1 /* 2 * Copyright (C) 2017 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/MachineMips64.h> 23 #include <unwindstack/MapInfo.h> 24 #include <unwindstack/Memory.h> 25 #include <unwindstack/RegsMips64.h> 26 #include <unwindstack/UcontextMips64.h> 27 #include <unwindstack/UserMips64.h> 28 29 namespace unwindstack { 30 31 RegsMips64::RegsMips64() 32 : RegsImpl<uint64_t>(MIPS64_REG_LAST, Location(LOCATION_REGISTER, MIPS64_REG_RA)) {} 33 34 ArchEnum RegsMips64::Arch() { 35 return ARCH_MIPS64; 36 } 37 38 uint64_t RegsMips64::pc() { 39 return regs_[MIPS64_REG_PC]; 40 } 41 42 uint64_t RegsMips64::sp() { 43 return regs_[MIPS64_REG_SP]; 44 } 45 46 void RegsMips64::set_pc(uint64_t pc) { 47 regs_[MIPS64_REG_PC] = pc; 48 } 49 50 void RegsMips64::set_sp(uint64_t sp) { 51 regs_[MIPS64_REG_SP] = sp; 52 } 53 54 uint64_t RegsMips64::GetPcAdjustment(uint64_t rel_pc, Elf*) { 55 if (rel_pc < 8) { 56 return 0; 57 } 58 // For now, just assume no compact branches 59 return 8; 60 } 61 62 bool RegsMips64::SetPcFromReturnAddress(Memory*) { 63 uint64_t ra = regs_[MIPS64_REG_RA]; 64 if (regs_[MIPS64_REG_PC] == ra) { 65 return false; 66 } 67 68 regs_[MIPS64_REG_PC] = ra; 69 return true; 70 } 71 72 void RegsMips64::IterateRegisters(std::function<void(const char*, uint64_t)> fn) { 73 fn("r0", regs_[MIPS64_REG_R0]); 74 fn("r1", regs_[MIPS64_REG_R1]); 75 fn("r2", regs_[MIPS64_REG_R2]); 76 fn("r3", regs_[MIPS64_REG_R3]); 77 fn("r4", regs_[MIPS64_REG_R4]); 78 fn("r5", regs_[MIPS64_REG_R5]); 79 fn("r6", regs_[MIPS64_REG_R6]); 80 fn("r7", regs_[MIPS64_REG_R7]); 81 fn("r8", regs_[MIPS64_REG_R8]); 82 fn("r9", regs_[MIPS64_REG_R9]); 83 fn("r10", regs_[MIPS64_REG_R10]); 84 fn("r11", regs_[MIPS64_REG_R11]); 85 fn("r12", regs_[MIPS64_REG_R12]); 86 fn("r13", regs_[MIPS64_REG_R13]); 87 fn("r14", regs_[MIPS64_REG_R14]); 88 fn("r15", regs_[MIPS64_REG_R15]); 89 fn("r16", regs_[MIPS64_REG_R16]); 90 fn("r17", regs_[MIPS64_REG_R17]); 91 fn("r18", regs_[MIPS64_REG_R18]); 92 fn("r19", regs_[MIPS64_REG_R19]); 93 fn("r20", regs_[MIPS64_REG_R20]); 94 fn("r21", regs_[MIPS64_REG_R21]); 95 fn("r22", regs_[MIPS64_REG_R22]); 96 fn("r23", regs_[MIPS64_REG_R23]); 97 fn("r24", regs_[MIPS64_REG_R24]); 98 fn("r25", regs_[MIPS64_REG_R25]); 99 fn("r26", regs_[MIPS64_REG_R26]); 100 fn("r27", regs_[MIPS64_REG_R27]); 101 fn("r28", regs_[MIPS64_REG_R28]); 102 fn("sp", regs_[MIPS64_REG_SP]); 103 fn("r30", regs_[MIPS64_REG_R30]); 104 fn("ra", regs_[MIPS64_REG_RA]); 105 fn("pc", regs_[MIPS64_REG_PC]); 106 } 107 108 Regs* RegsMips64::Read(void* remote_data) { 109 mips64_user_regs* user = reinterpret_cast<mips64_user_regs*>(remote_data); 110 RegsMips64* regs = new RegsMips64(); 111 uint64_t* reg_data = reinterpret_cast<uint64_t*>(regs->RawData()); 112 113 memcpy(regs->RawData(), &user->regs[MIPS64_EF_R0], (MIPS64_REG_R31 + 1) * sizeof(uint64_t)); 114 115 reg_data[MIPS64_REG_PC] = user->regs[MIPS64_EF_CP0_EPC]; 116 return regs; 117 } 118 119 Regs* RegsMips64::CreateFromUcontext(void* ucontext) { 120 mips64_ucontext_t* mips64_ucontext = reinterpret_cast<mips64_ucontext_t*>(ucontext); 121 122 RegsMips64* regs = new RegsMips64(); 123 // Copy 64 bit sc_regs over to 64 bit regs 124 memcpy(regs->RawData(), &mips64_ucontext->uc_mcontext.sc_regs[0], 32 * sizeof(uint64_t)); 125 (*regs)[MIPS64_REG_PC] = mips64_ucontext->uc_mcontext.sc_pc; 126 return regs; 127 } 128 129 bool RegsMips64::StepIfSignalHandler(uint64_t rel_pc, Elf* elf, Memory* process_memory) { 130 uint64_t data; 131 Memory* elf_memory = elf->memory(); 132 // Read from elf memory since it is usually more expensive to read from 133 // process memory. 134 if (!elf_memory->Read(rel_pc, &data, sizeof(data))) { 135 return false; 136 } 137 138 // Look for the kernel sigreturn function. 139 // __vdso_rt_sigreturn: 140 // 0x2402145b li v0, 0x145b 141 // 0x0000000c syscall 142 if (data != 0x0000000c2402145bULL) { 143 return false; 144 } 145 146 // vdso_rt_sigreturn => read rt_sigframe 147 // offset = siginfo offset + sizeof(siginfo) + uc_mcontext offset 148 // read 64 bit sc_regs[32] from stack into 64 bit regs_ 149 uint64_t sp = regs_[MIPS64_REG_SP]; 150 if (!process_memory->Read(sp + 24 + 128 + 40, regs_.data(), 151 sizeof(uint64_t) * (MIPS64_REG_LAST - 1))) { 152 return false; 153 } 154 155 // offset = siginfo offset + sizeof(siginfo) + uc_mcontext offset + sc_pc offset 156 // read 64 bit sc_pc from stack into 64 bit regs_[MIPS64_REG_PC] 157 if (!process_memory->Read(sp + 24 + 128 + 40 + 576, ®s_[MIPS64_REG_PC], sizeof(uint64_t))) { 158 return false; 159 } 160 return true; 161 } 162 163 Regs* RegsMips64::Clone() { 164 return new RegsMips64(*this); 165 } 166 167 } // namespace unwindstack 168
