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.
tryAddingSymbolicOperand(MCInst & MI,raw_ostream & cStream,int64_t Value,uint64_t Address,bool IsBranch,uint64_t Offset,uint64_t InstSize)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 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 if (!Name && !IsBranch)
67 return false;
68 }
69
70 const MCExpr *Add = NULL;
71 if (SymbolicOp.AddSymbol.Present) {
72 if (SymbolicOp.AddSymbol.Name) {
73 StringRef Name(SymbolicOp.AddSymbol.Name);
74 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name);
75 Add = MCSymbolRefExpr::Create(Sym, Ctx);
76 } else {
77 Add = MCConstantExpr::Create((int)SymbolicOp.AddSymbol.Value, Ctx);
78 }
79 }
80
81 const MCExpr *Sub = NULL;
82 if (SymbolicOp.SubtractSymbol.Present) {
83 if (SymbolicOp.SubtractSymbol.Name) {
84 StringRef Name(SymbolicOp.SubtractSymbol.Name);
85 MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name);
86 Sub = MCSymbolRefExpr::Create(Sym, Ctx);
87 } else {
88 Sub = MCConstantExpr::Create((int)SymbolicOp.SubtractSymbol.Value, Ctx);
89 }
90 }
91
92 const MCExpr *Off = NULL;
93 if (SymbolicOp.Value != 0)
94 Off = MCConstantExpr::Create(SymbolicOp.Value, Ctx);
95
96 const MCExpr *Expr;
97 if (Sub) {
98 const MCExpr *LHS;
99 if (Add)
100 LHS = MCBinaryExpr::CreateSub(Add, Sub, Ctx);
101 else
102 LHS = MCUnaryExpr::CreateMinus(Sub, Ctx);
103 if (Off != 0)
104 Expr = MCBinaryExpr::CreateAdd(LHS, Off, Ctx);
105 else
106 Expr = LHS;
107 } else if (Add) {
108 if (Off != 0)
109 Expr = MCBinaryExpr::CreateAdd(Add, Off, Ctx);
110 else
111 Expr = Add;
112 } else {
113 if (Off != 0)
114 Expr = Off;
115 else
116 Expr = MCConstantExpr::Create(0, Ctx);
117 }
118
119 Expr = RelInfo->createExprForCAPIVariantKind(Expr, SymbolicOp.VariantKind);
120 if (!Expr)
121 return false;
122
123 MI.addOperand(MCOperand::CreateExpr(Expr));
124 return true;
125 }
126
127 // This function tries to add a comment as to what is being referenced by a load
128 // instruction with the base register that is the Pc. These can often be values
129 // in a literal pool near the Address of the instruction. The Address of the
130 // instruction and its immediate Value are used as a possible literal pool entry.
131 // The SymbolLookUp call back will return the name of a symbol referenced by the
132 // literal pool's entry if the referenced address is that of a symbol. Or it
133 // will return a pointer to a literal 'C' string if the referenced address of
134 // the literal pool's entry is an address into a section with C string literals.
tryAddingPcLoadReferenceComment(raw_ostream & cStream,int64_t Value,uint64_t Address)135 void MCExternalSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream,
136 int64_t Value,
137 uint64_t Address) {
138 if (SymbolLookUp) {
139 uint64_t ReferenceType = LLVMDisassembler_ReferenceType_In_PCrel_Load;
140 const char *ReferenceName;
141 (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName);
142 if(ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr ||
143 ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr)
144 cStream << "literal pool for: " << ReferenceName;
145 }
146 }
147
148 namespace llvm {
createMCSymbolizer(StringRef TT,LLVMOpInfoCallback GetOpInfo,LLVMSymbolLookupCallback SymbolLookUp,void * DisInfo,MCContext * Ctx,MCRelocationInfo * RelInfo)149 MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
150 LLVMSymbolLookupCallback SymbolLookUp,
151 void *DisInfo,
152 MCContext *Ctx,
153 MCRelocationInfo *RelInfo) {
154 assert(Ctx != 0 && "No MCContext given for symbolic disassembly");
155
156 OwningPtr<MCRelocationInfo> RelInfoOwingPtr(RelInfo);
157 return new MCExternalSymbolizer(*Ctx, RelInfoOwingPtr, GetOpInfo,
158 SymbolLookUp, DisInfo);
159 }
160 }
161