[AMDGPU][RFC] Combine asm and disasm tests.

Eliminates the need to replicate the same instructions in MC and
MC/Disassembler tests and synchronize changes in them. Also
highlights differences between disassembled, reassembled and
original instructions.

Author: kosarev

llvm/include/llvm/MC/TargetRegistry.h

@@ -88,7 +88,11 @@ createAsmStreamer(MCContext &Ctx, std::unique_ptr<formatted_raw_ostream> OS,
                   bool isVerboseAsm, bool useDwarfDirectory,
                   MCInstPrinter *InstPrint, std::unique_ptr<MCCodeEmitter> &&CE,
                   std::unique_ptr<MCAsmBackend> &&TAB, bool ShowInst);
-
+MCStreamer *createHexStreamer(MCContext &Ctx,
+                              std::unique_ptr<formatted_raw_ostream> OS,
+                              MCInstPrinter *InstPrint,
+                              std::unique_ptr<MCCodeEmitter> &&CE,
+                              std::unique_ptr<MCAsmBackend> &&TAB);
 MCStreamer *createELFStreamer(MCContext &Ctx,
                               std::unique_ptr<MCAsmBackend> &&TAB,
                               std::unique_ptr<MCObjectWriter> &&OW,
@@ -240,6 +244,9 @@ class Target {
   using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
       bool IsVerboseAsm);
+  using HexTargetStreamerCtorTy =
+      MCTargetStreamer *(*)(MCStreamer &S, formatted_raw_ostream &OS,
+                            MCInstPrinter *InstPrint);
   using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(
       MCStreamer &S, const MCSubtargetInfo &STI);
   using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,
@@ -352,6 +359,10 @@ class Target {
   /// registered (default = nullptr).
   AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn = nullptr;
 
+  /// Construction function for this target's hex TargetStreamer, if
+  /// registered (default = nullptr).
+  HexTargetStreamerCtorTy HexTargetStreamerCtorFn = nullptr;
+
   /// Construction function for this target's obj TargetStreamer, if
   /// registered (default = nullptr).
   ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn = nullptr;
@@ -680,6 +691,26 @@ class Target {
     return nullptr;
   }
 
+  MCStreamer *createHexStreamer(MCContext &Ctx,
+                                std::unique_ptr<formatted_raw_ostream> OS,
+                                MCInstPrinter *InstPrint,
+                                std::unique_ptr<MCCodeEmitter> &&CE,
+                                std::unique_ptr<MCAsmBackend> &&TAB) const {
+    formatted_raw_ostream &OSRef = *OS;
+    MCStreamer *S = llvm::createHexStreamer(Ctx, std::move(OS), InstPrint,
+                                            std::move(CE), std::move(TAB));
+    createHexTargetStreamer(*S, OSRef, InstPrint);
+    return S;
+  }
+
+  MCTargetStreamer *createHexTargetStreamer(MCStreamer &S,
+                                            formatted_raw_ostream &OS,
+                                            MCInstPrinter *InstPrint) const {
+    if (HexTargetStreamerCtorFn)
+      return HexTargetStreamerCtorFn(S, OS, InstPrint);
+    return nullptr;
+  }
+
   /// createMCRelocationInfo - Create a target specific MCRelocationInfo.
   ///
   /// \param TT The target triple.
@@ -1058,6 +1089,11 @@ struct TargetRegistry {
     T.AsmTargetStreamerCtorFn = Fn;
   }
 
+  static void RegisterHexTargetStreamer(Target &T,
+                                        Target::HexTargetStreamerCtorTy Fn) {
+    T.HexTargetStreamerCtorFn = Fn;
+  }
+
   static void
   RegisterObjectTargetStreamer(Target &T,
                                Target::ObjectTargetStreamerCtorTy Fn) {

llvm/lib/MC/CMakeLists.txt

@@ -25,6 +25,7 @@ add_llvm_component_library(LLVMMC
   MCExpr.cpp
   MCFragment.cpp
   MCGOFFStreamer.cpp
+  MCHexStreamer.cpp
   MCInst.cpp
   MCInstPrinter.cpp
   MCInstrAnalysis.cpp

llvm/lib/MC/MCHexStreamer.cpp

@@ -0,0 +1,89 @@
+//===- lib/MC/MCHexStreamer.cpp - Hex Output --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/MC/MCAsmBackend.h"
+#include "llvm/MC/MCAssembler.h"
+#include "llvm/MC/MCCodeEmitter.h"
+#include "llvm/MC/MCInstPrinter.h"
+#include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCStreamer.h"
+#include "llvm/MC/TargetRegistry.h"
+
+using namespace llvm;
+
+namespace {
+
+class MCHexStreamer final : public MCStreamer {
+  std::unique_ptr<formatted_raw_ostream> OSOwner;
+  formatted_raw_ostream &OS;
+  std::unique_ptr<MCInstPrinter> InstPrinter;
+  std::unique_ptr<MCAssembler> Assembler;
+
+  raw_null_ostream NullStream;
+
+public:
+  MCHexStreamer(MCContext &Context, std::unique_ptr<formatted_raw_ostream> os,
+                MCInstPrinter *printer, std::unique_ptr<MCCodeEmitter> emitter,
+                std::unique_ptr<MCAsmBackend> asmbackend)
+      : MCStreamer(Context), OSOwner(std::move(os)), OS(*OSOwner),
+        InstPrinter(printer),
+        Assembler(std::make_unique<MCAssembler>(
+            Context, std::move(asmbackend), std::move(emitter),
+            asmbackend ? asmbackend->createObjectWriter(NullStream)
+                       : nullptr)) {
+    assert(InstPrinter);
+  }
+
+  MCAssembler &getAssembler() { return *Assembler; }
+
+  /// @name MCStreamer Interface
+  /// @{
+
+  bool emitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override {
+    return true;
+  }
+
+  void emitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
+                        Align ByteAlignment) override {}
+
+  void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
+                    uint64_t Size = 0, Align ByteAlignment = Align(1),
+                    SMLoc Loc = SMLoc()) override {}
+
+  void emitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
+};
+
+} // end anonymous namespace.
+
+void MCHexStreamer::emitInstruction(const MCInst &Inst,
+                                    const MCSubtargetInfo &STI) {
+  SmallString<256> Code;
+  SmallVector<MCFixup, 4> Fixups;
+  getAssembler().getEmitter().encodeInstruction(Inst, Code, Fixups, STI);
+
+  OS << "[";
+  for (auto [I, B] : enumerate(Code))
+    OS << (I != 0 ? "," : "") << format("0x%02x", B & 0xff);
+  OS << "]  #";
+
+  if (getTargetStreamer())
+    getTargetStreamer()->prettyPrintAsm(*InstPrinter, 0, Inst, STI, OS);
+  else
+    InstPrinter->printInst(&Inst, 0, "", STI, OS);
+
+  OS << "\n";
+}
+
+MCStreamer *llvm::createHexStreamer(MCContext &Context,
+                                    std::unique_ptr<formatted_raw_ostream> OS,
+                                    MCInstPrinter *IP,
+                                    std::unique_ptr<MCCodeEmitter> &&CE,
+                                    std::unique_ptr<MCAsmBackend> &&MAB) {
+  return new MCHexStreamer(Context, std::move(OS), IP, std::move(CE),
+                           std::move(MAB));
+}