1 //===- AArch64ExternalSymbolizer.cpp - Symbolizer for AArch64 ---*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "AArch64ExternalSymbolizer.h" 10 #include "MCTargetDesc/AArch64AddressingModes.h" 11 #include "Utils/AArch64BaseInfo.h" 12 #include "llvm/MC/MCContext.h" 13 #include "llvm/MC/MCExpr.h" 14 #include "llvm/MC/MCInst.h" 15 #include "llvm/MC/MCRegisterInfo.h" 16 #include "llvm/Support/Format.h" 17 #include "llvm/Support/raw_ostream.h" 18 19 using namespace llvm; 20 21 #define DEBUG_TYPE "aarch64-disassembler" 22 23 static MCSymbolRefExpr::VariantKind 24 getVariant(uint64_t LLVMDisassembler_VariantKind) { 25 switch (LLVMDisassembler_VariantKind) { 26 case LLVMDisassembler_VariantKind_None: 27 return MCSymbolRefExpr::VK_None; 28 case LLVMDisassembler_VariantKind_ARM64_PAGE: 29 return MCSymbolRefExpr::VK_PAGE; 30 case LLVMDisassembler_VariantKind_ARM64_PAGEOFF: 31 return MCSymbolRefExpr::VK_PAGEOFF; 32 case LLVMDisassembler_VariantKind_ARM64_GOTPAGE: 33 return MCSymbolRefExpr::VK_GOTPAGE; 34 case LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF: 35 return MCSymbolRefExpr::VK_GOTPAGEOFF; 36 case LLVMDisassembler_VariantKind_ARM64_TLVP: 37 return MCSymbolRefExpr::VK_TLVPPAGE; 38 case LLVMDisassembler_VariantKind_ARM64_TLVOFF: 39 return MCSymbolRefExpr::VK_TLVPPAGEOFF; 40 default: 41 llvm_unreachable("bad LLVMDisassembler_VariantKind"); 42 } 43 } 44 45 /// tryAddingSymbolicOperand - tryAddingSymbolicOperand trys to add a symbolic 46 /// operand in place of the immediate Value in the MCInst. The immediate 47 /// Value has not had any PC adjustment made by the caller. If the instruction 48 /// is a branch that adds the PC to the immediate Value then isBranch is 49 /// Success, else Fail. If GetOpInfo is non-null, then it is called to get any 50 /// symbolic information at the Address for this instrution. If that returns 51 /// non-zero then the symbolic information it returns is used to create an 52 /// MCExpr and that is added as an operand to the MCInst. If GetOpInfo() 53 /// returns zero and isBranch is Success then a symbol look up for 54 /// Address + Value is done and if a symbol is found an MCExpr is created with 55 /// that, else an MCExpr with Address + Value is created. If GetOpInfo() 56 /// returns zero and isBranch is Fail then the Opcode of the MCInst is 57 /// tested and for ADRP an other instructions that help to load of pointers 58 /// a symbol look up is done to see it is returns a specific reference type 59 /// to add to the comment stream. This function returns Success if it adds 60 /// an operand to the MCInst and Fail otherwise. 61 bool AArch64ExternalSymbolizer::tryAddingSymbolicOperand( 62 MCInst &MI, raw_ostream &CommentStream, int64_t Value, uint64_t Address, 63 bool IsBranch, uint64_t Offset, uint64_t InstSize) { 64 if (!SymbolLookUp) 65 return false; 66 // FIXME: This method shares a lot of code with 67 // MCExternalSymbolizer::tryAddingSymbolicOperand. It may be possible 68 // refactor the MCExternalSymbolizer interface to allow more of this 69 // implementation to be shared. 70 // 71 struct LLVMOpInfo1 SymbolicOp; 72 memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1)); 73 SymbolicOp.Value = Value; 74 uint64_t ReferenceType; 75 const char *ReferenceName; 76 if (!GetOpInfo || 77 !GetOpInfo(DisInfo, Address, 0 /* Offset */, InstSize, 1, &SymbolicOp)) { 78 if (IsBranch) { 79 ReferenceType = LLVMDisassembler_ReferenceType_In_Branch; 80 const char *Name = SymbolLookUp(DisInfo, Address + Value, &ReferenceType, 81 Address, &ReferenceName); 82 if (Name) { 83 SymbolicOp.AddSymbol.Name = Name; 84 SymbolicOp.AddSymbol.Present = true; 85 SymbolicOp.Value = 0; 86 } else { 87 SymbolicOp.Value = Address + Value; 88 } 89 if (ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub) 90 CommentStream << "symbol stub for: " << ReferenceName; 91 else if (ReferenceType == 92 LLVMDisassembler_ReferenceType_Out_Objc_Message) 93 CommentStream << "Objc message: " << ReferenceName; 94 } else if (MI.getOpcode() == AArch64::ADRP) { 95 ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADRP; 96 // otool expects the fully encoded ADRP instruction to be passed in as 97 // the value here, so reconstruct it: 98 const MCRegisterInfo &MCRI = *Ctx.getRegisterInfo(); 99 uint32_t EncodedInst = 0x90000000; 100 EncodedInst |= (Value & 0x3) << 29; // immlo 101 EncodedInst |= ((Value >> 2) & 0x7FFFF) << 5; // immhi 102 EncodedInst |= MCRI.getEncodingValue(MI.getOperand(0).getReg()); // reg 103 SymbolLookUp(DisInfo, EncodedInst, &ReferenceType, Address, 104 &ReferenceName); 105 CommentStream << format("0x%llx", (0xfffffffffffff000LL & Address) + 106 Value * 0x1000); 107 } else if (MI.getOpcode() == AArch64::ADDXri || 108 MI.getOpcode() == AArch64::LDRXui || 109 MI.getOpcode() == AArch64::LDRXl || 110 MI.getOpcode() == AArch64::ADR) { 111 if (MI.getOpcode() == AArch64::ADDXri) 112 ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADDXri; 113 else if (MI.getOpcode() == AArch64::LDRXui) 114 ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_LDRXui; 115 if (MI.getOpcode() == AArch64::LDRXl) { 116 ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_LDRXl; 117 SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address, 118 &ReferenceName); 119 } else if (MI.getOpcode() == AArch64::ADR) { 120 ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADR; 121 SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address, 122 &ReferenceName); 123 } else { 124 const MCRegisterInfo &MCRI = *Ctx.getRegisterInfo(); 125 // otool expects the fully encoded ADD/LDR instruction to be passed in 126 // as the value here, so reconstruct it: 127 unsigned EncodedInst = 128 MI.getOpcode() == AArch64::ADDXri ? 0x91000000: 0xF9400000; 129 EncodedInst |= Value << 10; // imm12 [+ shift:2 for ADD] 130 EncodedInst |= 131 MCRI.getEncodingValue(MI.getOperand(1).getReg()) << 5; // Rn 132 EncodedInst |= MCRI.getEncodingValue(MI.getOperand(0).getReg()); // Rd 133 134 SymbolLookUp(DisInfo, EncodedInst, &ReferenceType, Address, 135 &ReferenceName); 136 } 137 if (ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr) 138 CommentStream << "literal pool symbol address: " << ReferenceName; 139 else if (ReferenceType == 140 LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr) { 141 CommentStream << "literal pool for: \""; 142 CommentStream.write_escaped(ReferenceName); 143 CommentStream << "\""; 144 } else if (ReferenceType == 145 LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref) 146 CommentStream << "Objc cfstring ref: @\"" << ReferenceName << "\""; 147 else if (ReferenceType == 148 LLVMDisassembler_ReferenceType_Out_Objc_Message) 149 CommentStream << "Objc message: " << ReferenceName; 150 else if (ReferenceType == 151 LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref) 152 CommentStream << "Objc message ref: " << ReferenceName; 153 else if (ReferenceType == 154 LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref) 155 CommentStream << "Objc selector ref: " << ReferenceName; 156 else if (ReferenceType == 157 LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref) 158 CommentStream << "Objc class ref: " << ReferenceName; 159 // For these instructions, the SymbolLookUp() above is just to get the 160 // ReferenceType and ReferenceName. We want to make sure not to 161 // fall through so we don't build an MCExpr to leave the disassembly 162 // of the immediate values of these instructions to the InstPrinter. 163 return false; 164 } else { 165 return false; 166 } 167 } 168 169 const MCExpr *Add = nullptr; 170 if (SymbolicOp.AddSymbol.Present) { 171 if (SymbolicOp.AddSymbol.Name) { 172 StringRef Name(SymbolicOp.AddSymbol.Name); 173 MCSymbol *Sym = Ctx.getOrCreateSymbol(Name); 174 MCSymbolRefExpr::VariantKind Variant = getVariant(SymbolicOp.VariantKind); 175 if (Variant != MCSymbolRefExpr::VK_None) 176 Add = MCSymbolRefExpr::create(Sym, Variant, Ctx); 177 else 178 Add = MCSymbolRefExpr::create(Sym, Ctx); 179 } else { 180 Add = MCConstantExpr::create(SymbolicOp.AddSymbol.Value, Ctx); 181 } 182 } 183 184 const MCExpr *Sub = nullptr; 185 if (SymbolicOp.SubtractSymbol.Present) { 186 if (SymbolicOp.SubtractSymbol.Name) { 187 StringRef Name(SymbolicOp.SubtractSymbol.Name); 188 MCSymbol *Sym = Ctx.getOrCreateSymbol(Name); 189 Sub = MCSymbolRefExpr::create(Sym, Ctx); 190 } else { 191 Sub = MCConstantExpr::create(SymbolicOp.SubtractSymbol.Value, Ctx); 192 } 193 } 194 195 const MCExpr *Off = nullptr; 196 if (SymbolicOp.Value != 0) 197 Off = MCConstantExpr::create(SymbolicOp.Value, Ctx); 198 199 const MCExpr *Expr; 200 if (Sub) { 201 const MCExpr *LHS; 202 if (Add) 203 LHS = MCBinaryExpr::createSub(Add, Sub, Ctx); 204 else 205 LHS = MCUnaryExpr::createMinus(Sub, Ctx); 206 if (Off) 207 Expr = MCBinaryExpr::createAdd(LHS, Off, Ctx); 208 else 209 Expr = LHS; 210 } else if (Add) { 211 if (Off) 212 Expr = MCBinaryExpr::createAdd(Add, Off, Ctx); 213 else 214 Expr = Add; 215 } else { 216 if (Off) 217 Expr = Off; 218 else 219 Expr = MCConstantExpr::create(0, Ctx); 220 } 221 222 MI.addOperand(MCOperand::createExpr(Expr)); 223 224 return true; 225 } 226