1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <stdint.h>
18
19 #include <functional>
20
21 #include <unwindstack/Elf.h>
22 #include <unwindstack/MachineX86.h>
23 #include <unwindstack/MapInfo.h>
24 #include <unwindstack/Memory.h>
25 #include <unwindstack/RegsX86.h>
26 #include <unwindstack/UcontextX86.h>
27 #include <unwindstack/UserX86.h>
28
29 namespace unwindstack {
30
RegsX86()31 RegsX86::RegsX86() : RegsImpl<uint32_t>(X86_REG_LAST, Location(LOCATION_SP_OFFSET, -4)) {}
32
Arch()33 ArchEnum RegsX86::Arch() {
34 return ARCH_X86;
35 }
36
pc()37 uint64_t RegsX86::pc() {
38 return regs_[X86_REG_PC];
39 }
40
sp()41 uint64_t RegsX86::sp() {
42 return regs_[X86_REG_SP];
43 }
44
set_pc(uint64_t pc)45 void RegsX86::set_pc(uint64_t pc) {
46 regs_[X86_REG_PC] = static_cast<uint32_t>(pc);
47 }
48
set_sp(uint64_t sp)49 void RegsX86::set_sp(uint64_t sp) {
50 regs_[X86_REG_SP] = static_cast<uint32_t>(sp);
51 }
52
GetPcAdjustment(uint64_t rel_pc,Elf *)53 uint64_t RegsX86::GetPcAdjustment(uint64_t rel_pc, Elf*) {
54 if (rel_pc == 0) {
55 return 0;
56 }
57 return 1;
58 }
59
SetPcFromReturnAddress(Memory * process_memory)60 bool RegsX86::SetPcFromReturnAddress(Memory* process_memory) {
61 // Attempt to get the return address from the top of the stack.
62 uint32_t new_pc;
63 if (!process_memory->ReadFully(regs_[X86_REG_SP], &new_pc, sizeof(new_pc)) ||
64 new_pc == regs_[X86_REG_PC]) {
65 return false;
66 }
67
68 regs_[X86_REG_PC] = new_pc;
69 return true;
70 }
71
IterateRegisters(std::function<void (const char *,uint64_t)> fn)72 void RegsX86::IterateRegisters(std::function<void(const char*, uint64_t)> fn) {
73 fn("eax", regs_[X86_REG_EAX]);
74 fn("ebx", regs_[X86_REG_EBX]);
75 fn("ecx", regs_[X86_REG_ECX]);
76 fn("edx", regs_[X86_REG_EDX]);
77 fn("ebp", regs_[X86_REG_EBP]);
78 fn("edi", regs_[X86_REG_EDI]);
79 fn("esi", regs_[X86_REG_ESI]);
80 fn("esp", regs_[X86_REG_ESP]);
81 fn("eip", regs_[X86_REG_EIP]);
82 }
83
Read(void * user_data)84 Regs* RegsX86::Read(void* user_data) {
85 x86_user_regs* user = reinterpret_cast<x86_user_regs*>(user_data);
86
87 RegsX86* regs = new RegsX86();
88 (*regs)[X86_REG_EAX] = user->eax;
89 (*regs)[X86_REG_EBX] = user->ebx;
90 (*regs)[X86_REG_ECX] = user->ecx;
91 (*regs)[X86_REG_EDX] = user->edx;
92 (*regs)[X86_REG_EBP] = user->ebp;
93 (*regs)[X86_REG_EDI] = user->edi;
94 (*regs)[X86_REG_ESI] = user->esi;
95 (*regs)[X86_REG_ESP] = user->esp;
96 (*regs)[X86_REG_EIP] = user->eip;
97
98 return regs;
99 }
100
SetFromUcontext(x86_ucontext_t * ucontext)101 void RegsX86::SetFromUcontext(x86_ucontext_t* ucontext) {
102 // Put the registers in the expected order.
103 regs_[X86_REG_EDI] = ucontext->uc_mcontext.edi;
104 regs_[X86_REG_ESI] = ucontext->uc_mcontext.esi;
105 regs_[X86_REG_EBP] = ucontext->uc_mcontext.ebp;
106 regs_[X86_REG_ESP] = ucontext->uc_mcontext.esp;
107 regs_[X86_REG_EBX] = ucontext->uc_mcontext.ebx;
108 regs_[X86_REG_EDX] = ucontext->uc_mcontext.edx;
109 regs_[X86_REG_ECX] = ucontext->uc_mcontext.ecx;
110 regs_[X86_REG_EAX] = ucontext->uc_mcontext.eax;
111 regs_[X86_REG_EIP] = ucontext->uc_mcontext.eip;
112 }
113
CreateFromUcontext(void * ucontext)114 Regs* RegsX86::CreateFromUcontext(void* ucontext) {
115 x86_ucontext_t* x86_ucontext = reinterpret_cast<x86_ucontext_t*>(ucontext);
116
117 RegsX86* regs = new RegsX86();
118 regs->SetFromUcontext(x86_ucontext);
119 return regs;
120 }
121
StepIfSignalHandler(uint64_t rel_pc,Elf * elf,Memory * process_memory)122 bool RegsX86::StepIfSignalHandler(uint64_t rel_pc, Elf* elf, Memory* process_memory) {
123 uint64_t data;
124 Memory* elf_memory = elf->memory();
125 // Read from elf memory since it is usually more expensive to read from
126 // process memory.
127 if (!elf_memory->ReadFully(rel_pc, &data, sizeof(data))) {
128 return false;
129 }
130
131 if (data == 0x80cd00000077b858ULL) {
132 // Without SA_SIGINFO set, the return sequence is:
133 //
134 // __restore:
135 // 0x58 pop %eax
136 // 0xb8 0x77 0x00 0x00 0x00 movl 0x77,%eax
137 // 0xcd 0x80 int 0x80
138 //
139 // SP points at arguments:
140 // int signum
141 // struct sigcontext (same format as mcontext)
142 struct x86_mcontext_t context;
143 if (!process_memory->ReadFully(regs_[X86_REG_SP] + 4, &context, sizeof(context))) {
144 return false;
145 }
146 regs_[X86_REG_EBP] = context.ebp;
147 regs_[X86_REG_ESP] = context.esp;
148 regs_[X86_REG_EBX] = context.ebx;
149 regs_[X86_REG_EDX] = context.edx;
150 regs_[X86_REG_ECX] = context.ecx;
151 regs_[X86_REG_EAX] = context.eax;
152 regs_[X86_REG_EIP] = context.eip;
153 return true;
154 } else if ((data & 0x00ffffffffffffffULL) == 0x0080cd000000adb8ULL) {
155 // With SA_SIGINFO set, the return sequence is:
156 //
157 // __restore_rt:
158 // 0xb8 0xad 0x00 0x00 0x00 movl 0xad,%eax
159 // 0xcd 0x80 int 0x80
160 //
161 // SP points at arguments:
162 // int signum
163 // siginfo*
164 // ucontext*
165
166 // Get the location of the sigcontext data.
167 uint32_t ptr;
168 if (!process_memory->ReadFully(regs_[X86_REG_SP] + 8, &ptr, sizeof(ptr))) {
169 return false;
170 }
171 // Only read the portion of the data structure we care about.
172 x86_ucontext_t x86_ucontext;
173 if (!process_memory->ReadFully(ptr + 0x14, &x86_ucontext.uc_mcontext, sizeof(x86_mcontext_t))) {
174 return false;
175 }
176 SetFromUcontext(&x86_ucontext);
177 return true;
178 }
179 return false;
180 }
181
Clone()182 Regs* RegsX86::Clone() {
183 return new RegsX86(*this);
184 }
185
186 } // namespace unwindstack
187