[llvm] r182625 - Add MCSymbolizer for symbolic/annotated disassembly.

Aaron Ballman aaron at aaronballman.com
Thu May 30 09:54:34 PDT 2013


This commit is causing a failed assertion for me in MSVC 11 on Windows
7, x86 build.

157>  FAIL: LLVM :: Object/X86/objdump-disassembly-symbolic.test (5522 of 8170)
157>  ******************** TEST 'LLVM ::
Object/X86/objdump-disassembly-symbolic.test' FAILED
********************
157>  Script:
157>  --
157>  F:/llvm/build/bin/Debug/llvm-objdump.EXE -d -symbolize
F:\llvm\llvm\test\Object\X86/../Inputs/trivial-object-test.elf-x86-64
             | F:/llvm/build/bin/Debug/FileCheck.EXE
F:\llvm\llvm\test\Object\X86\objdump-disassembly-symbolic.test
-check-prefix ELF-x86-64
157>  F:/llvm/build/bin/Debug/llvm-objdump.EXE -d -symbolize
F:\llvm\llvm\test\Object\X86/../Inputs/trivial-object-test.macho-x86-64
              | F:/llvm/build/bin/Debug/FileCheck.EXE
F:\llvm\llvm\test\Object\X86\objdump-disassembly-symbolic.test
-check-prefix MACHO-x86-64
157>  --
157>  Exit Code: 2
157>  Command Output (stdout):
157>  --
157>  Command 0: "F:/llvm/build/bin/Debug/llvm-objdump.EXE" "-d"
"-symbolize" "F:\llvm\llvm\test\Object\X86/../Inputs/trivial-object-test.elf-x86-64"
157>  Command 0 Result: 3
157>  Command 0 Output:
157>
157>
157>  Command 0 Stderr:
157>  Assertion failed: (uintptr_t(data) & (alignOf<RootLeaf>() - 1))
== 0 && "Insufficient alignment", file
F:\llvm\llvm\include\llvm/ADT/IntervalMap.h, line 1055
157>
157>CUSTOMBUILD : CRT error : R6010
157>
157>
157>  - abort() has been called
157>
157>
157>
157>
157>
157>
157>  Command 1: "F:/llvm/build/bin/Debug/FileCheck.EXE"
"F:\llvm\llvm\test\Object\X86\objdump-disassembly-symbolic.test"
"-check-prefix" "ELF-x86-64"
157>  Command 1 Result: 2
157>  Command 1 Output:
157>
157>
157>  Command 1 Stderr:
157>CUSTOMBUILD : FileCheck error : '-' is empty.
157>
157>
157>  --
157>
157>  ********************

Any ideas?

~Aaron

