MCExternalSymbolizer.cpp revision 261991
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 17using 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. 31bool 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 if (!SymbolLookUp) 47 return false; 48 uint64_t ReferenceType; 49 if (IsBranch) 50 ReferenceType = LLVMDisassembler_ReferenceType_In_Branch; 51 else 52 ReferenceType = LLVMDisassembler_ReferenceType_InOut_None; 53 const char *ReferenceName; 54 const char *Name = SymbolLookUp(DisInfo, Value, &ReferenceType, Address, 55 &ReferenceName); 56 if (Name) { 57 SymbolicOp.AddSymbol.Name = Name; 58 SymbolicOp.AddSymbol.Present = true; 59 } 60 // For branches always create an MCExpr so it gets printed as hex address. 61 else if (IsBranch) { 62 SymbolicOp.Value = Value; 63 } 64 if(ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub) 65 cStream << "symbol stub for: " << ReferenceName; 66 else if(ReferenceType == LLVMDisassembler_ReferenceType_Out_Objc_Message) 67 cStream << "Objc message: " << ReferenceName; 68 if (!Name && !IsBranch) 69 return false; 70 } 71 72 const MCExpr *Add = NULL; 73 if (SymbolicOp.AddSymbol.Present) { 74 if (SymbolicOp.AddSymbol.Name) { 75 StringRef Name(SymbolicOp.AddSymbol.Name); 76 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name); 77 Add = MCSymbolRefExpr::Create(Sym, Ctx); 78 } else { 79 Add = MCConstantExpr::Create((int)SymbolicOp.AddSymbol.Value, Ctx); 80 } 81 } 82 83 const MCExpr *Sub = NULL; 84 if (SymbolicOp.SubtractSymbol.Present) { 85 if (SymbolicOp.SubtractSymbol.Name) { 86 StringRef Name(SymbolicOp.SubtractSymbol.Name); 87 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name); 88 Sub = MCSymbolRefExpr::Create(Sym, Ctx); 89 } else { 90 Sub = MCConstantExpr::Create((int)SymbolicOp.SubtractSymbol.Value, Ctx); 91 } 92 } 93 94 const MCExpr *Off = NULL; 95 if (SymbolicOp.Value != 0) 96 Off = MCConstantExpr::Create(SymbolicOp.Value, Ctx); 97 98 const MCExpr *Expr; 99 if (Sub) { 100 const MCExpr *LHS; 101 if (Add) 102 LHS = MCBinaryExpr::CreateSub(Add, Sub, Ctx); 103 else 104 LHS = MCUnaryExpr::CreateMinus(Sub, Ctx); 105 if (Off != 0) 106 Expr = MCBinaryExpr::CreateAdd(LHS, Off, Ctx); 107 else 108 Expr = LHS; 109 } else if (Add) { 110 if (Off != 0) 111 Expr = MCBinaryExpr::CreateAdd(Add, Off, Ctx); 112 else 113 Expr = Add; 114 } else { 115 if (Off != 0) 116 Expr = Off; 117 else 118 Expr = MCConstantExpr::Create(0, Ctx); 119 } 120 121 Expr = RelInfo->createExprForCAPIVariantKind(Expr, SymbolicOp.VariantKind); 122 if (!Expr) 123 return false; 124 125 MI.addOperand(MCOperand::CreateExpr(Expr)); 126 return true; 127} 128 129// This function tries to add a comment as to what is being referenced by a load 130// instruction with the base register that is the Pc. These can often be values 131// in a literal pool near the Address of the instruction. The Address of the 132// instruction and its immediate Value are used as a possible literal pool entry. 133// The SymbolLookUp call back will return the name of a symbol referenced by the 134// literal pool's entry if the referenced address is that of a symbol. Or it 135// will return a pointer to a literal 'C' string if the referenced address of 136// the literal pool's entry is an address into a section with C string literals. 137// Or if the reference is to an Objective-C data structure it will return a 138// specific reference type for it and a string. 139void MCExternalSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream, 140 int64_t Value, 141 uint64_t Address) { 142 if (SymbolLookUp) { 143 uint64_t ReferenceType = LLVMDisassembler_ReferenceType_In_PCrel_Load; 144 const char *ReferenceName; 145 (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName); 146 if(ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr) 147 cStream << "literal pool symbol address: " << ReferenceName; 148 else if(ReferenceType == 149 LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr) 150 cStream << "literal pool for: \"" << ReferenceName << "\""; 151 else if(ReferenceType == 152 LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref) 153 cStream << "Objc cfstring ref: @\"" << ReferenceName << "\""; 154 else if(ReferenceType == 155 LLVMDisassembler_ReferenceType_Out_Objc_Message) 156 cStream << "Objc message: " << ReferenceName; 157 else if(ReferenceType == 158 LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref) 159 cStream << "Objc message ref: " << ReferenceName; 160 else if(ReferenceType == 161 LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref) 162 cStream << "Objc selector ref: " << ReferenceName; 163 else if(ReferenceType == 164 LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref) 165 cStream << "Objc class ref: " << ReferenceName; 166 } 167} 168 169namespace llvm { 170MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo, 171 LLVMSymbolLookupCallback SymbolLookUp, 172 void *DisInfo, 173 MCContext *Ctx, 174 MCRelocationInfo *RelInfo) { 175 assert(Ctx != 0 && "No MCContext given for symbolic disassembly"); 176 177 OwningPtr<MCRelocationInfo> RelInfoOwingPtr(RelInfo); 178 return new MCExternalSymbolizer(*Ctx, RelInfoOwingPtr, GetOpInfo, 179 SymbolLookUp, DisInfo); 180} 181} 182