LLVM 19.0.0git
MCExternalSymbolizer.cpp
Go to the documentation of this file.
1//===-- MCExternalSymbolizer.cpp - External symbolizer --------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
10#include "llvm/MC/MCContext.h"
11#include "llvm/MC/MCExpr.h"
12#include "llvm/MC/MCInst.h"
14#include <cstring>
15
16using namespace llvm;
17
18namespace llvm {
19class Triple;
20}
21
22// This function tries to add a symbolic operand in place of the immediate
23// Value in the MCInst. The immediate Value has had any PC adjustment made by
24// the caller. If the instruction is a branch instruction then IsBranch is true,
25// else false. If the getOpInfo() function was set as part of the
26// setupForSymbolicDisassembly() call then that function is called to get any
27// symbolic information at the Address for this instruction. If that returns
28// non-zero then the symbolic information it returns is used to create an MCExpr
29// and that is added as an operand to the MCInst. If getOpInfo() returns zero
30// and IsBranch is true then a symbol look up for Value is done and if a symbol
31// is found an MCExpr is created with that, else an MCExpr with Value is
32// created. This function returns true if it adds an operand to the MCInst and
33// false otherwise.
35 MCInst &MI, raw_ostream &cStream, int64_t Value, uint64_t Address,
36 bool IsBranch, uint64_t Offset, uint64_t OpSize, uint64_t InstSize) {
37 struct LLVMOpInfo1 SymbolicOp;
38 std::memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
39 SymbolicOp.Value = Value;
40
41 if (!GetOpInfo ||
42 !GetOpInfo(DisInfo, Address, Offset, OpSize, InstSize, 1, &SymbolicOp)) {
43 // Clear SymbolicOp.Value from above and also all other fields.
44 std::memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
45
46 // At this point, GetOpInfo() did not find any relocation information about
47 // this operand and we are left to use the SymbolLookUp() call back to guess
48 // if the Value is the address of a symbol. In the case this is a branch
49 // that always makes sense to guess. But in the case of an immediate it is
50 // a bit more questionable if it is an address of a symbol or some other
51 // reference. So if the immediate Value comes from a width of 1 byte,
52 // OpSize, we will not guess it is an address of a symbol. Because in
53 // object files assembled starting at address 0 this usually leads to
54 // incorrect symbolication.
55 if (!SymbolLookUp || (OpSize == 1 && !IsBranch))
56 return false;
57
59 if (IsBranch)
61 else
63 const char *ReferenceName;
65 &ReferenceName);
66 if (Name) {
67 SymbolicOp.AddSymbol.Name = Name;
68 SymbolicOp.AddSymbol.Present = true;
69 // If Name is a C++ symbol name put the human readable name in a comment.
71 cStream << ReferenceName;
72 }
73 // For branches always create an MCExpr so it gets printed as hex address.
74 else if (IsBranch) {
75 SymbolicOp.Value = Value;
76 }
78 cStream << "symbol stub for: " << ReferenceName;
80 cStream << "Objc message: " << ReferenceName;
81 if (!Name && !IsBranch)
82 return false;
83 }
84
85 const MCExpr *Add = nullptr;
86 if (SymbolicOp.AddSymbol.Present) {
87 if (SymbolicOp.AddSymbol.Name) {
88 StringRef Name(SymbolicOp.AddSymbol.Name);
91 } else {
92 Add = MCConstantExpr::create((int)SymbolicOp.AddSymbol.Value, Ctx);
93 }
94 }
95
96 const MCExpr *Sub = nullptr;
97 if (SymbolicOp.SubtractSymbol.Present) {
98 if (SymbolicOp.SubtractSymbol.Name) {
102 } else {
103 Sub = MCConstantExpr::create((int)SymbolicOp.SubtractSymbol.Value, Ctx);
104 }
105 }
106
107 const MCExpr *Off = nullptr;
108 if (SymbolicOp.Value != 0)
109 Off = MCConstantExpr::create(SymbolicOp.Value, Ctx);
110
111 const MCExpr *Expr;
112 if (Sub) {
113 const MCExpr *LHS;
114 if (Add)
116 else
118 if (Off)
119 Expr = MCBinaryExpr::createAdd(LHS, Off, Ctx);
120 else
121 Expr = LHS;
122 } else if (Add) {
123 if (Off)
124 Expr = MCBinaryExpr::createAdd(Add, Off, Ctx);
125 else
126 Expr = Add;
127 } else {
128 if (Off)
129 Expr = Off;
130 else
131 Expr = MCConstantExpr::create(0, Ctx);
132 }
133
134 Expr = RelInfo->createExprForCAPIVariantKind(Expr, SymbolicOp.VariantKind);
135 if (!Expr)
136 return false;
137
138 MI.addOperand(MCOperand::createExpr(Expr));
139 return true;
140}
141
142// This function tries to add a comment as to what is being referenced by a load
143// instruction with the base register that is the Pc. These can often be values
144// in a literal pool near the Address of the instruction. The Address of the
145// instruction and its immediate Value are used as a possible literal pool entry.
146// The SymbolLookUp call back will return the name of a symbol referenced by the
147// literal pool's entry if the referenced address is that of a symbol. Or it
148// will return a pointer to a literal 'C' string if the referenced address of
149// the literal pool's entry is an address into a section with C string literals.
150// Or if the reference is to an Objective-C data structure it will return a
151// specific reference type for it and a string.
153 int64_t Value,
155 if (SymbolLookUp) {
157 const char *ReferenceName;
158 (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName);
160 cStream << "literal pool symbol address: " << ReferenceName;
161 else if(ReferenceType ==
163 cStream << "literal pool for: \"";
164 cStream.write_escaped(ReferenceName);
165 cStream << "\"";
166 }
167 else if(ReferenceType ==
169 cStream << "Objc cfstring ref: @\"" << ReferenceName << "\"";
170 else if(ReferenceType ==
172 cStream << "Objc message: " << ReferenceName;
173 else if(ReferenceType ==
175 cStream << "Objc message ref: " << ReferenceName;
176 else if(ReferenceType ==
178 cStream << "Objc selector ref: " << ReferenceName;
179 else if(ReferenceType ==
181 cStream << "Objc class ref: " << ReferenceName;
182 }
183}
184
185namespace llvm {
187 LLVMSymbolLookupCallback SymbolLookUp,
188 void *DisInfo, MCContext *Ctx,
189 std::unique_ptr<MCRelocationInfo> &&RelInfo) {
190 assert(Ctx && "No MCContext given for symbolic disassembly");
191
192 return new MCExternalSymbolizer(*Ctx, std::move(RelInfo), GetOpInfo,
193 SymbolLookUp, DisInfo);
194}
195}
std::string Name
Symbol * Sym
Definition: ELF_riscv.cpp:479
IRTranslator LLVM IR MI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * LHS
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:534
static const MCBinaryExpr * createSub(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:619
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
Context object for machine code objects.
Definition: MCContext.h:76
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:200
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
Symbolize using user-provided, C API, callbacks.
void * DisInfo
The pointer to the block of symbolic information for above call back.
LLVMSymbolLookupCallback SymbolLookUp
The function to lookup a symbol name.
void tryAddingPcLoadReferenceComment(raw_ostream &CommentStream, int64_t Value, uint64_t Address) override
Try to add a comment on the PC-relative load.
bool tryAddingSymbolicOperand(MCInst &MI, raw_ostream &CommentStream, int64_t Value, uint64_t Address, bool IsBranch, uint64_t Offset, uint64_t OpSize, uint64_t InstSize) override
Try to add a symbolic operand instead of Value to the MCInst.
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:162
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:395
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:40
Symbolize and annotate disassembled instructions.
Definition: MCSymbolizer.h:39
std::unique_ptr< MCRelocationInfo > RelInfo
Definition: MCSymbolizer.h:42
MCContext & Ctx
Definition: MCSymbolizer.h:41
static const MCUnaryExpr * createMinus(const MCExpr *Expr, MCContext &Ctx, SMLoc Loc=SMLoc())
Definition: MCExpr.h:460
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
LLVM Value Representation.
Definition: Value.h:74
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
raw_ostream & write_escaped(StringRef Str, bool UseHexEscapes=false)
Output Str, turning '\', '\t', ' ', '"', and anything that doesn't satisfy llvm::isPrint into an esca...
const char *(* LLVMSymbolLookupCallback)(void *DisInfo, uint64_t ReferenceValue, uint64_t *ReferenceType, uint64_t ReferencePC, const char **ReferenceName)
The type for the symbol lookup function.
#define LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref
#define LLVMDisassembler_ReferenceType_Out_SymbolStub
#define LLVMDisassembler_ReferenceType_In_PCrel_Load
#define LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref
#define LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr
#define LLVMDisassembler_ReferenceType_In_Branch
#define LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr
#define LLVMDisassembler_ReferenceType_Out_Objc_Message
#define LLVMDisassembler_ReferenceType_InOut_None
The reference types on input and output.
int(* LLVMOpInfoCallback)(void *DisInfo, uint64_t PC, uint64_t Offset, uint64_t OpSize, uint64_t InstSize, int TagType, void *TagBuf)
The type for the operand information call back function.
#define LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref
#define LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref
#define LLVMDisassembler_ReferenceType_DeMangled_Name
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
MCSymbolizer * createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo, LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx, std::unique_ptr< MCRelocationInfo > &&RelInfo)
@ Add
Sum of integers.
struct LLVMOpInfoSymbol1 SubtractSymbol
struct LLVMOpInfoSymbol1 AddSymbol
uint64_t VariantKind