| //===- AArch64ExternalSymbolizer.cpp - Symbolizer for AArch64 ---*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "AArch64ExternalSymbolizer.h" |
| #include "AArch64Subtarget.h" |
| #include "MCTargetDesc/AArch64AddressingModes.h" |
| #include "Utils/AArch64BaseInfo.h" |
| #include "llvm/MC/MCContext.h" |
| #include "llvm/MC/MCExpr.h" |
| #include "llvm/MC/MCInst.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/raw_ostream.h" |
| |
| using namespace llvm; |
| |
| #define DEBUG_TYPE "aarch64-disassembler" |
| |
| static MCSymbolRefExpr::VariantKind |
| getVariant(uint64_t LLVMDisassembler_VariantKind) { |
| switch (LLVMDisassembler_VariantKind) { |
| case LLVMDisassembler_VariantKind_None: |
| return MCSymbolRefExpr::VK_None; |
| case LLVMDisassembler_VariantKind_ARM64_PAGE: |
| return MCSymbolRefExpr::VK_PAGE; |
| case LLVMDisassembler_VariantKind_ARM64_PAGEOFF: |
| return MCSymbolRefExpr::VK_PAGEOFF; |
| case LLVMDisassembler_VariantKind_ARM64_GOTPAGE: |
| return MCSymbolRefExpr::VK_GOTPAGE; |
| case LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF: |
| return MCSymbolRefExpr::VK_GOTPAGEOFF; |
| case LLVMDisassembler_VariantKind_ARM64_TLVP: |
| case LLVMDisassembler_VariantKind_ARM64_TLVOFF: |
| default: |
| llvm_unreachable("bad LLVMDisassembler_VariantKind"); |
| } |
| } |
| |
| /// tryAddingSymbolicOperand - tryAddingSymbolicOperand trys to add a symbolic |
| /// operand in place of the immediate Value in the MCInst. The immediate |
| /// Value has not had any PC adjustment made by the caller. If the instruction |
| /// is a branch that adds the PC to the immediate Value then isBranch is |
| /// Success, else Fail. If GetOpInfo is non-null, then it is called to get any |
| /// symbolic information at the Address for this instrution. If that returns |
| /// non-zero then the symbolic information it returns is used to create an |
| /// MCExpr and that is added as an operand to the MCInst. If GetOpInfo() |
| /// returns zero and isBranch is Success then a symbol look up for |
| /// Address + Value is done and if a symbol is found an MCExpr is created with |
| /// that, else an MCExpr with Address + Value is created. If GetOpInfo() |
| /// returns zero and isBranch is Fail then the Opcode of the MCInst is |
| /// tested and for ADRP an other instructions that help to load of pointers |
| /// a symbol look up is done to see it is returns a specific reference type |
| /// to add to the comment stream. This function returns Success if it adds |
| /// an operand to the MCInst and Fail otherwise. |
| bool AArch64ExternalSymbolizer::tryAddingSymbolicOperand( |
| MCInst &MI, raw_ostream &CommentStream, int64_t Value, uint64_t Address, |
| bool IsBranch, uint64_t Offset, uint64_t InstSize) { |
| // FIXME: This method shares a lot of code with |
| // MCExternalSymbolizer::tryAddingSymbolicOperand. It may be possible |
| // refactor the MCExternalSymbolizer interface to allow more of this |
| // implementation to be shared. |
| // |
| struct LLVMOpInfo1 SymbolicOp; |
| memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1)); |
| SymbolicOp.Value = Value; |
| uint64_t ReferenceType; |
| const char *ReferenceName; |
| if (!GetOpInfo || |
| !GetOpInfo(DisInfo, Address, 0 /* Offset */, InstSize, 1, &SymbolicOp)) { |
| if (IsBranch) { |
| ReferenceType = LLVMDisassembler_ReferenceType_In_Branch; |
| const char *Name = SymbolLookUp(DisInfo, Address + Value, &ReferenceType, |
| Address, &ReferenceName); |
| if (Name) { |
| SymbolicOp.AddSymbol.Name = Name; |
| SymbolicOp.AddSymbol.Present = true; |
| SymbolicOp.Value = 0; |
| } else { |
| SymbolicOp.Value = Address + Value; |
| } |
| if (ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub) |
| CommentStream << "symbol stub for: " << ReferenceName; |
| else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_Objc_Message) |
| CommentStream << "Objc message: " << ReferenceName; |
| } else if (MI.getOpcode() == AArch64::ADRP) { |
| ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADRP; |
| // otool expects the fully encoded ADRP instruction to be passed in as |
| // the value here, so reconstruct it: |
| const MCRegisterInfo &MCRI = *Ctx.getRegisterInfo(); |
| uint32_t EncodedInst = 0x90000000; |
| EncodedInst |= (Value & 0x3) << 29; // immlo |
| EncodedInst |= ((Value >> 2) & 0x7FFFF) << 5; // immhi |
| EncodedInst |= MCRI.getEncodingValue(MI.getOperand(0).getReg()); // reg |
| SymbolLookUp(DisInfo, EncodedInst, &ReferenceType, Address, |
| &ReferenceName); |
| CommentStream << format("0x%llx", |
| 0xfffffffffffff000LL & (Address + Value)); |
| } else if (MI.getOpcode() == AArch64::ADDXri || |
| MI.getOpcode() == AArch64::LDRXui || |
| MI.getOpcode() == AArch64::LDRXl || |
| MI.getOpcode() == AArch64::ADR) { |
| if (MI.getOpcode() == AArch64::ADDXri) |
| ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADDXri; |
| else if (MI.getOpcode() == AArch64::LDRXui) |
| ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_LDRXui; |
| if (MI.getOpcode() == AArch64::LDRXl) { |
| ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_LDRXl; |
| SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address, |
| &ReferenceName); |
| } else if (MI.getOpcode() == AArch64::ADR) { |
| ReferenceType = LLVMDisassembler_ReferenceType_In_ARM64_ADR; |
| SymbolLookUp(DisInfo, Address + Value, &ReferenceType, Address, |
| &ReferenceName); |
| } else { |
| const MCRegisterInfo &MCRI = *Ctx.getRegisterInfo(); |
| // otool expects the fully encoded ADD/LDR instruction to be passed in |
| // as the value here, so reconstruct it: |
| unsigned EncodedInst = |
| MI.getOpcode() == AArch64::ADDXri ? 0x91000000: 0xF9400000; |
| EncodedInst |= Value << 10; // imm12 [+ shift:2 for ADD] |
| EncodedInst |= |
| MCRI.getEncodingValue(MI.getOperand(1).getReg()) << 5; // Rn |
| EncodedInst |= MCRI.getEncodingValue(MI.getOperand(0).getReg()); // Rd |
| |
| SymbolLookUp(DisInfo, EncodedInst, &ReferenceType, Address, |
| &ReferenceName); |
| } |
| if (ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr) |
| CommentStream << "literal pool symbol address: " << ReferenceName; |
| else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr) { |
| CommentStream << "literal pool for: \""; |
| CommentStream.write_escaped(ReferenceName); |
| CommentStream << "\""; |
| } else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref) |
| CommentStream << "Objc cfstring ref: @\"" << ReferenceName << "\""; |
| else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_Objc_Message) |
| CommentStream << "Objc message: " << ReferenceName; |
| else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref) |
| CommentStream << "Objc message ref: " << ReferenceName; |
| else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref) |
| CommentStream << "Objc selector ref: " << ReferenceName; |
| else if (ReferenceType == |
| LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref) |
| CommentStream << "Objc class ref: " << ReferenceName; |
| // For these instructions, the SymbolLookUp() above is just to get the |
| // ReferenceType and ReferenceName. We want to make sure not to |
| // fall through so we don't build an MCExpr to leave the disassembly |
| // of the immediate values of these instructions to the InstPrinter. |
| return false; |
| } else { |
| return false; |
| } |
| } |
| |
| const MCExpr *Add = nullptr; |
| if (SymbolicOp.AddSymbol.Present) { |
| if (SymbolicOp.AddSymbol.Name) { |
| StringRef Name(SymbolicOp.AddSymbol.Name); |
| MCSymbol *Sym = Ctx.getOrCreateSymbol(Name); |
| MCSymbolRefExpr::VariantKind Variant = getVariant(SymbolicOp.VariantKind); |
| if (Variant != MCSymbolRefExpr::VK_None) |
| Add = MCSymbolRefExpr::create(Sym, Variant, Ctx); |
| else |
| Add = MCSymbolRefExpr::create(Sym, Ctx); |
| } else { |
| Add = MCConstantExpr::create(SymbolicOp.AddSymbol.Value, Ctx); |
| } |
| } |
| |
| const MCExpr *Sub = nullptr; |
| if (SymbolicOp.SubtractSymbol.Present) { |
| if (SymbolicOp.SubtractSymbol.Name) { |
| StringRef Name(SymbolicOp.SubtractSymbol.Name); |
| MCSymbol *Sym = Ctx.getOrCreateSymbol(Name); |
| Sub = MCSymbolRefExpr::create(Sym, Ctx); |
| } else { |
| Sub = MCConstantExpr::create(SymbolicOp.SubtractSymbol.Value, Ctx); |
| } |
| } |
| |
| const MCExpr *Off = nullptr; |
| if (SymbolicOp.Value != 0) |
| Off = MCConstantExpr::create(SymbolicOp.Value, Ctx); |
| |
| const MCExpr *Expr; |
| if (Sub) { |
| const MCExpr *LHS; |
| if (Add) |
| LHS = MCBinaryExpr::createSub(Add, Sub, Ctx); |
| else |
| LHS = MCUnaryExpr::createMinus(Sub, Ctx); |
| if (Off) |
| Expr = MCBinaryExpr::createAdd(LHS, Off, Ctx); |
| else |
| Expr = LHS; |
| } else if (Add) { |
| if (Off) |
| Expr = MCBinaryExpr::createAdd(Add, Off, Ctx); |
| else |
| Expr = Add; |
| } else { |
| if (Off) |
| Expr = Off; |
| else |
| Expr = MCConstantExpr::create(0, Ctx); |
| } |
| |
| MI.addOperand(MCOperand::createExpr(Expr)); |
| |
| return true; |
| } |
