1 //===------------- Disassembler.h - LLVM Disassembler -----------*- C++ -*-===// 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 // 9 // This file defines the interface for the Disassembly library's disassembler 10 // context. The disassembler is responsible for producing strings for 11 // individual instructions according to a given architecture and disassembly 12 // syntax. 13 // 14 //===----------------------------------------------------------------------===// 15 16 #ifndef LLVM_LIB_MC_MCDISASSEMBLER_DISASSEMBLER_H 17 #define LLVM_LIB_MC_MCDISASSEMBLER_DISASSEMBLER_H 18 19 #include "llvm-c/DisassemblerTypes.h" 20 #include "llvm/ADT/SmallString.h" 21 #include "llvm/MC/MCAsmInfo.h" 22 #include "llvm/MC/MCContext.h" 23 #include "llvm/MC/MCDisassembler/MCDisassembler.h" 24 #include "llvm/MC/MCInstPrinter.h" 25 #include "llvm/MC/MCInstrInfo.h" 26 #include "llvm/MC/MCRegisterInfo.h" 27 #include "llvm/MC/MCSubtargetInfo.h" 28 #include "llvm/Support/raw_ostream.h" 29 #include <string> 30 #include <utility> 31 32 namespace llvm { 33 class Target; 34 35 // 36 // This is the disassembler context returned by LLVMCreateDisasm(). 37 // 38 class LLVMDisasmContext { 39 private: 40 // 41 // The passed parameters when the disassembler context is created. 42 // 43 // The TripleName for this disassembler. 44 std::string TripleName; 45 // The pointer to the caller's block of symbolic information. 46 void *DisInfo; 47 // The Triple specific symbolic information type returned by GetOpInfo. 48 int TagType; 49 // The function to get the symbolic information for operands. 50 LLVMOpInfoCallback GetOpInfo; 51 // The function to look up a symbol name. 52 LLVMSymbolLookupCallback SymbolLookUp; 53 // 54 // The objects created and saved by LLVMCreateDisasm() then used by 55 // LLVMDisasmInstruction(). 56 // 57 // The LLVM target corresponding to the disassembler. 58 // FIXME: using std::unique_ptr<const llvm::Target> causes a malloc error 59 // when this LLVMDisasmContext is deleted. 60 const Target *TheTarget; 61 // The assembly information for the target architecture. 62 std::unique_ptr<const llvm::MCAsmInfo> MAI; 63 // The register information for the target architecture. 64 std::unique_ptr<const llvm::MCRegisterInfo> MRI; 65 // The subtarget information for the target architecture. 66 std::unique_ptr<const llvm::MCSubtargetInfo> MSI; 67 // The instruction information for the target architecture. 68 std::unique_ptr<const llvm::MCInstrInfo> MII; 69 // The assembly context for creating symbols and MCExprs. 70 std::unique_ptr<const llvm::MCContext> Ctx; 71 // The disassembler for the target architecture. 72 std::unique_ptr<const llvm::MCDisassembler> DisAsm; 73 // The instruction printer for the target architecture. 74 std::unique_ptr<llvm::MCInstPrinter> IP; 75 // The options used to set up the disassembler. 76 uint64_t Options; 77 // The CPU string. 78 std::string CPU; 79 80 public: 81 // Comment stream and backing vector. 82 SmallString<128> CommentsToEmit; 83 raw_svector_ostream CommentStream; 84 85 LLVMDisasmContext(std::string TripleName, void *DisInfo, int TagType, 86 LLVMOpInfoCallback GetOpInfo, 87 LLVMSymbolLookupCallback SymbolLookUp, 88 const Target *TheTarget, 89 std::unique_ptr<const MCAsmInfo> &&MAI, 90 std::unique_ptr<const MCRegisterInfo> &&MRI, 91 std::unique_ptr<const MCSubtargetInfo> &&MSI, 92 std::unique_ptr<const MCInstrInfo> &&MII, 93 std::unique_ptr<const llvm::MCContext> &&Ctx, 94 std::unique_ptr<const MCDisassembler> &&DisAsm, 95 std::unique_ptr<MCInstPrinter> &&IP) 96 : TripleName(std::move(TripleName)), DisInfo(DisInfo), TagType(TagType), 97 GetOpInfo(GetOpInfo), SymbolLookUp(SymbolLookUp), TheTarget(TheTarget), 98 MAI(std::move(MAI)), MRI(std::move(MRI)), MSI(std::move(MSI)), 99 MII(std::move(MII)), Ctx(std::move(Ctx)), DisAsm(std::move(DisAsm)), 100 IP(std::move(IP)), Options(0), CommentStream(CommentsToEmit) {} 101 const std::string &getTripleName() const { return TripleName; } 102 void *getDisInfo() const { return DisInfo; } 103 int getTagType() const { return TagType; } 104 LLVMOpInfoCallback getGetOpInfo() const { return GetOpInfo; } 105 LLVMSymbolLookupCallback getSymbolLookupCallback() const { 106 return SymbolLookUp; 107 } 108 const Target *getTarget() const { return TheTarget; } 109 const MCDisassembler *getDisAsm() const { return DisAsm.get(); } 110 const MCAsmInfo *getAsmInfo() const { return MAI.get(); } 111 const MCInstrInfo *getInstrInfo() const { return MII.get(); } 112 const MCRegisterInfo *getRegisterInfo() const { return MRI.get(); } 113 const MCSubtargetInfo *getSubtargetInfo() const { return MSI.get(); } 114 MCInstPrinter *getIP() { return IP.get(); } 115 void setIP(MCInstPrinter *NewIP) { IP.reset(NewIP); } 116 uint64_t getOptions() const { return Options; } 117 void addOptions(uint64_t Options) { this->Options |= Options; } 118 StringRef getCPU() const { return CPU; } 119 void setCPU(const char *CPU) { this->CPU = CPU; } 120 }; 121 122 } // namespace llvm 123 124 #endif 125