On Thu, May 23, 2013 at 8:39 PM, Ahmed Bougacha
<ahmed.bougacha at gmail.com> wrote:
> Author: ab
> Date: Thu May 23 19:39:57 2013
> New Revision: 182625
>
> URL: http://llvm.org/viewvc/llvm-project?rev=182625&view=rev
> Log:
> Add MCSymbolizer for symbolic/annotated disassembly.
>
> This is a basic first step towards symbolization of disassembled
> instructions. This used to be done using externally provided (C API)
> callbacks. This patch introduces:
> - the MCSymbolizer class, that mimics the same functions that were used
>   in the X86 and ARM disassemblers to symbolize immediate operands and
>   to annotate loads based off PC (for things like c string literals).
> - the MCExternalSymbolizer class, which implements the old C API.
> - the MCRelocationInfo class, which provides a way for targets to
>   translate relocations (either object::RelocationRef, or disassembler
>   C API VariantKinds) to MCExprs.
> - the MCObjectSymbolizer class, which does symbolization using what it
>   finds in an object::ObjectFile. This makes simple symbolization (with
>   no fancy relocation stuff) work for all object formats!
> - x86-64 Mach-O and ELF MCRelocationInfos.
> - A basic ARM Mach-O MCRelocationInfo, that provides just enough to
>   support the C API VariantKinds.
>
> Most of what works in otool (the only user of the old symbolization API
> that I know of) for x86-64 symbolic disassembly (-tvV) works, namely:
> - symbol references: call _foo; jmp 15 <_foo+50>
> - relocations:       call _foo-_bar; call _foo-4
> - __cf?string:       leaq 193(%rip), %rax ## literal pool for "hello"
> Stub support is the main missing part (because libObject doesn't know,
> among other things, about mach-o indirect symbols).
>
> As for the MCSymbolizer API, instead of relying on the disassemblers
> to call the tryAdding* methods, maybe this could be done automagically
> using InstrInfo? For instance, even though PC-relative LEAs are used
> to get the address of string literals in a typical Mach-O file, a MOV
> would be used in an ELF file. And right now, the explicit symbolization
> only recognizes PC-relative LEAs. InstrInfo should have already have
> most of what is needed to know what to symbolize, so this can
> definitely be improved.
>
> I'd also like to remove object::RelocationRef::getValueString (it seems
> only used by relocation printing in objdump), as simply printing the
> created MCExpr is definitely enough (and cleaner than string concats).
>
>
> Added:
>     llvm/trunk/include/llvm/MC/MCExternalSymbolizer.h
>     llvm/trunk/include/llvm/MC/MCObjectSymbolizer.h
>     llvm/trunk/include/llvm/MC/MCRelocationInfo.h
>     llvm/trunk/include/llvm/MC/MCSymbolizer.h
>     llvm/trunk/lib/MC/MCExternalSymbolizer.cpp
>     llvm/trunk/lib/MC/MCObjectSymbolizer.cpp
>     llvm/trunk/lib/MC/MCRelocationInfo.cpp
>     llvm/trunk/lib/MC/MCSymbolizer.cpp
>     llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachORelocationInfo.cpp
>     llvm/trunk/lib/Target/X86/MCTargetDesc/X86ELFRelocationInfo.cpp
>     llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp
>     llvm/trunk/test/Object/X86/objdump-disassembly-symbolic.test
> Modified:
>     llvm/trunk/include/llvm/MC/MCDisassembler.h
>     llvm/trunk/include/llvm/Support/TargetRegistry.h
>     llvm/trunk/lib/MC/CMakeLists.txt
>     llvm/trunk/lib/MC/MCDisassembler.cpp
>     llvm/trunk/lib/MC/MCDisassembler/Disassembler.cpp
>     llvm/trunk/lib/Target/ARM/Disassembler/ARMDisassembler.cpp
>     llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
>     llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
>     llvm/trunk/lib/Target/ARM/MCTargetDesc/CMakeLists.txt
>     llvm/trunk/lib/Target/X86/Disassembler/X86Disassembler.cpp
>     llvm/trunk/lib/Target/X86/MCTargetDesc/CMakeLists.txt
>     llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp
>     llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h
>     llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp
>     llvm/trunk/tools/llvm-objdump/llvm-objdump.h
>
> Modified: llvm/trunk/include/llvm/MC/MCDisassembler.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCDisassembler.h?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/MC/MCDisassembler.h (original)
> +++ llvm/trunk/include/llvm/MC/MCDisassembler.h Thu May 23 19:39:57 2013
> @@ -10,6 +10,9 @@
>  #define LLVM_MC_MCDISASSEMBLER_H
>
>  #include "llvm-c/Disassembler.h"
> +#include "llvm/ADT/OwningPtr.h"
> +#include "llvm/MC/MCSymbolizer.h"
> +#include "llvm/MC/MCRelocationInfo.h"
>  #include "llvm/Support/DataTypes.h"
>
>  namespace llvm {
> @@ -53,9 +56,8 @@ public:
>    };
>
>    /// Constructor     - Performs initial setup for the disassembler.
> -  MCDisassembler(const MCSubtargetInfo &STI) : GetOpInfo(0), SymbolLookUp(0),
> -                                               DisInfo(0), Ctx(0),
> -                                               STI(STI), CommentStream(0) {}
> +  MCDisassembler(const MCSubtargetInfo &STI) : STI(STI), Symbolizer(0),
> +                                               CommentStream(0) {}
>
>    virtual ~MCDisassembler();
>
> @@ -82,39 +84,32 @@ public:
>                                         raw_ostream &vStream,
>                                         raw_ostream &cStream) const = 0;
>
> -private:
> -  //
> -  // Hooks for symbolic disassembly via the public 'C' interface.
> -  //
> -  // The function to get the symbolic information for operands.
> -  LLVMOpInfoCallback GetOpInfo;
> -  // The function to lookup a symbol name.
> -  LLVMSymbolLookupCallback SymbolLookUp;
> -  // The pointer to the block of symbolic information for above call back.
> -  void *DisInfo;
> -  // The assembly context for creating symbols and MCExprs in place of
> -  // immediate operands when there is symbolic information.
> -  MCContext *Ctx;
>  protected:
>    // Subtarget information, for instruction decoding predicates if required.
>    const MCSubtargetInfo &STI;
>
> +private:
> +  OwningPtr<MCSymbolizer> Symbolizer;
> +
>  public:
> -  void setupForSymbolicDisassembly(LLVMOpInfoCallback getOpInfo,
> -                                   LLVMSymbolLookupCallback symbolLookUp,
> -                                   void *disInfo,
> -                                   MCContext *ctx) {
> -    GetOpInfo = getOpInfo;
> -    SymbolLookUp = symbolLookUp;
> -    DisInfo = disInfo;
> -    Ctx = ctx;
> -  }
> -  LLVMOpInfoCallback getLLVMOpInfoCallback() const { return GetOpInfo; }
> -  LLVMSymbolLookupCallback getLLVMSymbolLookupCallback() const {
> -    return SymbolLookUp;
> -  }
> -  void *getDisInfoBlock() const { return DisInfo; }
> -  MCContext *getMCContext() const { return Ctx; }
> +  // Helpers around MCSymbolizer
> +  bool tryAddingSymbolicOperand(MCInst &Inst,
> +                                int64_t Value,
> +                                uint64_t Address, bool IsBranch,
> +                                uint64_t Offset, uint64_t InstSize) const;
> +
> +  void tryAddingPcLoadReferenceComment(int64_t Value, uint64_t Address) const;
> +
> +  /// Set \p Symzer as the current symbolizer.
> +  /// This takes ownership of \p Symzer, and deletes the previously set one.
> +  void setSymbolizer(OwningPtr<MCSymbolizer> &Symzer);
> +
> +  /// Sets up an external symbolizer that uses the C API callbacks.
> +  void setupForSymbolicDisassembly(LLVMOpInfoCallback GetOpInfo,
> +                                   LLVMSymbolLookupCallback SymbolLookUp,
> +                                   void *DisInfo,
> +                                   MCContext *Ctx,
> +                                   OwningPtr<MCRelocationInfo> &RelInfo);
>
>    // Marked mutable because we cache it inside the disassembler, rather than
>    // having to pass it around as an argument through all the autogenerated code.
>
> Added: llvm/trunk/include/llvm/MC/MCExternalSymbolizer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCExternalSymbolizer.h?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/MC/MCExternalSymbolizer.h (added)
> +++ llvm/trunk/include/llvm/MC/MCExternalSymbolizer.h Thu May 23 19:39:57 2013
> @@ -0,0 +1,58 @@
> +//===-- llvm/MC/MCExternalSymbolizer.h - ------------------------*- C++ -*-===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file contains the declaration of the MCExternalSymbolizer class, which
> +// enables library users to provide callbacks (through the C API) to do the
> +// symbolization externally.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_MC_MCEXTERNALSYMBOLIZER_H
> +#define LLVM_MC_MCEXTERNALSYMBOLIZER_H
> +
> +#include "llvm-c/Disassembler.h"
> +#include "llvm/MC/MCSymbolizer.h"
> +
> +namespace llvm {
> +
> +/// \brief Symbolize using user-provided, C API, callbacks.
> +///
> +/// See llvm-c/Disassembler.h.
> +class MCExternalSymbolizer : public MCSymbolizer {
> +
> +  /// \name Hooks for symbolic disassembly via the public 'C' interface.
> +  /// @{
> +  /// The function to get the symbolic information for operands.
> +  LLVMOpInfoCallback GetOpInfo;
> +  /// The function to lookup a symbol name.
> +  LLVMSymbolLookupCallback SymbolLookUp;
> +  /// The pointer to the block of symbolic information for above call back.
> +  void *DisInfo;
> +  /// @}
> +
> +public:
> +  MCExternalSymbolizer(MCContext &Ctx,
> +                       OwningPtr<MCRelocationInfo> &RelInfo,
> +                       LLVMOpInfoCallback getOpInfo,
> +                       LLVMSymbolLookupCallback symbolLookUp,
> +                       void *disInfo)
> +    : MCSymbolizer(Ctx, RelInfo),
> +      GetOpInfo(getOpInfo), SymbolLookUp(symbolLookUp), DisInfo(disInfo) {}
> +
> +  bool tryAddingSymbolicOperand(MCInst &MI, raw_ostream &CommentStream,
> +                                int64_t Value,
> +                                uint64_t Address, bool IsBranch,
> +                                uint64_t Offset, uint64_t InstSize);
> +  void tryAddingPcLoadReferenceComment(raw_ostream &CommentStream,
> +                                       int64_t Value, uint64_t Address);
> +};
> +
> +}
> +
> +#endif
>
> Added: llvm/trunk/include/llvm/MC/MCObjectSymbolizer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCObjectSymbolizer.h?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/MC/MCObjectSymbolizer.h (added)
> +++ llvm/trunk/include/llvm/MC/MCObjectSymbolizer.h Thu May 23 19:39:57 2013
> @@ -0,0 +1,74 @@
> +//===-- llvm/MC/MCObjectSymbolizer.h --------------------------------------===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file declares the MCObjectSymbolizer class, an MCSymbolizer that is
> +// backed by an object::ObjectFile.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_MC_MCOBJECTSYMBOLIZER_H
> +#define LLVM_MC_MCOBJECTSYMBOLIZER_H
> +
> +#include "llvm/ADT/IntervalMap.h"
> +#include "llvm/ADT/DenseMap.h"
> +#include "llvm/MC/MCSymbolizer.h"
> +#include "llvm/Object/ObjectFile.h"
> +
> +namespace llvm {
> +
> +class MCExpr;
> +class MCInst;
> +class MCRelocationInfo;
> +class raw_ostream;
> +
> +/// \brief An ObjectFile-backed symbolizer.
> +class MCObjectSymbolizer : public MCSymbolizer {
> +protected:
> +  const object::ObjectFile *Obj;
> +
> +  typedef DenseMap<uint64_t, object::RelocationRef> AddrToRelocMap;
> +  // FIXME: Working around a missing SectionRef operator!= by storing
> +  // DataRefImpl.p instead of SectionRef. Feel free to improve!
> +  typedef IntervalMap<uint64_t, uintptr_t> AddrToSectionMap;
> +
> +  AddrToSectionMap::Allocator AddrToSectionAllocator;
> +  AddrToSectionMap AddrToSection;
> +
> +  // Map a load address to the first relocation that applies there. As far as I
> +  // know, if there are several relocations at the exact same address, they are
> +  // related and the others can be determined from the first that was found in
> +  // the relocation table. For instance, on x86-64 mach-o, a SUBTRACTOR
> +  // relocation (referencing the minuend symbol) is followed by an UNSIGNED
> +  // relocation (referencing the subtrahend symbol).
> +  AddrToRelocMap AddrToReloc;
> +
> +  MCObjectSymbolizer(MCContext &Ctx, OwningPtr<MCRelocationInfo> &RelInfo,
> +                     const object::ObjectFile *Obj);
> +
> +public:
> +  /// \name Overridden MCSymbolizer methods:
> +  /// @{
> +  bool tryAddingSymbolicOperand(MCInst &MI, raw_ostream &cStream,
> +                                int64_t Value,
> +                                uint64_t Address, bool IsBranch,
> +                                uint64_t Offset, uint64_t InstSize);
> +
> +  void tryAddingPcLoadReferenceComment(raw_ostream &cStream,
> +                                       int64_t Value, uint64_t Address);
> +  /// @}
> +
> +  /// \brief Create an object symbolizer for \p Obj.
> +  static MCObjectSymbolizer *
> +    createObjectSymbolizer(MCContext &Ctx, OwningPtr<MCRelocationInfo> &RelInfo,
> +                           const object::ObjectFile *Obj);
> +};
> +
> +}
> +
> +#endif
>
> Added: llvm/trunk/include/llvm/MC/MCRelocationInfo.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCRelocationInfo.h?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/MC/MCRelocationInfo.h (added)
> +++ llvm/trunk/include/llvm/MC/MCRelocationInfo.h Thu May 23 19:39:57 2013
> @@ -0,0 +1,55 @@
> +//==-- llvm/MC/MCRelocationInfo.h --------------------------------*- C++ -*-==//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file declares the MCRelocationInfo class, which provides methods to
> +// create MCExprs from relocations, either found in an object::ObjectFile
> +// (object::RelocationRef), or provided through the C API.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_MC_MCRELOCATIONINFO_H
> +#define LLVM_MC_MCRELOCATIONINFO_H
> +
> +#include "llvm/Support/Compiler.h"
> +
> +namespace llvm {
> +
> +namespace object {
> +class RelocationRef;
> +}
> +class MCExpr;
> +class MCContext;
> +
> +/// \brief Create MCExprs from relocations found in an object file.
> +class MCRelocationInfo {
> +  MCRelocationInfo(const MCRelocationInfo &) LLVM_DELETED_FUNCTION;
> +  void operator=(const MCRelocationInfo &) LLVM_DELETED_FUNCTION;
> +
> +protected:
> +  MCContext &Ctx;
> +
> +public:
> +  MCRelocationInfo(MCContext &Ctx);
> +  virtual ~MCRelocationInfo();
> +
> +  /// \brief Create an MCExpr for the relocation \p Rel.
> +  /// \returns If possible, an MCExpr corresponding to Rel, else 0.
> +  virtual const MCExpr *createExprForRelocation(object::RelocationRef Rel);
> +
> +  /// \brief Create an MCExpr for the target-specific \p VariantKind.
> +  /// The VariantKinds are defined in llvm-c/Disassembler.h.
> +  /// Used by MCExternalSymbolizer.
> +  /// \returns If possible, an MCExpr corresponding to VariantKind, else 0.
> +  virtual const MCExpr *createExprForCAPIVariantKind(const MCExpr *SubExpr,
> +                                                     unsigned VariantKind);
> +};
> +
> +}
> +
> +#endif
>
> Added: llvm/trunk/include/llvm/MC/MCSymbolizer.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/MC/MCSymbolizer.h?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/include/llvm/MC/MCSymbolizer.h (added)
> +++ llvm/trunk/include/llvm/MC/MCSymbolizer.h Thu May 23 19:39:57 2013
> @@ -0,0 +1,81 @@
> +//===-- llvm/MC/MCSymbolizer.h - MCSymbolizer class -------------*- C++ -*-===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +//
> +// This file contains the declaration of the MCSymbolizer class, which is used
> +// to symbolize instructions decoded from an object, that is, transform their
> +// immediate operands to MCExprs.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef LLVM_MC_MCSYMBOLIZER_H
> +#define LLVM_MC_MCSYMBOLIZER_H
> +
> +#include "llvm/ADT/OwningPtr.h"
> +#include "llvm/MC/MCRelocationInfo.h"
> +#include "llvm/Support/Compiler.h"
> +#include "llvm/Support/DataTypes.h"
> +
> +namespace llvm {
> +
> +class MCContext;
> +class MCInst;
> +class raw_ostream;
> +
> +/// \brief Symbolize and annotate disassembled instructions.
> +///
> +/// For now this mimics the old symbolization logic (from both ARM and x86), that
> +/// relied on user-provided (C API) callbacks to do the actual symbol lookup in
> +/// the object file. This was moved to MCExternalSymbolizer.
> +/// A better API would not rely on actually calling the two methods here from
> +/// inside each disassembler, but would use the instr info to determine what
> +/// operands are actually symbolizable, and in what way. I don't think this
> +/// information exists right now.
> +class MCSymbolizer {
> +  MCSymbolizer(const MCSymbolizer &) LLVM_DELETED_FUNCTION;
> +  void operator=(const MCSymbolizer &) LLVM_DELETED_FUNCTION;
> +
> +protected:
> +  MCContext &Ctx;
> +  OwningPtr<MCRelocationInfo> RelInfo;
> +
> +public:
> +  /// \brief Construct an MCSymbolizer, taking ownership of \p RelInfo.
> +  MCSymbolizer(MCContext &Ctx, OwningPtr<MCRelocationInfo> &RelInfo);
> +  virtual ~MCSymbolizer();
> +
> +  /// \brief Try to add a symbolic operand instead of \p Value to the MCInst.
> +  ///
> +  /// Instead of having a difficult to read immediate, a symbolic operand would
> +  /// represent this immediate in a more understandable way, for instance as a
> +  /// symbol or an offset from a symbol. Relocations can also be used to enrich
> +  /// the symbolic expression.
> +  /// @param Inst      - The MCInst where to insert the symbolic operand.
> +  /// @param cStream   - Stream to print comments and annotations on.
> +  /// @param Value     - Operand value, pc-adjusted by the caller if necessary.
> +  /// @param Address   - Load address of the instruction.
> +  /// @param IsBranch  - Is the instruction a branch?
> +  /// @param Offset    - Byte offset of the operand inside the inst.
> +  /// @param InstSize  - Size of the instruction in bytes.
> +  /// @return Whether a symbolic operand was added.
> +  virtual bool tryAddingSymbolicOperand(MCInst &Inst, raw_ostream &cStream,
> +                                        int64_t Value, uint64_t Address,
> +                                        bool IsBranch, uint64_t Offset,
> +                                        uint64_t InstSize) = 0;
> +
> +  /// \brief Try to add a comment on the PC-relative load.
> +  /// For instance, in Mach-O, this is used to add annotations to instructions
> +  /// that use C string literals, as found in __cstring.
> +  virtual void tryAddingPcLoadReferenceComment(raw_ostream &cStream,
> +                                               int64_t Value,
> +                                               uint64_t Address) = 0;
> +};
> +
> +}
> +
> +#endif
>
> Modified: llvm/trunk/include/llvm/Support/TargetRegistry.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/Support/TargetRegistry.h?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/include/llvm/Support/TargetRegistry.h (original)
> +++ llvm/trunk/include/llvm/Support/TargetRegistry.h Thu May 23 19:39:57 2013
> @@ -41,6 +41,7 @@ namespace llvm {
>    class MCRegisterInfo;
>    class MCStreamer;
>    class MCSubtargetInfo;
> +  class MCRelocationInfo;
>    class MCTargetAsmParser;
>    class TargetMachine;
>    class TargetOptions;
> @@ -56,6 +57,8 @@ namespace llvm {
>                                  MCAsmBackend *TAB,
>                                  bool ShowInst);
>
> +  MCRelocationInfo *createMCRelocationInfo(MCContext &Ctx);
> +
>    /// Target - Wrapper for Target specific information.
>    ///
>    /// For registration purposes, this is a POD type so that targets can be
> @@ -127,6 +130,8 @@ namespace llvm {
>                                               MCCodeEmitter *CE,
>                                               MCAsmBackend *TAB,
>                                               bool ShowInst);
> +    typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT,
> +                                                        MCContext &Ctx);
>
>    private:
>      /// Next - The next registered target in the linked list, maintained by the
> @@ -206,6 +211,10 @@ namespace llvm {
>      /// AsmStreamer, if registered (default = llvm::createAsmStreamer).
>      AsmStreamerCtorTy AsmStreamerCtorFn;
>
> +    /// MCRelocationInfoCtorFn - Construction function for this target's
> +    /// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
> +    MCRelocationInfoCtorTy MCRelocationInfoCtorFn;
> +
>    public:
>      Target() : AsmStreamerCtorFn(llvm::createAsmStreamer) {}
>
> @@ -433,6 +442,16 @@ namespace llvm {
>                                 useDwarfDirectory, InstPrint, CE, TAB, ShowInst);
>      }
>
> +    /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
> +    ///
> +    /// \param TT The target triple.
> +    /// \param Ctx The target context.
> +    MCRelocationInfo *
> +      createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
> +      // MCRelocationInfoCtorFn defaults to createMCRelocationInfo
> +      return MCRelocationInfoCtorFn(TT, Ctx);
> +    }
> +
>      /// @}
>    };
>
> @@ -760,6 +779,21 @@ namespace llvm {
>          T.AsmStreamerCtorFn = Fn;
>      }
>
> +    /// RegisterMCRelocationInfo - Register an MCRelocationInfo
> +    /// implementation for the given target.
> +    ///
> +    /// Clients are responsible for ensuring that registration doesn't occur
> +    /// while another thread is attempting to access the registry. Typically
> +    /// this is done by initializing all targets at program startup.
> +    ///
> +    /// @param T - The target being registered.
> +    /// @param Fn - A function to construct an MCRelocationInfo for the target.
> +    static void RegisterMCRelocationInfo(Target &T,
> +                                         Target::MCRelocationInfoCtorTy Fn) {
> +      if (!T.MCRelocationInfoCtorFn)
> +        T.MCRelocationInfoCtorFn = Fn;
> +    }
> +
>      /// @}
>    };
>
>
> Modified: llvm/trunk/lib/MC/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/CMakeLists.txt?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/MC/CMakeLists.txt (original)
> +++ llvm/trunk/lib/MC/CMakeLists.txt Thu May 23 19:39:57 2013
> @@ -16,6 +16,7 @@ add_llvm_library(LLVMMC
>    MCELFObjectTargetWriter.cpp
>    MCELFStreamer.cpp
>    MCExpr.cpp
> +  MCExternalSymbolizer.cpp
>    MCInst.cpp
>    MCInstPrinter.cpp
>    MCInstrAnalysis.cpp
> @@ -26,9 +27,11 @@ add_llvm_library(LLVMMC
>    MCNullStreamer.cpp
>    MCObjectFileInfo.cpp
>    MCObjectStreamer.cpp
> +  MCObjectSymbolizer.cpp
>    MCObjectWriter.cpp
>    MCPureStreamer.cpp
>    MCRegisterInfo.cpp
> +  MCRelocationInfo.cpp
>    MCSection.cpp
>    MCSectionCOFF.cpp
>    MCSectionELF.cpp
> @@ -36,6 +39,7 @@ add_llvm_library(LLVMMC
>    MCStreamer.cpp
>    MCSubtargetInfo.cpp
>    MCSymbol.cpp
> +  MCSymbolizer.cpp
>    MCValue.cpp
>    MCWin64EH.cpp
>    MachObjectWriter.cpp
>
> Modified: llvm/trunk/lib/MC/MCDisassembler.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCDisassembler.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/MC/MCDisassembler.cpp (original)
> +++ llvm/trunk/lib/MC/MCDisassembler.cpp Thu May 23 19:39:57 2013
> @@ -8,7 +8,44 @@
>  //===----------------------------------------------------------------------===//
>
>  #include "llvm/MC/MCDisassembler.h"
> +#include "llvm/MC/MCExternalSymbolizer.h"
> +#include "llvm/Support/raw_ostream.h"
> +
>  using namespace llvm;
>
>  MCDisassembler::~MCDisassembler() {
>  }
> +
> +void
> +MCDisassembler::setupForSymbolicDisassembly(
> +    LLVMOpInfoCallback GetOpInfo,
> +    LLVMSymbolLookupCallback SymbolLookUp,
> +    void *DisInfo,
> +    MCContext *Ctx,
> +    OwningPtr<MCRelocationInfo> &RelInfo) {
> +  assert(Ctx != 0 && "No MCContext given for symbolic disassembly");
> +  Symbolizer.reset(new MCExternalSymbolizer(*Ctx, RelInfo, GetOpInfo,
> +                                            SymbolLookUp, DisInfo));
> +}
> +
> +bool MCDisassembler::tryAddingSymbolicOperand(MCInst &Inst, int64_t Value,
> +                                              uint64_t Address, bool IsBranch,
> +                                              uint64_t Offset,
> +                                              uint64_t InstSize) const {
> +  raw_ostream &cStream = CommentStream ? *CommentStream : nulls();
> +  if (Symbolizer)
> +    return Symbolizer->tryAddingSymbolicOperand(Inst, cStream, Value, Address,
> +                                                IsBranch, Offset, InstSize);
> +  return false;
> +}
> +
> +void MCDisassembler::tryAddingPcLoadReferenceComment(int64_t Value,
> +                                                     uint64_t Address) const {
> +  raw_ostream &cStream = CommentStream ? *CommentStream : nulls();
> +  if (Symbolizer)
> +    Symbolizer->tryAddingPcLoadReferenceComment(cStream, Value, Address);
> +}
> +
> +void MCDisassembler::setSymbolizer(OwningPtr<MCSymbolizer> &Symzer) {
> +  Symbolizer.reset(Symzer.take());
> +}
>
> Modified: llvm/trunk/lib/MC/MCDisassembler/Disassembler.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCDisassembler/Disassembler.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/MC/MCDisassembler/Disassembler.cpp (original)
> +++ llvm/trunk/lib/MC/MCDisassembler/Disassembler.cpp Thu May 23 19:39:57 2013
> @@ -16,6 +16,7 @@
>  #include "llvm/MC/MCInstPrinter.h"
>  #include "llvm/MC/MCInstrInfo.h"
>  #include "llvm/MC/MCRegisterInfo.h"
> +#include "llvm/MC/MCRelocationInfo.h"
>  #include "llvm/MC/MCSubtargetInfo.h"
>  #include "llvm/Support/ErrorHandling.h"
>  #include "llvm/Support/MemoryObject.h"
> @@ -73,7 +74,14 @@ LLVMDisasmContextRef LLVMCreateDisasmCPU
>    MCDisassembler *DisAsm = TheTarget->createMCDisassembler(*STI);
>    if (!DisAsm)
>      return 0;
> -  DisAsm->setupForSymbolicDisassembly(GetOpInfo, SymbolLookUp, DisInfo, Ctx);
> +
> +  OwningPtr<MCRelocationInfo> RelInfo(
> +    TheTarget->createMCRelocationInfo(Triple, *Ctx));
> +  if (!RelInfo)
> +    return 0;
> +
> +  DisAsm->setupForSymbolicDisassembly(GetOpInfo, SymbolLookUp, DisInfo,
> +                                      Ctx, RelInfo);
>
>    // Set up the instruction printer.
>    int AsmPrinterVariant = MAI->getAssemblerDialect();
>
> Added: llvm/trunk/lib/MC/MCExternalSymbolizer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCExternalSymbolizer.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/MC/MCExternalSymbolizer.cpp (added)
> +++ llvm/trunk/lib/MC/MCExternalSymbolizer.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,146 @@
> +//===-- lib/MC/MCExternalSymbolizer.cpp - External symbolizer ---*- C++ -*-===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "llvm/MC/MCExternalSymbolizer.h"
> +#include "llvm/MC/MCContext.h"
> +#include "llvm/MC/MCExpr.h"
> +#include "llvm/MC/MCInst.h"
> +#include "llvm/Support/raw_ostream.h"
> +#include <cstring>
> +
> +using namespace llvm;
> +
> +// This function tries to add a symbolic operand in place of the immediate
> +// Value in the MCInst. The immediate Value has had any PC adjustment made by
> +// the caller. If the instruction is a branch instruction then IsBranch is true,
> +// else false. If the getOpInfo() function was set as part of the
> +// setupForSymbolicDisassembly() call then that function is called to get any
> +// symbolic information at the Address for this instruction. 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 true then a symbol look up for Value is done and if a symbol
> +// is found an MCExpr is created with that, else an MCExpr with Value is
> +// created. This function returns true if it adds an operand to the MCInst and
> +// false otherwise.
> +bool MCExternalSymbolizer::tryAddingSymbolicOperand(MCInst &MI,
> +                                                    raw_ostream &cStream,
> +                                                    int64_t Value,
> +                                                    uint64_t Address,
> +                                                    bool IsBranch,
> +                                                    uint64_t Offset,
> +                                                    uint64_t InstSize) {
> +  struct LLVMOpInfo1 SymbolicOp;
> +  std::memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
> +  SymbolicOp.Value = Value;
> +
> +  if (!GetOpInfo ||
> +      !GetOpInfo(DisInfo, Address, Offset, InstSize, 1, &SymbolicOp)) {
> +    // Clear SymbolicOp.Value from above and also all other fields.
> +    std::memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
> +    if (!SymbolLookUp)
> +      return false;
> +    uint64_t ReferenceType;
> +    if (IsBranch)
> +       ReferenceType = LLVMDisassembler_ReferenceType_In_Branch;
> +    else
> +       ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
> +    const char *ReferenceName;
> +    const char *Name = SymbolLookUp(DisInfo, Value, &ReferenceType, Address,
> +                                    &ReferenceName);
> +    if (Name) {
> +      SymbolicOp.AddSymbol.Name = Name;
> +      SymbolicOp.AddSymbol.Present = true;
> +    }
> +    // For branches always create an MCExpr so it gets printed as hex address.
> +    else if (IsBranch) {
> +      SymbolicOp.Value = Value;
> +    }
> +    if(ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub)
> +      cStream << "symbol stub for: " << ReferenceName;
> +    if (!Name && !IsBranch)
> +      return false;
> +  }
> +
> +  const MCExpr *Add = NULL;
> +  if (SymbolicOp.AddSymbol.Present) {
> +    if (SymbolicOp.AddSymbol.Name) {
> +      StringRef Name(SymbolicOp.AddSymbol.Name);
> +      MCSymbol *Sym = Ctx.GetOrCreateSymbol(Name);
> +      Add = MCSymbolRefExpr::Create(Sym, Ctx);
> +    } else {
> +      Add = MCConstantExpr::Create((int)SymbolicOp.AddSymbol.Value, Ctx);
> +    }
> +  }
> +
> +  const MCExpr *Sub = NULL;
> +  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((int)SymbolicOp.SubtractSymbol.Value, Ctx);
> +    }
> +  }
> +
> +  const MCExpr *Off = NULL;
> +  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 != 0)
> +      Expr = MCBinaryExpr::CreateAdd(LHS, Off, Ctx);
> +    else
> +      Expr = LHS;
> +  } else if (Add) {
> +    if (Off != 0)
> +      Expr = MCBinaryExpr::CreateAdd(Add, Off, Ctx);
> +    else
> +      Expr = Add;
> +  } else {
> +    if (Off != 0)
> +      Expr = Off;
> +    else
> +      Expr = MCConstantExpr::Create(0, Ctx);
> +  }
> +
> +  Expr = RelInfo->createExprForCAPIVariantKind(Expr, SymbolicOp.VariantKind);
> +  if (!Expr)
> +    return false;
> +
> +  MI.addOperand(MCOperand::CreateExpr(Expr));
> +  return true;
> +}
> +
> +// This function tries to add a comment as to what is being referenced by a load
> +// instruction with the base register that is the Pc.  These can often be values
> +// in a literal pool near the Address of the instruction. The Address of the
> +// instruction and its immediate Value are used as a possible literal pool entry.
> +// The SymbolLookUp call back will return the name of a symbol referenced by the
> +// literal pool's entry if the referenced address is that of a symbol. Or it
> +// will return a pointer to a literal 'C' string if the referenced address of
> +// the literal pool's entry is an address into a section with C string literals.
> +void MCExternalSymbolizer::tryAddingPcLoadReferenceComment(raw_ostream &cStream,
> +                                                           int64_t Value,
> +                                                           uint64_t Address) {
> +  if (SymbolLookUp) {
> +    uint64_t ReferenceType = LLVMDisassembler_ReferenceType_In_PCrel_Load;
> +    const char *ReferenceName;
> +    (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName);
> +    if(ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr ||
> +       ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr)
> +      cStream << "literal pool for: " << ReferenceName;
> +  }
> +}
>
> Added: llvm/trunk/lib/MC/MCObjectSymbolizer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCObjectSymbolizer.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/MC/MCObjectSymbolizer.cpp (added)
> +++ llvm/trunk/lib/MC/MCObjectSymbolizer.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,175 @@
> +//===-- lib/MC/MCObjectSymbolizer.cpp -------------------------------------===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "llvm/MC/MCObjectSymbolizer.h"
> +#include "llvm/ADT/SmallString.h"
> +#include "llvm/MC/MCContext.h"
> +#include "llvm/MC/MCExpr.h"
> +#include "llvm/MC/MCInst.h"
> +#include "llvm/MC/MCRelocationInfo.h"
> +#include "llvm/MC/MCSymbol.h"
> +#include "llvm/Object/MachO.h"
> +#include "llvm/Object/ELF.h"
> +#include "llvm/Support/raw_ostream.h"
> +
> +using namespace llvm;
> +using namespace object;
> +
> +//===- MCMachObjectSymbolizer ---------------------------------------------===//
> +
> +namespace {
> +class MCMachObjectSymbolizer : public MCObjectSymbolizer {
> +public:
> +  MCMachObjectSymbolizer(MCContext &Ctx, OwningPtr<MCRelocationInfo> &RelInfo,
> +                         const object::MachOObjectFile *MachOOF)
> +    : MCObjectSymbolizer(Ctx, RelInfo, MachOOF)
> +  {}
> +
> +  void tryAddingPcLoadReferenceComment(raw_ostream &cStream,
> +                                       int64_t Value, uint64_t Address) {
> +    AddrToRelocMap::iterator RI = AddrToReloc.find(Address);
> +    if (RI != AddrToReloc.end()) {
> +      const MCExpr *RelExpr = RelInfo->createExprForRelocation(RI->second);
> +      if (!RelExpr || RelExpr->EvaluateAsAbsolute(Value) == false)
> +        return;
> +    }
> +    uint64_t Addr = Value;
> +    AddrToSectionMap::const_iterator SI = AddrToSection.find(Addr);
> +    if (SI.valid()) {
> +      DataRefImpl DRI; DRI.p = *SI;
> +      SectionRef S(DRI, Obj);
> +      StringRef Name; S.getName(Name);
> +      if (Name == "__cstring") {
> +        StringRef Contents;
> +        S.getContents(Contents);
> +        Contents = Contents.substr(Addr - SI.start());
> +        cStream << " ## literal pool for: "
> +                << Contents.substr(0, Contents.find_first_of(0));
> +      }
> +    }
> +  }
> +};
> +} // End unnamed namespace
> +
> +//===- MCObjectSymbolizer -------------------------------------------------===//
> +
> +MCObjectSymbolizer::MCObjectSymbolizer(MCContext &Ctx,
> +                                       OwningPtr<MCRelocationInfo> &RelInfo,
> +                                       const ObjectFile *Obj)
> +    : MCSymbolizer(Ctx, RelInfo), Obj(Obj),
> +      AddrToSectionAllocator(), AddrToSection(AddrToSectionAllocator),
> +      AddrToReloc() {
> +  error_code ec;
> +  for (section_iterator SI = Obj->begin_sections(),
> +                        SE = Obj->end_sections();
> +                        SI != SE;
> +                        SI.increment(ec)) {
> +    if (ec) break;
> +    uint64_t StartAddr; SI->getAddress(StartAddr);
> +    uint64_t Size; SI->getSize(Size);
> +    StringRef SecName; SI->getName(SecName);
> +    bool RequiredForExec; SI->isRequiredForExecution(RequiredForExec);
> +    if (RequiredForExec == false || Size == 0)
> +      continue;
> +    AddrToSection.insert(StartAddr, StartAddr + Size - 1,
> +                         SI->getRawDataRefImpl().p);
> +    for (relocation_iterator RI = SI->begin_relocations(),
> +                             RE = SI->end_relocations();
> +                             RI != RE;
> +                             RI.increment(ec)) {
> +      if (ec) break;
> +      // FIXME: libObject is inconsistent regarding error handling. The
> +      // overwhelming majority of methods always return object_error::success,
> +      // and assert for simple errors.. Here, ELFObjectFile::getRelocationOffset
> +      // asserts when the file type isn't ET_REL.
> +      // This workaround handles x86-64 elf, the only one that has a relocinfo.
> +      uint64_t Offset;
> +      if (Obj->isELF()) {
> +        const ELF64LEObjectFile *ELFObj = dyn_cast<ELF64LEObjectFile>(Obj);
> +        if (ELFObj == 0)
> +          break;
> +        if (ELFObj->getElfHeader()->e_type == ELF::ET_REL) {
> +          RI->getOffset(Offset);
> +          Offset += StartAddr;
> +        } else {
> +          RI->getAddress(Offset);
> +        }
> +      } else {
> +        RI->getOffset(Offset);
> +        Offset += StartAddr;
> +      }
> +      // At a specific address, only keep the first relocation.
> +      if (AddrToReloc.find(Offset) == AddrToReloc.end())
> +        AddrToReloc[Offset] = *RI;
> +    }
> +  }
> +}
> +
> +bool MCObjectSymbolizer::
> +tryAddingSymbolicOperand(MCInst &MI, raw_ostream &cStream,
> +                         int64_t Value, uint64_t Address, bool IsBranch,
> +                         uint64_t Offset, uint64_t InstSize) {
> +  AddrToRelocMap::iterator RI = AddrToReloc.find(Address + Offset);
> +  if (RI != AddrToReloc.end()) {
> +    if (const MCExpr *RelExpr = RelInfo->createExprForRelocation(RI->second)) {
> +      MI.addOperand(MCOperand::CreateExpr(RelExpr));
> +      return true;
> +    }
> +    // Only try to create a symbol+offset expression if there is no relocation.
> +    return false;
> +  }
> +
> +  // Interpret Value as a branch target.
> +  if (IsBranch == false)
> +    return false;
> +  uint64_t UValue = Value;
> +  // FIXME: map instead of looping each time?
> +  error_code ec;
> +  for (symbol_iterator SI = Obj->begin_symbols(),
> +       SE = Obj->end_symbols();
> +       SI != SE;
> +       SI.increment(ec)) {
> +    if (ec) break;
> +    uint64_t SymAddr; SI->getAddress(SymAddr);
> +    uint64_t SymSize; SI->getSize(SymSize);
> +    StringRef SymName; SI->getName(SymName);
> +    SymbolRef::Type SymType; SI->getType(SymType);
> +    if (SymAddr == UnknownAddressOrSize || SymSize == UnknownAddressOrSize
> +        || SymName.empty() || SymType != SymbolRef::ST_Function)
> +      continue;
> +
> +    if ( SymAddr == UValue ||
> +        (SymAddr <= UValue && SymAddr + SymSize > UValue)) {
> +      MCSymbol *Sym = Ctx.GetOrCreateSymbol(SymName);
> +      const MCExpr *Expr = MCSymbolRefExpr::Create(Sym, Ctx);
> +      if (SymAddr != UValue) {
> +        const MCExpr *Off = MCConstantExpr::Create(UValue - SymAddr, Ctx);
> +        Expr = MCBinaryExpr::CreateAdd(Expr, Off, Ctx);
> +      }
> +      MI.addOperand(MCOperand::CreateExpr(Expr));
> +      return true;
> +    }
> +  }
> +  return false;
> +}
> +
> +void MCObjectSymbolizer::
> +tryAddingPcLoadReferenceComment(raw_ostream &cStream,
> +                                int64_t Value, uint64_t Address) {
> +}
> +
> +MCObjectSymbolizer *
> +MCObjectSymbolizer::createObjectSymbolizer(MCContext &Ctx,
> +                                           OwningPtr<MCRelocationInfo> &RelInfo,
> +                                           const ObjectFile *Obj) {
> +  if (const MachOObjectFile *MachOOF = dyn_cast<MachOObjectFile>(Obj)) {
> +    return new MCMachObjectSymbolizer(Ctx, RelInfo, MachOOF);
> +  }
> +  return new MCObjectSymbolizer(Ctx, RelInfo, Obj);
> +}
>
> Added: llvm/trunk/lib/MC/MCRelocationInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCRelocationInfo.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/MC/MCRelocationInfo.cpp (added)
> +++ llvm/trunk/lib/MC/MCRelocationInfo.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,39 @@
> +//==-- lib/MC/MCRelocationInfo.cpp -------------------------------*- C++ -*-==//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "llvm/MC/MCRelocationInfo.h"
> +#include "llvm/Object/ObjectFile.h"
> +#include "llvm/Support/TargetRegistry.h"
> +#include "llvm-c/Disassembler.h"
> +
> +using namespace llvm;
> +
> +MCRelocationInfo::MCRelocationInfo(MCContext &Ctx)
> +  : Ctx(Ctx) {
> +}
> +
> +MCRelocationInfo::~MCRelocationInfo() {
> +}
> +
> +const MCExpr *
> +MCRelocationInfo::createExprForRelocation(object::RelocationRef Rel) {
> +  return 0;
> +}
> +
> +const MCExpr *
> +MCRelocationInfo::createExprForCAPIVariantKind(const MCExpr *SubExpr,
> +                                               unsigned VariantKind) {
> +  if (VariantKind != LLVMDisassembler_VariantKind_None)
> +    return 0;
> +  return SubExpr;
> +}
> +
> +MCRelocationInfo *llvm::createMCRelocationInfo(MCContext &Ctx) {
> +  return new MCRelocationInfo(Ctx);
> +}
>
> Added: llvm/trunk/lib/MC/MCSymbolizer.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/MC/MCSymbolizer.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/MC/MCSymbolizer.cpp (added)
> +++ llvm/trunk/lib/MC/MCSymbolizer.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,20 @@
> +//===-- llvm/MC/MCSymbolizer.cpp - MCSymbolizer class -----------*- C++ -*-===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "llvm/MC/MCSymbolizer.h"
> +#include "llvm/MC/MCRelocationInfo.h"
> +
> +using namespace llvm;
> +
> +MCSymbolizer::MCSymbolizer(MCContext &Ctx, OwningPtr<MCRelocationInfo> &RelInfo)
> +  : Ctx(Ctx), RelInfo(RelInfo.take()) {
> +}
> +
> +MCSymbolizer::~MCSymbolizer() {
> +}
>
> Modified: llvm/trunk/lib/Target/ARM/Disassembler/ARMDisassembler.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/Disassembler/ARMDisassembler.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/ARM/Disassembler/ARMDisassembler.cpp (original)
> +++ llvm/trunk/lib/Target/ARM/Disassembler/ARMDisassembler.cpp Thu May 23 19:39:57 2013
> @@ -503,102 +503,9 @@ static bool tryAddingSymbolicOperand(uin
>                                       bool isBranch, uint64_t InstSize,
>                                       MCInst &MI, const void *Decoder) {
>    const MCDisassembler *Dis = static_cast<const MCDisassembler*>(Decoder);
> -  LLVMOpInfoCallback getOpInfo = Dis->getLLVMOpInfoCallback();
> -  struct LLVMOpInfo1 SymbolicOp;
> -  memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
> -  SymbolicOp.Value = Value;
> -  void *DisInfo = Dis->getDisInfoBlock();
> -
> -  if (!getOpInfo ||
> -      !getOpInfo(DisInfo, Address, 0 /* Offset */, InstSize, 1, &SymbolicOp)) {
> -    // Clear SymbolicOp.Value from above and also all other fields.
> -    memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
> -    LLVMSymbolLookupCallback SymbolLookUp = Dis->getLLVMSymbolLookupCallback();
> -    if (!SymbolLookUp)
> -      return false;
> -    uint64_t ReferenceType;
> -    if (isBranch)
> -       ReferenceType = LLVMDisassembler_ReferenceType_In_Branch;
> -    else
> -       ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
> -    const char *ReferenceName;
> -    uint64_t SymbolValue = 0x00000000ffffffffULL & Value;
> -    const char *Name = SymbolLookUp(DisInfo, SymbolValue, &ReferenceType,
> -                                    Address, &ReferenceName);
> -    if (Name) {
> -      SymbolicOp.AddSymbol.Name = Name;
> -      SymbolicOp.AddSymbol.Present = true;
> -    }
> -    // For branches always create an MCExpr so it gets printed as hex address.
> -    else if (isBranch) {
> -      SymbolicOp.Value = Value;
> -    }
> -    if(ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub)
> -      (*Dis->CommentStream) << "symbol stub for: " << ReferenceName;
> -    if (!Name && !isBranch)
> -      return false;
> -  }
> -
> -  MCContext *Ctx = Dis->getMCContext();
> -  const MCExpr *Add = NULL;
> -  if (SymbolicOp.AddSymbol.Present) {
> -    if (SymbolicOp.AddSymbol.Name) {
> -      StringRef Name(SymbolicOp.AddSymbol.Name);
> -      MCSymbol *Sym = Ctx->GetOrCreateSymbol(Name);
> -      Add = MCSymbolRefExpr::Create(Sym, *Ctx);
> -    } else {
> -      Add = MCConstantExpr::Create(SymbolicOp.AddSymbol.Value, *Ctx);
> -    }
> -  }
> -
> -  const MCExpr *Sub = NULL;
> -  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 = NULL;
> -  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 != 0)
> -      Expr = MCBinaryExpr::CreateAdd(LHS, Off, *Ctx);
> -    else
> -      Expr = LHS;
> -  } else if (Add) {
> -    if (Off != 0)
> -      Expr = MCBinaryExpr::CreateAdd(Add, Off, *Ctx);
> -    else
> -      Expr = Add;
> -  } else {
> -    if (Off != 0)
> -      Expr = Off;
> -    else
> -      Expr = MCConstantExpr::Create(0, *Ctx);
> -  }
> -
> -  if (SymbolicOp.VariantKind == LLVMDisassembler_VariantKind_ARM_HI16)
> -    MI.addOperand(MCOperand::CreateExpr(ARMMCExpr::CreateUpper16(Expr, *Ctx)));
> -  else if (SymbolicOp.VariantKind == LLVMDisassembler_VariantKind_ARM_LO16)
> -    MI.addOperand(MCOperand::CreateExpr(ARMMCExpr::CreateLower16(Expr, *Ctx)));
> -  else if (SymbolicOp.VariantKind == LLVMDisassembler_VariantKind_None)
> -    MI.addOperand(MCOperand::CreateExpr(Expr));
> -  else
> -    llvm_unreachable("bad SymbolicOp.VariantKind");
> -
> -  return true;
> +  // FIXME: Does it make sense for value to be negative?
> +  return Dis->tryAddingSymbolicOperand(MI, (uint32_t)Value, Address, isBranch,
> +                                       /* Offset */ 0, InstSize);
>  }
>
>  /// tryAddingPcLoadReferenceComment - trys to add a comment as to what is being
> @@ -613,17 +520,7 @@ static bool tryAddingSymbolicOperand(uin
>  static void tryAddingPcLoadReferenceComment(uint64_t Address, int Value,
>                                              const void *Decoder) {
>    const MCDisassembler *Dis = static_cast<const MCDisassembler*>(Decoder);
> -  LLVMSymbolLookupCallback SymbolLookUp = Dis->getLLVMSymbolLookupCallback();
> -  if (SymbolLookUp) {
> -    void *DisInfo = Dis->getDisInfoBlock();
> -    uint64_t ReferenceType;
> -    ReferenceType = LLVMDisassembler_ReferenceType_In_PCrel_Load;
> -    const char *ReferenceName;
> -    (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName);
> -    if(ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr ||
> -       ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr)
> -      (*Dis->CommentStream) << "literal pool for: " << ReferenceName;
> -  }
> +  Dis->tryAddingPcLoadReferenceComment(Value, Address);
>  }
>
>  // Thumb1 instructions don't have explicit S bits.  Rather, they
>
> Modified: llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp (original)
> +++ llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.cpp Thu May 23 19:39:57 2013
> @@ -212,6 +212,14 @@ static MCInstPrinter *createARMMCInstPri
>    return 0;
>  }
>
> +static MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
> +  Triple TheTriple(TT);
> +  if (TheTriple.isEnvironmentMachO())
> +    return createARMMachORelocationInfo(Ctx);
> +  // Default to the stock relocation info.
> +  return llvm::createMCRelocationInfo(Ctx);
> +}
> +
>  namespace {
>
>  class ARMMCInstrAnalysis : public MCInstrAnalysis {
> @@ -295,4 +303,10 @@ extern "C" void LLVMInitializeARMTargetM
>    // Register the MCInstPrinter.
>    TargetRegistry::RegisterMCInstPrinter(TheARMTarget, createARMMCInstPrinter);
>    TargetRegistry::RegisterMCInstPrinter(TheThumbTarget, createARMMCInstPrinter);
> +
> +  // Register the MC relocation info.
> +  TargetRegistry::RegisterMCRelocationInfo(TheARMTarget,
> +                                           createMCRelocationInfo);
> +  TargetRegistry::RegisterMCRelocationInfo(TheThumbTarget,
> +                                           createMCRelocationInfo);
>  }
>
> Modified: llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h (original)
> +++ llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMCTargetDesc.h Thu May 23 19:39:57 2013
> @@ -25,6 +25,7 @@ class MCInstrInfo;
>  class MCObjectWriter;
>  class MCRegisterInfo;
>  class MCSubtargetInfo;
> +class MCRelocationInfo;
>  class StringRef;
>  class Target;
>  class raw_ostream;
> @@ -58,6 +59,9 @@ MCObjectWriter *createARMMachObjectWrite
>                                            uint32_t CPUType,
>                                            uint32_t CPUSubtype);
>
> +
> +/// createARMMachORelocationInfo - Construct ARM Mach-O relocation info.
> +MCRelocationInfo *createARMMachORelocationInfo(MCContext &Ctx);
>  } // End llvm namespace
>
>  // Defines symbolic names for ARM registers.  This defines a mapping from
>
> Added: llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachORelocationInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachORelocationInfo.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachORelocationInfo.cpp (added)
> +++ llvm/trunk/lib/Target/ARM/MCTargetDesc/ARMMachORelocationInfo.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,43 @@
> +//===-- ARMMachORelocationInfo.cpp ----------------------------------------===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "MCTargetDesc/ARMMCTargetDesc.h"
> +#include "ARMMCExpr.h"
> +#include "llvm/MC/MCContext.h"
> +#include "llvm/MC/MCExpr.h"
> +#include "llvm/MC/MCRelocationInfo.h"
> +#include "llvm-c/Disassembler.h"
> +
> +using namespace llvm;
> +using namespace object;
> +
> +namespace {
> +class ARMMachORelocationInfo : public MCRelocationInfo {
> +public:
> +  ARMMachORelocationInfo(MCContext &Ctx) : MCRelocationInfo(Ctx) {}
> +
> +  const MCExpr *createExprForCAPIVariantKind(const MCExpr *SubExpr,
> +                                             unsigned VariantKind) {
> +    switch(VariantKind) {
> +    case LLVMDisassembler_VariantKind_ARM_HI16:
> +      return ARMMCExpr::CreateUpper16(SubExpr, Ctx);
> +    case LLVMDisassembler_VariantKind_ARM_LO16:
> +      return ARMMCExpr::CreateLower16(SubExpr, Ctx);
> +    default:
> +      return MCRelocationInfo::createExprForCAPIVariantKind(SubExpr,
> +                                                            VariantKind);
> +    }
> +  }
> +};
> +} // End unnamed namespace
> +
> +/// createARMMachORelocationInfo - Construct an ARM Mach-O RelocationInfo.
> +MCRelocationInfo *llvm::createARMMachORelocationInfo(MCContext &Ctx) {
> +  return new ARMMachORelocationInfo(Ctx);
> +}
>
> Modified: llvm/trunk/lib/Target/ARM/MCTargetDesc/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/ARM/MCTargetDesc/CMakeLists.txt?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/ARM/MCTargetDesc/CMakeLists.txt (original)
> +++ llvm/trunk/lib/Target/ARM/MCTargetDesc/CMakeLists.txt Thu May 23 19:39:57 2013
> @@ -9,6 +9,7 @@ add_llvm_library(LLVMARMDesc
>    ARMMachObjectWriter.cpp
>    ARMELFObjectWriter.cpp
>    ARMUnwindOpAsm.cpp
> +  ARMMachORelocationInfo.cpp
>    )
>  add_dependencies(LLVMARMDesc ARMCommonTableGen)
>
>
> Modified: llvm/trunk/lib/Target/X86/Disassembler/X86Disassembler.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/Disassembler/X86Disassembler.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/X86/Disassembler/X86Disassembler.cpp (original)
> +++ llvm/trunk/lib/Target/X86/Disassembler/X86Disassembler.cpp Thu May 23 19:39:57 2013
> @@ -190,94 +190,8 @@ static bool tryAddingSymbolicOperand(int
>                                       uint64_t Address, uint64_t Offset,
>                                       uint64_t Width, MCInst &MI,
>                                       const MCDisassembler *Dis) {
> -  LLVMOpInfoCallback getOpInfo = Dis->getLLVMOpInfoCallback();
> -  struct LLVMOpInfo1 SymbolicOp;
> -  memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
> -  SymbolicOp.Value = Value;
> -  void *DisInfo = Dis->getDisInfoBlock();
> -
> -  if (!getOpInfo ||
> -      !getOpInfo(DisInfo, Address, Offset, Width, 1, &SymbolicOp)) {
> -    // Clear SymbolicOp.Value from above and also all other fields.
> -    memset(&SymbolicOp, '\0', sizeof(struct LLVMOpInfo1));
> -    LLVMSymbolLookupCallback SymbolLookUp = Dis->getLLVMSymbolLookupCallback();
> -    if (!SymbolLookUp)
> -      return false;
> -    uint64_t ReferenceType;
> -    if (isBranch)
> -       ReferenceType = LLVMDisassembler_ReferenceType_In_Branch;
> -    else
> -       ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
> -    const char *ReferenceName;
> -    const char *Name = SymbolLookUp(DisInfo, Value, &ReferenceType, Address,
> -                                    &ReferenceName);
> -    if (Name) {
> -      SymbolicOp.AddSymbol.Name = Name;
> -      SymbolicOp.AddSymbol.Present = true;
> -    }
> -    // For branches always create an MCExpr so it gets printed as hex address.
> -    else if (isBranch) {
> -      SymbolicOp.Value = Value;
> -    }
> -    if(ReferenceType == LLVMDisassembler_ReferenceType_Out_SymbolStub)
> -      (*Dis->CommentStream) << "symbol stub for: " << ReferenceName;
> -    if (!Name && !isBranch)
> -      return false;
> -  }
> -
> -  MCContext *Ctx = Dis->getMCContext();
> -  const MCExpr *Add = NULL;
> -  if (SymbolicOp.AddSymbol.Present) {
> -    if (SymbolicOp.AddSymbol.Name) {
> -      StringRef Name(SymbolicOp.AddSymbol.Name);
> -      MCSymbol *Sym = Ctx->GetOrCreateSymbol(Name);
> -      Add = MCSymbolRefExpr::Create(Sym, *Ctx);
> -    } else {
> -      Add = MCConstantExpr::Create((int)SymbolicOp.AddSymbol.Value, *Ctx);
> -    }
> -  }
> -
> -  const MCExpr *Sub = NULL;
> -  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((int)SymbolicOp.SubtractSymbol.Value, *Ctx);
> -    }
> -  }
> -
> -  const MCExpr *Off = NULL;
> -  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 != 0)
> -      Expr = MCBinaryExpr::CreateAdd(LHS, Off, *Ctx);
> -    else
> -      Expr = LHS;
> -  } else if (Add) {
> -    if (Off != 0)
> -      Expr = MCBinaryExpr::CreateAdd(Add, Off, *Ctx);
> -    else
> -      Expr = Add;
> -  } else {
> -    if (Off != 0)
> -      Expr = Off;
> -    else
> -      Expr = MCConstantExpr::Create(0, *Ctx);
> -  }
> -
> -  MI.addOperand(MCOperand::CreateExpr(Expr));
> -
> -  return true;
> +  return Dis->tryAddingSymbolicOperand(MI, Value, Address, isBranch,
> +                                       Offset, Width);
>  }
>
>  /// tryAddingPcLoadReferenceComment - trys to add a comment as to what is being
> @@ -290,15 +204,7 @@ static bool tryAddingSymbolicOperand(int
>  static void tryAddingPcLoadReferenceComment(uint64_t Address, uint64_t Value,
>                                              const void *Decoder) {
>    const MCDisassembler *Dis = static_cast<const MCDisassembler*>(Decoder);
> -  LLVMSymbolLookupCallback SymbolLookUp = Dis->getLLVMSymbolLookupCallback();
> -  if (SymbolLookUp) {
> -    void *DisInfo = Dis->getDisInfoBlock();
> -    uint64_t ReferenceType = LLVMDisassembler_ReferenceType_In_PCrel_Load;
> -    const char *ReferenceName;
> -    (void)SymbolLookUp(DisInfo, Value, &ReferenceType, Address, &ReferenceName);
> -    if(ReferenceType == LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr)
> -      (*Dis->CommentStream) << "literal pool for: " << ReferenceName;
> -  }
> +  Dis->tryAddingPcLoadReferenceComment(Value, Address);
>  }
>
>  /// translateImmediate  - Appends an immediate operand to an MCInst.
>
> Modified: llvm/trunk/lib/Target/X86/MCTargetDesc/CMakeLists.txt
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/CMakeLists.txt?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/X86/MCTargetDesc/CMakeLists.txt (original)
> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/CMakeLists.txt Thu May 23 19:39:57 2013
> @@ -6,6 +6,8 @@ add_llvm_library(LLVMX86Desc
>    X86MachObjectWriter.cpp
>    X86ELFObjectWriter.cpp
>    X86WinCOFFObjectWriter.cpp
> +  X86MachORelocationInfo.cpp
> +  X86ELFRelocationInfo.cpp
>    )
>
>  add_dependencies(LLVMX86Desc X86CommonTableGen)
>
> Added: llvm/trunk/lib/Target/X86/MCTargetDesc/X86ELFRelocationInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86ELFRelocationInfo.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86ELFRelocationInfo.cpp (added)
> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86ELFRelocationInfo.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,135 @@
> +//===-- X86ELFRelocationInfo.cpp ----------------------------------------===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "MCTargetDesc/X86MCTargetDesc.h"
> +#include "llvm/MC/MCContext.h"
> +#include "llvm/MC/MCExpr.h"
> +#include "llvm/MC/MCInst.h"
> +#include "llvm/MC/MCSymbol.h"
> +#include "llvm/MC/MCRelocationInfo.h"
> +#include "llvm/Object/ELF.h"
> +#include "llvm/Support/ELF.h"
> +
> +using namespace llvm;
> +using namespace object;
> +using namespace ELF;
> +
> +namespace {
> +class X86_64ELFRelocationInfo : public MCRelocationInfo {
> +public:
> +  X86_64ELFRelocationInfo(MCContext &Ctx) : MCRelocationInfo(Ctx) {}
> +
> +  const MCExpr *createExprForRelocation(RelocationRef Rel) {
> +    uint64_t RelType; Rel.getType(RelType);
> +    SymbolRef SymRef; Rel.getSymbol(SymRef);
> +
> +    StringRef SymName; SymRef.getName(SymName);
> +    uint64_t  SymAddr; SymRef.getAddress(SymAddr);
> +    uint64_t  SymSize; SymRef.getSize(SymSize);
> +    int64_t  Addend;  getELFRelocationAddend(Rel, Addend);
> +
> +    MCSymbol *Sym = Ctx.GetOrCreateSymbol(SymName);
> +    // FIXME: check that the value is actually the same.
> +    if (Sym->isVariable() == false)
> +      Sym->setVariableValue(MCConstantExpr::Create(SymAddr, Ctx));
> +
> +    const MCExpr *Expr = 0;
> +    // If hasAddend is true, then we need to add Addend (r_addend) to Expr.
> +    bool hasAddend = false;
> +
> +    // The AMD64 SysV ABI says:
> +    // A: the addend used to compute the value of the relocatable field.
> +    // B: the base address at which a shared object has been loaded into memory
> +    //    during execution. Generally, a shared object is built with a 0 base
> +    //    virtual address, but the execution address will be different.
> +    // G: the offset into the global offset table at which the relocation
> +    //    entry's symbol will reside during execution.
> +    // GOT: the address of the global offset table.
> +    // L: the place (section offset or address) of the Procedure Linkage Table
> +    //    entry for a symbol.
> +    // P: the place (section offset or address) of the storage unit being
> +    //    relocated (computed using r_offset).
> +    // S: the value of the symbol whose index resides in the relocation entry.
> +    // Z: the size of the symbol whose index resides in the relocation entry.
> +
> +    switch(RelType) {
> +    case R_X86_64_NONE:
> +    case R_X86_64_COPY:
> +      // none
> +      break;
> +    case R_X86_64_64:
> +    case R_X86_64_16:
> +    case R_X86_64_8:
> +      // S + A
> +    case R_X86_64_32:
> +    case R_X86_64_32S:
> +      // S + A (We don't care about the result not fitting in 32 bits.)
> +    case R_X86_64_PC32:
> +    case R_X86_64_PC16:
> +    case R_X86_64_PC8:
> +    case R_X86_64_PC64:
> +      // S + A - P (P/pcrel is implicit)
> +      hasAddend = true;
> +      Expr = MCSymbolRefExpr::Create(Sym, Ctx);
> +      break;
> +    case R_X86_64_GOT32:
> +    case R_X86_64_GOT64:
> +    case R_X86_64_GOTPC32:
> +    case R_X86_64_GOTPC64:
> +    case R_X86_64_GOTPLT64:
> +      // G + A
> +      hasAddend = true;
> +      Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOT, Ctx);
> +      break;
> +    case R_X86_64_PLT32:
> +      // L + A - P -> S at PLT + A
> +      hasAddend = true;
> +      Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_PLT, Ctx);
> +      break;
> +    case R_X86_64_GLOB_DAT:
> +    case R_X86_64_JUMP_SLOT:
> +      // S
> +      Expr = MCSymbolRefExpr::Create(Sym, Ctx);
> +      break;
> +    case R_X86_64_GOTPCREL:
> +    case R_X86_64_GOTPCREL64:
> +      // G + GOT + A - P -> S at GOTPCREL + A
> +      hasAddend = true;
> +      Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, Ctx);
> +      break;
> +    case R_X86_64_GOTOFF64:
> +      // S + A - GOT
> +      Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTOFF, Ctx);
> +      break;
> +    case R_X86_64_PLTOFF64:
> +      // L + A - GOT
> +      break;
> +    case R_X86_64_SIZE32:
> +    case R_X86_64_SIZE64:
> +      // Z + A
> +      Expr = MCConstantExpr::Create(SymSize, Ctx);
> +      break;
> +    default:
> +      Expr = MCSymbolRefExpr::Create(Sym, Ctx);
> +      break;
> +    }
> +    if (Expr && hasAddend && Addend != 0)
> +      Expr = MCBinaryExpr::CreateAdd(Expr,
> +                                     MCConstantExpr::Create(Addend, Ctx),
> +                                     Ctx);
> +    return Expr;
> +  }
> +};
> +} // End unnamed namespace
> +
> +/// createX86ELFRelocationInfo - Construct an X86 Mach-O RelocationInfo.
> +MCRelocationInfo *llvm::createX86_64ELFRelocationInfo(MCContext &Ctx) {
> +  // We only handle x86-64 for now.
> +  return new X86_64ELFRelocationInfo(Ctx);
> +}
>
> Modified: llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp (original)
> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp Thu May 23 19:39:57 2013
> @@ -384,6 +384,16 @@ static MCInstPrinter *createX86MCInstPri
>    return 0;
>  }
>
> +static MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
> +  Triple TheTriple(TT);
> +  if (TheTriple.isEnvironmentMachO() && TheTriple.getArch() == Triple::x86_64)
> +    return createX86_64MachORelocationInfo(Ctx);
> +  else if (TheTriple.isOSBinFormatELF())
> +    return createX86_64ELFRelocationInfo(Ctx);
> +  // Default to the stock relocation info.
> +  return llvm::createMCRelocationInfo(Ctx);
> +}
> +
>  static MCInstrAnalysis *createX86MCInstrAnalysis(const MCInstrInfo *Info) {
>    return new MCInstrAnalysis(Info);
>  }
> @@ -441,4 +451,10 @@ extern "C" void LLVMInitializeX86TargetM
>                                          createX86MCInstPrinter);
>    TargetRegistry::RegisterMCInstPrinter(TheX86_64Target,
>                                          createX86MCInstPrinter);
> +
> +  // Register the MC relocation info.
> +  TargetRegistry::RegisterMCRelocationInfo(TheX86_32Target,
> +                                           createMCRelocationInfo);
> +  TargetRegistry::RegisterMCRelocationInfo(TheX86_64Target,
> +                                           createMCRelocationInfo);
>  }
>
> Modified: llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h (original)
> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.h Thu May 23 19:39:57 2013
> @@ -25,6 +25,7 @@ class MCInstrInfo;
>  class MCObjectWriter;
>  class MCRegisterInfo;
>  class MCSubtargetInfo;
> +class MCRelocationInfo;
>  class Target;
>  class StringRef;
>  class raw_ostream;
> @@ -94,6 +95,12 @@ MCObjectWriter *createX86ELFObjectWriter
>                                           uint16_t EMachine);
>  /// createX86WinCOFFObjectWriter - Construct an X86 Win COFF object writer.
>  MCObjectWriter *createX86WinCOFFObjectWriter(raw_ostream &OS, bool Is64Bit);
> +
> +/// createX86_64MachORelocationInfo - Construct X86-64 Mach-O relocation info.
> +MCRelocationInfo *createX86_64MachORelocationInfo(MCContext &Ctx);
> +
> +/// createX86_64ELFORelocationInfo - Construct X86-64 ELF relocation info.
> +MCRelocationInfo *createX86_64ELFRelocationInfo(MCContext &Ctx);
>  } // End llvm namespace
>
>
>
> Added: llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp (added)
> +++ llvm/trunk/lib/Target/X86/MCTargetDesc/X86MachORelocationInfo.cpp Thu May 23 19:39:57 2013
> @@ -0,0 +1,117 @@
> +//===-- X86MachORelocationInfo.cpp ----------------------------------------===//
> +//
> +//                     The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "MCTargetDesc/X86MCTargetDesc.h"
> +#include "llvm/MC/MCContext.h"
> +#include "llvm/MC/MCExpr.h"
> +#include "llvm/MC/MCInst.h"
> +#include "llvm/MC/MCSymbol.h"
> +#include "llvm/MC/MCRelocationInfo.h"
> +#include "llvm/Object/MachO.h"
> +
> +using namespace llvm;
> +using namespace object;
> +using namespace macho;
> +
> +namespace {
> +class X86_64MachORelocationInfo : public MCRelocationInfo {
> +public:
> +  X86_64MachORelocationInfo(MCContext &Ctx) : MCRelocationInfo(Ctx) {}
> +
> +  const MCExpr *createExprForRelocation(RelocationRef Rel) {
> +    const MachOObjectFile *Obj = cast<MachOObjectFile>(Rel.getObjectFile());
> +
> +    uint64_t RelType; Rel.getType(RelType);
> +    SymbolRef SymRef; Rel.getSymbol(SymRef);
> +
> +    StringRef SymName; SymRef.getName(SymName);
> +    uint64_t  SymAddr; SymRef.getAddress(SymAddr);
> +
> +    RelocationEntry RE = Obj->getRelocation(Rel.getRawDataRefImpl());
> +    bool isPCRel = Obj->getAnyRelocationPCRel(RE);
> +
> +    MCSymbol *Sym = Ctx.GetOrCreateSymbol(SymName);
> +    // FIXME: check that the value is actually the same.
> +    if (Sym->isVariable() == false)
> +      Sym->setVariableValue(MCConstantExpr::Create(SymAddr, Ctx));
> +    const MCExpr *Expr = 0;
> +
> +    switch(RelType) {
> +    case RIT_X86_64_TLV:
> +      Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_TLVP, Ctx);
> +      break;
> +    case RIT_X86_64_Signed4:
> +      Expr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Sym, Ctx),
> +                                     MCConstantExpr::Create(4, Ctx),
> +                                     Ctx);
> +      break;
> +    case RIT_X86_64_Signed2:
> +      Expr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Sym, Ctx),
> +                                     MCConstantExpr::Create(2, Ctx),
> +                                     Ctx);
> +      break;
> +    case RIT_X86_64_Signed1:
> +      Expr = MCBinaryExpr::CreateAdd(MCSymbolRefExpr::Create(Sym, Ctx),
> +                                     MCConstantExpr::Create(1, Ctx),
> +                                     Ctx);
> +      break;
> +    case RIT_X86_64_GOTLoad:
> +      Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, Ctx);
> +      break;
> +    case RIT_X86_64_GOT:
> +      Expr = MCSymbolRefExpr::Create(Sym, isPCRel ?
> +                                     MCSymbolRefExpr::VK_GOTPCREL :
> +                                     MCSymbolRefExpr::VK_GOT,
> +                                     Ctx);
> +      break;
> +    case RIT_X86_64_Subtractor:
> +      {
> +        RelocationRef RelNext;
> +        Obj->getRelocationNext(Rel.getRawDataRefImpl(), RelNext);
> +        RelocationEntry RENext = Obj->getRelocation(RelNext.getRawDataRefImpl());
> +
> +        // X86_64_SUBTRACTOR must be followed by a relocation of type
> +        // X86_64_RELOC_UNSIGNED    .
> +        // NOTE: Scattered relocations don't exist on x86_64.
> +        unsigned RType = Obj->getAnyRelocationType(RENext);
> +        if (RType != RIT_X86_64_Unsigned)
> +          report_fatal_error("Expected X86_64_RELOC_UNSIGNED after "
> +                             "X86_64_RELOC_SUBTRACTOR.");
> +
> +        const MCExpr *LHS = MCSymbolRefExpr::Create(Sym, Ctx);
> +
> +        SymbolRef RSymRef;
> +        RelNext.getSymbol(RSymRef);
> +        uint64_t RSymAddr;
> +        RSymRef.getAddress(RSymAddr);
> +        StringRef RSymName;
> +        RSymRef.getName(RSymName);
> +
> +        MCSymbol *RSym = Ctx.GetOrCreateSymbol(RSymName);
> +        if (RSym->isVariable() == false)
> +          RSym->setVariableValue(MCConstantExpr::Create(RSymAddr, Ctx));
> +
> +        const MCExpr *RHS = MCSymbolRefExpr::Create(RSym, Ctx);
> +
> +        Expr = MCBinaryExpr::CreateSub(LHS, RHS, Ctx);
> +        break;
> +      }
> +    default:
> +      Expr = MCSymbolRefExpr::Create(Sym, Ctx);
> +      break;
> +    }
> +    return Expr;
> +  }
> +};
> +} // End unnamed namespace
> +
> +/// createX86_64MachORelocationInfo - Construct an X86-64 Mach-O RelocationInfo.
> +MCRelocationInfo *llvm::createX86_64MachORelocationInfo(MCContext &Ctx) {
> +  return new X86_64MachORelocationInfo(Ctx);
> +}
>
> Added: llvm/trunk/test/Object/X86/objdump-disassembly-symbolic.test
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Object/X86/objdump-disassembly-symbolic.test?rev=182625&view=auto
> ==============================================================================
> --- llvm/trunk/test/Object/X86/objdump-disassembly-symbolic.test (added)
> +++ llvm/trunk/test/Object/X86/objdump-disassembly-symbolic.test Thu May 23 19:39:57 2013
> @@ -0,0 +1,30 @@
> +RUN: llvm-objdump -d -symbolize %p/../Inputs/trivial-object-test.elf-x86-64 \
> +RUN:              | FileCheck %s -check-prefix ELF-x86-64
> +RUN: llvm-objdump -d -symbolize %p/../Inputs/trivial-object-test.macho-x86-64 \
> +RUN:              | FileCheck %s -check-prefix MACHO-x86-64
> +
> +ELF-x86-64: file format ELF64-x86-64
> +ELF-x86-64: Disassembly of section .text:
> +ELF-x86-64: main:
> +ELF-x86-64:        0:  48 83 ec 08                                     subq    $8, %rsp
> +ELF-x86-64:        4:  c7 44 24 04 00 00 00 00                         movl    $0, 4(%rsp)
> +ELF-x86-64:        c:  bf 00 00 00 00                                  movl    $.rodata.str1.1, %edi
> +ELF-x86-64:       11:  e8 00 00 00 00                                  callq   puts-4
> +ELF-x86-64:       16:  30 c0                                           xorb    %al, %al
> +ELF-x86-64:       18:  e8 00 00 00 00                                  callq   SomeOtherFunction-4
> +ELF-x86-64:       1d:  8b 44 24 04                                     movl    4(%rsp), %eax
> +ELF-x86-64:       21:  48 83 c4 08                                     addq    $8, %rsp
> +ELF-x86-64:       25:  c3                                              ret
> +
> +MACHO-x86-64: file format Mach-O 64-bit x86-64
> +MACHO-x86-64: Disassembly of section __TEXT,__text:
> +MACHO-x86-64: _main:
> +MACHO-x86-64:        0:        48 83 ec 08                                     subq    $8, %rsp
> +MACHO-x86-64:        4:        c7 44 24 04 00 00 00 00                         movl    $0, 4(%rsp)
> +MACHO-x86-64:        c:        48 8d 3d 00 00 00 00                            leaq    L_.str(%rip), %rdi ## literal pool for: Hello World!
> +MACHO-x86-64:       13:        e8 00 00 00 00                                  callq   _puts
> +MACHO-x86-64:       18:        30 c0                                           xorb    %al, %al
> +MACHO-x86-64:       1a:        e8 00 00 00 00                                  callq   _SomeOtherFunction
> +MACHO-x86-64:       1f:        8b 44 24 04                                     movl    4(%rsp), %eax
> +MACHO-x86-64:       23:        48 83 c4 08                                     addq    $8, %rsp
> +MACHO-x86-64:       27:        c3                                              ret
>
> Modified: llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp (original)
> +++ llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp Thu May 23 19:39:57 2013
> @@ -23,12 +23,16 @@
>  #include "llvm/ADT/StringExtras.h"
>  #include "llvm/ADT/Triple.h"
>  #include "llvm/MC/MCAsmInfo.h"
> +#include "llvm/MC/MCContext.h"
>  #include "llvm/MC/MCDisassembler.h"
>  #include "llvm/MC/MCInst.h"
>  #include "llvm/MC/MCInstPrinter.h"
>  #include "llvm/MC/MCInstrInfo.h"
> +#include "llvm/MC/MCObjectFileInfo.h"
> +#include "llvm/MC/MCObjectSymbolizer.h"
>  #include "llvm/MC/MCRegisterInfo.h"
>  #include "llvm/MC/MCSubtargetInfo.h"
> +#include "llvm/MC/MCRelocationInfo.h"
>  #include "llvm/Object/Archive.h"
>  #include "llvm/Object/COFF.h"
>  #include "llvm/Object/MachO.h"
> @@ -123,6 +127,10 @@ static cl::alias
>  PrivateHeadersShort("p", cl::desc("Alias for --private-headers"),
>                      cl::aliasopt(PrivateHeaders));
>
> +static cl::opt<bool>
> +Symbolize("symbolize", cl::desc("When disassembling instructions, "
> +                                "try to symbolize operands."));
> +
>  static StringRef ToolName;
>
>  bool llvm::error(error_code ec) {
> @@ -137,8 +145,13 @@ static const Target *getTarget(const Obj
>    // Figure out the target triple.
>    llvm::Triple TheTriple("unknown-unknown-unknown");
>    if (TripleName.empty()) {
> -    if (Obj)
> +    if (Obj) {
>        TheTriple.setArch(Triple::ArchType(Obj->getArch()));
> +      // TheTriple defaults to ELF, and COFF doesn't have an environment:
> +      // the best we can do here is indicate that it is mach-o.
> +      if (Obj->isMachO())
> +        TheTriple.setEnvironment(Triple::MachO);
> +    }
>    } else
>      TheTriple.setTriple(Triple::normalize(TripleName));
>
> @@ -216,7 +229,6 @@ static void DisassembleObject(const Obje
>    // Set up disassembler.
>    OwningPtr<const MCAsmInfo> AsmInfo(
>      TheTarget->createMCAsmInfo(*MRI, TripleName));
> -
>    if (!AsmInfo) {
>      errs() << "error: no assembly info for target " << TripleName << "\n";
>      return;
> @@ -224,23 +236,37 @@ static void DisassembleObject(const Obje
>
>    OwningPtr<const MCSubtargetInfo> STI(
>      TheTarget->createMCSubtargetInfo(TripleName, "", FeaturesStr));
> -
>    if (!STI) {
>      errs() << "error: no subtarget info for target " << TripleName << "\n";
>      return;
>    }
>
> -  OwningPtr<const MCDisassembler> DisAsm(
> -    TheTarget->createMCDisassembler(*STI));
> +  OwningPtr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
> +  if (!MII) {
> +    errs() << "error: no instruction info for target " << TripleName << "\n";
> +    return;
> +  }
> +
> +  OwningPtr<MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI));
>    if (!DisAsm) {
>      errs() << "error: no disassembler for target " << TripleName << "\n";
>      return;
>    }
>
> -  OwningPtr<const MCInstrInfo> MII(TheTarget->createMCInstrInfo());
> -  if (!MII) {
> -    errs() << "error: no instruction info for target " << TripleName << "\n";
> -    return;
> +  OwningPtr<const MCObjectFileInfo> MOFI;
> +  OwningPtr<MCContext> Ctx;
> +
> +  if (Symbolize) {
> +    MOFI.reset(new MCObjectFileInfo);
> +    Ctx.reset(new MCContext(*AsmInfo.get(), *MRI.get(), MOFI.get()));
> +    OwningPtr<MCRelocationInfo> RelInfo(
> +      TheTarget->createMCRelocationInfo(TripleName, *Ctx.get()));
> +    if (RelInfo) {
> +      OwningPtr<MCSymbolizer> Symzer(
> +        MCObjectSymbolizer::createObjectSymbolizer(*Ctx.get(), RelInfo, Obj));
> +      if (Symzer)
> +        DisAsm->setSymbolizer(Symzer);
> +    }
>    }
>
>    int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
> @@ -317,9 +343,13 @@ static void DisassembleObject(const Obje
>      if (Symbols.empty())
>        Symbols.push_back(std::make_pair(0, name));
>
> +
> +    SmallString<40> Comments;
> +    raw_svector_ostream CommentStream(Comments);
> +
>      StringRef Bytes;
>      if (error(i->getContents(Bytes))) break;
> -    StringRefMemoryObject memoryObject(Bytes);
> +    StringRefMemoryObject memoryObject(Bytes, SectionAddr);
>      uint64_t Size;
>      uint64_t Index;
>      uint64_t SectSize;
> @@ -353,14 +383,17 @@ static void DisassembleObject(const Obje
>        for (Index = Start; Index < End; Index += Size) {
>          MCInst Inst;
>
> -        if (DisAsm->getInstruction(Inst, Size, memoryObject, Index,
> -                                   DebugOut, nulls())) {
> +        if (DisAsm->getInstruction(Inst, Size, memoryObject,
> +                                   SectionAddr + Index,
> +                                   DebugOut, CommentStream)) {
>            outs() << format("%8" PRIx64 ":", SectionAddr + Index);
>            if (!NoShowRawInsn) {
>              outs() << "\t";
>              DumpBytes(StringRef(Bytes.data() + Index, Size));
>            }
>            IP->printInst(&Inst, outs(), "");
> +          outs() << CommentStream.str();
> +          Comments.clear();
>            outs() << "\n";
>          } else {
>            errs() << ToolName << ": warning: invalid instruction encoding\n";
>
> Modified: llvm/trunk/tools/llvm-objdump/llvm-objdump.h
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-objdump/llvm-objdump.h?rev=182625&r1=182624&r2=182625&view=diff
> ==============================================================================
> --- llvm/trunk/tools/llvm-objdump/llvm-objdump.h (original)
> +++ llvm/trunk/tools/llvm-objdump/llvm-objdump.h Thu May 23 19:39:57 2013
> @@ -38,16 +38,18 @@ void printELFFileHeader(const object::Ob
>  class StringRefMemoryObject : public MemoryObject {
>    virtual void anchor();
>    StringRef Bytes;
> +  uint64_t Base;
>  public:
> -  StringRefMemoryObject(StringRef bytes) : Bytes(bytes) {}
> +  StringRefMemoryObject(StringRef bytes, uint64_t Base = 0)
> +    : Bytes(bytes), Base(Base) {}
>
> -  uint64_t getBase() const { return 0; }
> +  uint64_t getBase() const { return Base; }
>    uint64_t getExtent() const { return Bytes.size(); }
>
>    int readByte(uint64_t Addr, uint8_t *Byte) const {
> -    if (Addr >= getExtent())
> +    if (Addr >= Base + getExtent() || Addr < Base)
>        return -1;
> -    *Byte = Bytes[Addr];
> +    *Byte = Bytes[Addr - Base];
>      return 0;
>    }
>  };
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits



More information about the llvm-commits mailing list