[Disassembler] MCELFNoteDisassembler abstraction

[tpr]

Summary

This commit adds a new abstraction that a target can register with
TargetRegistry to disassemble an ELF note record. This is different to
the ELFNoteDumper abstraction I added in an earlier change; this new one
takes an MCTargetStreamer to stream directives into, and is intended for
a disassembler that wants to show the note record in a form that is
editable and re-assemblable.

A subsequent commit will add an implementation of this in AMDGPU.

There is currently no in-tree user of this.

Change-Id: I6a46db4f88b0d27a1abd06c878c2bf092bb1665b

[tpr]

See D52824 for the start of AMDGPU implementing this.

As there is currently no in-tree user, I would be happy with a review that says "LGTM subject to there being a testable in-tree user". Then I can keep the change in a holding pattern until we're in a position to upstream the code that uses it.

[arsenm]

include/llvm/MC/MCDisassembler/MCELFNoteDisassembler.h

1

Missing - before * for the mode comment

[tpr]

Ping.

include/llvm/MC/MCDisassembler/MCELFNoteDisassembler.h

+//===- llvm/MC/MCELFNoteDisassembler.h - MCELFNoteDisassembler 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 ELFNoteDisassembler class, which
+// is used to disassemble the contents of a note from the ELF .note section.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCDISASSEMBLER_MCELFNOTEDISASSEMBLER_H
+#define LLVM_MC_MCDISASSEMBLER_MCELFNOTEDISASSEMBLER_H
+
+#include "llvm/ADT/StringRef.h"
+
+namespace llvm {
+
+class MCSubtargetInfo;
+class MCTargetStreamer;
+class Twine;
+
+class MCELFNoteDisassembler {
+protected:
+  MCContext *Ctx;
+public:
+  MCELFNoteDisassembler(MCContext &Ctx, const MCSubtargetInfo *STI) : Ctx(&Ctx) {}
+
+  MCELFNoteDisassembler(const MCELFNoteDisassembler &) = delete;
+  MCELFNoteDisassembler &operator=(const MCELFNoteDisassembler &) = delete;
+  virtual ~MCELFNoteDisassembler() {}
+
+  // Disassemble one note from the ELF .note section into an MCTargetStreamer,
+  // adding assembler directives that would assemble to the semantically
+  // equivalent note.
+  // Returns false if the note type is not recognized or disassembly fails.
+  // The .note record descriptor (i.e. contents) is passed as a StringRef of
+  // bytes as found in the ELF file, together with an indication of the
+  // endianness of the ELF file.
+  virtual bool disassembleNote(unsigned Type, StringRef Name, StringRef Desc,
+               support::endianness TargetEndianness, MCTargetStreamer *TS) = 0;
+};
+
+} // end namespace llvm
+
+#endif // LLVM_MC_MCDISASSEMBLER_MCELFNOTEDISASSEMBLER_H

include/llvm/Support/TargetRegistry.h

 class AsmPrinter;
 class ELFNoteDumper;
 class MCAsmBackend;
 class MCAsmInfo;
 class MCAsmParser;
 class MCCodeEmitter;
 class MCContext;
 class MCDisassembler;
+class MCELFNoteDisassembler;
 class MCInstPrinter;
 class MCInstrAnalysis;
 class MCInstrInfo;
 class MCObjectWriter;
 class MCRegisterInfo;
 class MCRelocationInfo;
 class MCStreamer;
 class MCSubtargetInfo;
using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, const MCSubtargetInfo &STI);
   using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,
                                                        MCContext &Ctx);
   using MCSymbolizerCtorTy = MCSymbolizer *(*)(
       const Triple &TT, LLVMOpInfoCallback GetOpInfo,
       LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,
       std::unique_ptr<MCRelocationInfo> &&RelInfo);
   using ELFNoteDumperCtorTy = ELFNoteDumper *(*)(const Target &T);
+  using MCELFNoteDisassemblerCtorTy = MCELFNoteDisassembler *(*)(const Target &T,
+                                  MCContext &Ctx, const MCSubtargetInfo &STI);
 
 private:
   /// Next - The next registered target in the linked list, maintained by the
   /// TargetRegistry.
   Target *Next;
 
   /// The target function for checking if an architecture is supported.
   ArchMatchFnTy ArchMatchFn;
private:
   /// MCSymbolizerCtorFn - Construction function for this target's
   /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
   MCSymbolizerCtorTy MCSymbolizerCtorFn = nullptr;
 
   /// ELFNoteDumperCtorFn - Construction function for this target's
   /// ELF note dumper, if registered.
   ELFNoteDumperCtorTy ELFNoteDumperCtorFn = nullptr;
 
+  /// MCELFNoteDisassemblerCtorFn - Construction function for this target's
+  /// ELF note disassembler, if registered.
+  MCELFNoteDisassemblerCtorTy MCELFNoteDisassemblerCtorFn = nullptr;
+
 public:
   Target() = default;
 
   /// @name Target Information
   /// @{
 
   // getNext - Return the next registered target.
   const Target *getNext() const { return Next; }
public:
 
   /// createELFNoteDumper - Create a target specific ELFNoteDumper
   ELFNoteDumper *createELFNoteDumper() const {
     if (!ELFNoteDumperCtorFn)
       return nullptr;
     return ELFNoteDumperCtorFn(*this);
   }
 
+  /// createMCELFNoteDisassembler - Create a target specific MCELFNoteDisassembler
+  MCELFNoteDisassembler *createMCELFNoteDisassembler(MCContext *Ctx,
+                                            const MCSubtargetInfo &STI) const {
+    if (!MCELFNoteDisassemblerCtorFn)
+      return nullptr;
+    return MCELFNoteDisassemblerCtorFn(*this, *Ctx, STI);
+  }
+
   /// @}
 };
 
 /// TargetRegistry - Generic interface to target specific features.
 struct TargetRegistry {
   // FIXME: Make this a namespace, probably just move all the Register*
   // functions into Target (currently they all just set members on the Target
   // anyway, and Target friends this class so those functions can...
struct TargetRegistry {
   /// this is done by initializing all targets at program startup.
   ///
   /// @param T - The target being registered.
   /// @param Fn - A function to construct an ELFNoteDumper for the target.
   static void RegisterELFNoteDumper(Target &T, Target::ELFNoteDumperCtorTy Fn) {
     T.ELFNoteDumperCtorFn = Fn;
   }
 
+  /// RegisterMCELFNoteDisassembler - Register an MCELFNoteDisassembler
+  /// 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 MCELFNoteDisassembler for the target.
+  static void RegisterMCELFNoteDisassembler(Target &T,
+                                      Target::MCELFNoteDisassemblerCtorTy Fn) {
+    T.MCELFNoteDisassemblerCtorFn = Fn;
+  }
+
   /// @}
 };
 
 //===--------------------------------------------------------------------===//
 
 /// RegisterTarget - Helper template for registering a target, for use in the
 /// target's initialization function. Usage:
 ///