lib/MC/MCExternalSymbolizer.cpp

   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     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.
 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 {
 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 }