1 //===-- lib/MC/MCExternalSymbolizer.cpp - External symbolizer ---*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/MC/MCExternalSymbolizer.h" 11 #include "llvm/MC/MCContext.h" 12 #include "llvm/MC/MCExpr.h" 13 #include "llvm/MC/MCInst.h" 14 #include "llvm/Support/raw_ostream.h" 15 #include <cstring> 16 17 using namespace llvm; 18 19 // This function tries to add a symbolic operand in place of the immediate 20 // Value in the MCInst. The immediate Value has had any PC adjustment made by 21 // the caller. If the instruction is a branch instruction then IsBranch is true, 22 // else false. If the getOpInfo() function was set as part of the 23 // setupForSymbolicDisassembly() call then that function is called to get any 24 // symbolic information at the Address for this instruction. If that returns 25 // non-zero then the symbolic information it returns is used to create an MCExpr 26 // and that is added as an operand to the MCInst. If getOpInfo() returns zero 27 // and IsBranch is true then a symbol look up for Value is done and if a symbol 28 // is found an MCExpr is created with that, else an MCExpr with Value is 29 // created. This function returns true if it adds an operand to the MCInst and 30 // false otherwise. 31 bool MCExternalSymbolizer::tryAddingSymbolicOperand(MCInst &MI, 32 raw_ostream &cStream, 33 int64_t Value, 34 uint64_t Address, 35 bool IsBranch, 36 uint64_t Offset, 37 uint64_t InstSize) { 38 struct LLVMOpInfo1 SymbolicOp; 39 std::memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1)); 40 SymbolicOp.Value = Value; 41 42 if (!GetOpInfo || 43 !GetOpInfo(DisInfo, Address, Offset, InstSize, 1, &SymbolicOp)) { 44 // Clear SymbolicOp.Value from above and also all other fields. 45 std::memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1)); 46 47 // At this point, GetOpInfo() did not find any relocation information about 48 // this operand and we are left to use the SymbolLookUp() call back to guess 49 // if the Value is the address of a symbol. In the case this is a branch 50 // that always makes sense to guess. But in the case of an immediate it is 51 // a bit more questionable if it is an address of a symbol or some other 52 // reference. So if the immediate Value comes from a width of 1 byte, 53 // InstSize, we will not guess it is an address of a symbol. Because in 54 // object files assembled starting at address 0 this usually leads to 55 // incorrect symbolication. 56 if (!SymbolLookUp || (InstSize == 1 && !IsBranch)) 57 return false; 58 59 uint64_t ReferenceType; 60 if (IsBranch) 61 ReferenceType = LLVMDisassembler_ReferenceType_In_Branch; 62 else 63 ReferenceType = LLVMDisassembler_ReferenceType_InOut_None; 64 const char *ReferenceName; 65 const char *Name = SymbolLookUp(DisInfo, Value, &ReferenceType, Address, 66 &ReferenceName); 67 if (Name) { 68 SymbolicOp.AddSymbol.Name = Name; 69 SymbolicOp.AddSymbol.Present = true; 70 // If Name is a C++ symbol name put the human readable name in a comment. 71 if(ReferenceType == LLVMDisassembler_ReferenceType_DeMangled_Name) 72 cStream << ReferenceName; 73 } 74 // For branches always create an MCExpr so it gets printed as hex address. 75 else if (IsBranch) { 76 SymbolicOp.Value = Value; 77 } 78 if(ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub) 79 cStream << "symbol stub for: " << ReferenceName; 80 else if(ReferenceType == LLVMDisassembler_ReferenceType_Out_Objc_Message) 81 cStream << "Objc message: " << ReferenceName; 82 if (!Name && !IsBranch) 83 return false; 84 } 85 86 const MCExpr *Add = nullptr; 87 if (SymbolicOp.AddSymbol.Present) { 88 if (SymbolicOp.AddSymbol.Name) { 89 StringRef Name(SymbolicOp.AddSymbol.Name); 90 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name); 91 Add = MCSymbolRefExpr::Create(Sym, Ctx); 92 } else { 93 Add = MCConstantExpr::Create((int)SymbolicOp.AddSymbol.Value, Ctx); 94 } 95 } 96 97 const MCExpr *Sub = nullptr; 98 if (SymbolicOp.SubtractSymbol.Present) { 99 if (SymbolicOp.SubtractSymbol.Name) { 100 StringRef Name(SymbolicOp.SubtractSymbol.Name); 101 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name); 102 Sub = MCSymbolRefExpr::Create(Sym, Ctx); 103 } else { 104 Sub = MCConstantExpr::Create((int)SymbolicOp.SubtractSymbol.Value, Ctx); 105 } 106 } 107 108 const MCExpr *Off = nullptr; 109 if (SymbolicOp.Value != 0) 110 Off = MCConstantExpr::Create(SymbolicOp.Value, Ctx); 111 112 const MCExpr *Expr; 113 if (Sub) { 114 const MCExpr *LHS; 115 if (Add) 116 LHS = MCBinaryExpr::CreateSub(Add, Sub, Ctx); 117 else 118 LHS = MCUnaryExpr::CreateMinus(Sub, Ctx); 119 if (Off) 120 Expr = MCBinaryExpr::CreateAdd(LHS, Off, Ctx); 121 else 122 Expr = LHS; 123 } else if (Add) { 124 if (Off) 125 Expr = MCBinaryExpr::CreateAdd(Add, Off, Ctx); 126 else 127 Expr = Add; 128 } else { 129 if (Off) 130 Expr = Off; 131 else 132 Expr = MCConstantExpr::Create(0, Ctx); 133 } 134 135 Expr = RelInfo->createExprForCAPIVariantKind(Expr, SymbolicOp.VariantKind); 136 if (!Expr) 137 return false; 138 139 MI.addOperand(MCOperand::CreateExpr(Expr)); 140 return true; 141 } 142 143 // This function tries to add a comment as to what is being referenced by a load 144 // instruction with the base register that is the Pc. These can often be values 145 // in a literal pool near the Address of the instruction. The Address of the 146 // instruction and its immediate Value are used as a possible literal pool entry. 147 // The SymbolLookUp call back will return the name of a symbol referenced by the 148 // literal pool's entry if the referenced address is that of a symbol. Or it 149 // will return a pointer to a literal 'C' string if the referenced address of 150 // the literal pool's entry is an address into a section with C string literals. 151 // Or if the reference is to an Objective-C data structure it will return a 152 // specific reference type for it and a string. 153 void MCExternalSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream, 154 int64_t Value, 155 uint64_t Address) { 156 if (SymbolLookUp) { 157 uint64_t ReferenceType = LLVMDisassembler_ReferenceType_In_PCrel_Load; 158 const char *ReferenceName; 159 (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName); 160 if(ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr) 161 cStream << "literal pool symbol address: " << ReferenceName; 162 else if(ReferenceType == 163 LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr) { 164 cStream << "literal pool for: \""; 165 cStream.write_escaped(ReferenceName); 166 cStream << "\""; 167 } 168 else if(ReferenceType == 169 LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref) 170 cStream << "Objc cfstring ref: @\"" << ReferenceName << "\""; 171 else if(ReferenceType == 172 LLVMDisassembler_ReferenceType_Out_Objc_Message) 173 cStream << "Objc message: " << ReferenceName; 174 else if(ReferenceType == 175 LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref) 176 cStream << "Objc message ref: " << ReferenceName; 177 else if(ReferenceType == 178 LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref) 179 cStream << "Objc selector ref: " << ReferenceName; 180 else if(ReferenceType == 181 LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref) 182 cStream << "Objc class ref: " << ReferenceName; 183 } 184 } 185 186 namespace llvm { 187 MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, 188 LLVMSymbolLookupCallback SymbolLookUp, 189 void *DisInfo, 190 MCContext *Ctx, 191 MCRelocationInfo *RelInfo) { 192 assert(Ctx && "No MCContext given for symbolic disassembly"); 193 194 return new MCExternalSymbolizer(*Ctx, 195 std::unique_ptr<MCRelocationInfo>(RelInfo), 196 GetOpInfo, SymbolLookUp, DisInfo); 197 } 198 } 199
