MCExternalSymbolizer.cpp revision 263508 
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