[SystemZ/z/OS] Add the GOFFDumper

[yusra.syeda]

Summary

This patch creates the GOFFDumper. It contains a test which uses llvm-readobj to check the symbols and relocations of the provided object file.
This requires https://reviews.llvm.org/D89071

llvm/test/tools/llvm-readobj/GOFF/goff-basic.test

+# RUN: llvm-readobj --symbols %p/Inputs/goff-basic.o | \
+# RUN: FileCheck --check-prefix=SYMBOLSEXP %s
+
+# RUN: llvm-readobj --relocs --expand-relocs %p/Inputs/goff-basic.o | \
+# RUN: FileCheck --check-prefix=RELOCSEXP %s
+
+# SYMBOLSEXP: File: {{.*}}goff-basic.o
+# SYMBOLSEXP-NEXT: Format: GOFF-SystemZ
+# SYMBOLSEXP-NEXT: Arch: s390x
+# SYMBOLSEXP-NEXT: AddressSize: 64bit
+# SYMBOLSEXP-NEXT: Symbols [
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: test#C
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: test#S
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: .&ppa2
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: a
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: b
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: d
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: CELQSTRT
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: A
+# SYMBOLSEXP-NEXT:     Value: 16
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: B
+# SYMBOLSEXP-NEXT:     Value: 48
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: D
+# SYMBOLSEXP-NEXT:     Value: 80
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: @a
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: @b
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT:   Symbol {
+# SYMBOLSEXP-NEXT:     Name: @d
+# SYMBOLSEXP-NEXT:     Value: 0
+# SYMBOLSEXP-NEXT:     Alignment: 0
+# SYMBOLSEXP-NEXT:   }
+# SYMBOLSEXP-NEXT: ]
+
+# RELOCSEXP: File: {{.*}}goff-basic.o
+# RELOCSEXP-NEXT: Format: GOFF-SystemZ
+# RELOCSEXP-NEXT: Arch: s390x
+# RELOCSEXP-NEXT: AddressSize: 64bit
+# RELOCSEXP-NEXT: Relocations [
+# RELOCSEXP-NEXT:  Section (1) C_CODE64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0xB6
+# RELOCSEXP-NEXT:      Type: R-2:0400:0000
+# RELOCSEXP-NEXT:      Symbol: CELQSTRT
+# RELOCSEXP-NEXT:      Flags: Fetch Code Add Length 0x4
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0xB6
+# RELOCSEXP-NEXT:      Type: R-2:0400:0002
+# RELOCSEXP-NEXT:      Symbol: test#C
+# RELOCSEXP-NEXT:      Flags: Fetch Code Subtract Length 0x4
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (2) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x10
+# RELOCSEXP-NEXT:      Type: R-0:0800:0001
+# RELOCSEXP-NEXT:      Symbol: d
+# RELOCSEXP-NEXT:      Flags: Store Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0001
+# RELOCSEXP-NEXT:      Symbol: a
+# RELOCSEXP-NEXT:      Flags: Store Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x8
+# RELOCSEXP-NEXT:      Type: R-0:0800:0001
+# RELOCSEXP-NEXT:      Symbol: b
+# RELOCSEXP-NEXT:      Flags: Store Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (3) C_@@QPPA2 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-2:0800:0000
+# RELOCSEXP-NEXT:      Symbol: test#C
+# RELOCSEXP-NEXT:      Flags: Fetch Code Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-2:0800:0002
+# RELOCSEXP-NEXT:      Symbol: CELQSTRT
+# RELOCSEXP-NEXT:      Flags: Fetch Code Subtract Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (7) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0000
+# RELOCSEXP-NEXT:      Symbol: a
+# RELOCSEXP-NEXT:      Flags: Fetch Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (8) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0000
+# RELOCSEXP-NEXT:      Symbol: b
+# RELOCSEXP-NEXT:      Flags: Fetch Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:  Section (9) C_WSA64 {
+# RELOCSEXP-NEXT:    Relocation {
+# RELOCSEXP-NEXT:      Offset: 0x0
+# RELOCSEXP-NEXT:      Type: R-0:0800:0000
+# RELOCSEXP-NEXT:      Symbol: d
+# RELOCSEXP-NEXT:      Flags: Fetch Add Length 0x8
+# RELOCSEXP-NEXT:    }
+# RELOCSEXP-NEXT:  }
+# RELOCSEXP-NEXT:]
+
+# goff-basic.o was compiled with `clang -c goff-basic.c`
+# from the following source:
+# int a = 55;
+# int b;
+# double d;
+# int A() { return a; }
+# int B() { return b; }
+# double D() { return d; }

llvm/tools/llvm-readobj/CMakeLists.txt

set(LLVM_LINK_COMPONENTS
   DebugInfoPDB
   )
 
 add_llvm_tool(llvm-readobj
   ARMWinEHPrinter.cpp
   COFFDumper.cpp
   COFFImportDumper.cpp
   ELFDumper.cpp
+  GOFFDumper.cpp
   llvm-readobj.cpp
   MachODumper.cpp
   ObjDumper.cpp
   WasmDumper.cpp
   Win64EHDumper.cpp
   WindowsResourceDumper.cpp
   XCOFFDumper.cpp
   )
 
 add_llvm_tool_symlink(llvm-readelf llvm-readobj)
 
 if(LLVM_INSTALL_BINUTILS_SYMLINKS)
   add_llvm_tool_symlink(readelf llvm-readobj)
 endif()

llvm/tools/llvm-readobj/GOFFDumper.cpp

+#include "ObjDumper.h"
+#include "llvm-readobj.h"
+#include "llvm/Object/GOFFObjectFile.h"
+#include "llvm/Support/ScopedPrinter.h"
+
+using namespace llvm;
+using namespace llvm::object;
+
+namespace {
+
+class GOFFDumper : public ObjDumper {
+public:
+  GOFFDumper(const GOFFObjectFile *Obj, ScopedPrinter &Writer)
+      : ObjDumper(Writer), Obj(Obj) {}
+
+  void printFileHeaders() override {}
+  void printSectionHeaders() override;
+  void printRelocations() override;
+  void printSymbols() override;
+  void printDynamicSymbols() override;
+  void printUnwindInfo() override {}
+  void printStackMap() const override {}
+
+  const object::GOFFObjectFile *getGOFFObject() const { return Obj; };
+
+private:
+  void printSymbol(const SymbolRef &Sym);
+  void printRelocation(const SectionRef &Section, const RelocationRef &Reloc);
+
+  const GOFFObjectFile *Obj;
+};
+
+} // End anonymous namespace
+
+namespace llvm {
+std::unique_ptr<ObjDumper> createGOFFDumper(const object::GOFFObjectFile &Obj,
+                                            ScopedPrinter &Writer) {
+  return std::make_unique<GOFFDumper>(&Obj, Writer);
+}
+
+} // namespace llvm
+
+void GOFFDumper::printSymbol(const SymbolRef &Symbol) {
+  DictScope D(W, "Symbol");
+
+  StringRef SymbolName;
+  if (!Obj->getSymbolName(Symbol, SymbolName))
+    W.printString("Name", SymbolName);
+  Expected<uint64_t> SymVal = Symbol.getValue();
+  if (!SymVal)
+    reportError(SymVal.takeError(), Obj->getFileName());
+  W.printNumber("Value", *SymVal);
+  W.printNumber("Alignment", Symbol.getAlignment());
+}
+
+void GOFFDumper::printRelocation(const SectionRef &Section,
+                                 const RelocationRef &Reloc) {
+  uint64_t Offset = Reloc.getOffset();
+  uint64_t RelocType = Reloc.getType();
+  SmallString<32> RelocName;
+  StringRef SymbolName;
+  Reloc.getTypeName(RelocName);
+  symbol_iterator Symbol = Reloc.getSymbol();
+  if (Symbol != Obj->symbol_end()) {
+    Expected<StringRef> SymbolNameOrErr = Symbol->getName();
+    if (!SymbolNameOrErr)
+      reportError(SymbolNameOrErr.takeError(), Obj->getFileName());
+
+    SymbolName = *SymbolNameOrErr;
+  }
+
+  std::vector<std::string> Flags;
+  Flags.push_back(Obj->getRLDFetchStore(RelocType) == GOFF::RLD_FS_Fetch
+                      ? "Fetch"
+                      : "Store");
+  if (Obj->getRLDIsCodeAddressReference(RelocType))
+    Flags.push_back("Code");
+  if (Obj->getRLDSymbolIsIndirect(RelocType))
+    Flags.push_back("Indirect");
+  if (Obj->getRLDIsWeak(RelocType))
+    Flags.push_back("Weak");
+  switch (Obj->getRLDAction(RelocType)) {
+#define CASE(X)                                                                \
+  case GOFF::RLD_ACT_##X:                                                      \
+    Flags.push_back(#X);                                                       \
+    break
+    CASE(Multiply);
+    CASE(Div4Quotient);
+    CASE(Div4Remainder);
+    CASE(And);
+    CASE(Or);
+    CASE(Xor);
+    CASE(Move);
+#undef CASE
+  }
+  uint8_t BitOffset = Obj->getRLDBitOffset(RelocType);
+  uint16_t BitLength = Obj->getRLDBitLength(RelocType);
+  if ((BitLength & 0x07) || BitOffset)
+    Flags.push_back(llvm::Twine("Bit Length+Offset 0x")
+                        .concat(llvm::utohexstr(BitLength))
+                        .concat(" +")
+                        .concat(llvm::utohexstr(BitOffset))
+                        .str());
+  else
+    Flags.push_back(
+        llvm::Twine("Length 0x").concat(llvm::utohexstr(BitLength >> 3)).str());
+
+  if (opts::ExpandRelocs) {
+    DictScope Group(W, "Relocation");
+    W.printHex("Offset", Offset);
+    W.printString("Type", RelocName);
+    W.printString("Symbol", SymbolName.empty() ? "-" : SymbolName);
+    W.printString("Flags", llvm::join(Flags, " "));
+  } else {
+    raw_ostream &OS = W.startLine();
+    OS << W.hex(Offset) << " " << RelocName << " "
+       << (SymbolName.empty() ? "-" : SymbolName) << " "
+       << llvm::join(Flags, " ") << "\n";
+  }
+}
+
+void GOFFDumper::printSectionHeaders() {
+  ListScope SectionsD(W, "Sections");
+  for (const SectionRef &Sec : Obj->sections()) {
+    StringRef Name = unwrapOrError(Obj->getFileName(), Sec.getName());
+
+    DictScope D(W, "Section");
+    W.printNumber("Index", Sec.getIndex());
+    W.printString("Name", Name);
+    W.printHex("Address", Sec.getAddress());
+    W.printHex("Size", Sec.getSize());
+    W.printNumber("Alignment", Sec.getAlignment());
+
+    if (opts::SectionRelocations) {
+      ListScope D(W, "Relocations");
+      for (const RelocationRef &Reloc : Sec.relocations())
+        printRelocation(Sec, Reloc);
+    }
+
+    if (opts::SectionSymbols) {
+      ListScope D(W, "Symbols");
+      for (const SymbolRef &Symbol : Obj->symbols()) {
+        if (!Sec.containsSymbol(Symbol))
+          continue;
+
+        printSymbol(Symbol);
+      }
+    }
+
+    if (opts::SectionData) {
+      StringRef Data = unwrapOrError(Obj->getFileName(), Sec.getContents());
+      W.printBinaryBlock("SectionData", Data);
+    }
+  }
+}
+
+void GOFFDumper::printSymbols() {
+  ListScope Group(W, "Symbols");
+
+  for (const SymbolRef &Symbol : Obj->symbols())
+    printSymbol(Symbol);
+}
+
+void GOFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); }
+
+void GOFFDumper::printRelocations() {
+  ListScope D(W, "Relocations");
+
+  for (const SectionRef &Section : Obj->sections()) {
+    StringRef Name = unwrapOrError(Obj->getFileName(), Section.getName());
+
+    bool PrintedGroup = false;
+    for (const RelocationRef &Reloc : Section.relocations()) {
+      if (!PrintedGroup) {
+        W.startLine() << "Section (" << Section.getIndex() << ") " << Name
+                      << " {\n";
+        W.indent();
+        PrintedGroup = true;
+      }
+
+      printRelocation(Section, Reloc);
+    }
+
+    if (PrintedGroup) {
+      W.unindent();
+      W.startLine() << "}\n";
+    }
+  }
+}

llvm/tools/llvm-readobj/ObjDumper.h

 //===-- ObjDumper.h ---------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 #define LLVM_TOOLS_LLVM_READOBJ_OBJDUMPER_H
 
 #include <memory>
 #include <system_error>
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace llvm {
 namespace object {
 class COFFImportFile;
 class ObjectFile;
+class GOFFObjectFile;
 class XCOFFObjectFile;
 class ELFObjectFileBase;
 }
 namespace codeview {
 class GlobalTypeTableBuilder;
 class MergingTypeTableBuilder;
 } // namespace codeview
 
std::unique_ptr<ObjDumper> createCOFFDumper(const object::COFFObjectFile &Obj,
                                             ScopedPrinter &Writer);
 
 std::unique_ptr<ObjDumper> createELFDumper(const object::ELFObjectFileBase &Obj,
                                            ScopedPrinter &Writer);
 
 std::unique_ptr<ObjDumper> createMachODumper(const object::MachOObjectFile &Obj,
                                              ScopedPrinter &Writer);
 
+std::unique_ptr<ObjDumper> createGOFFDumper(const object::GOFFObjectFile &Obj,
+                                            ScopedPrinter &Writer);
+
 std::unique_ptr<ObjDumper> createWasmDumper(const object::WasmObjectFile &Obj,
                                             ScopedPrinter &Writer);
 
 std::unique_ptr<ObjDumper> createXCOFFDumper(const object::XCOFFObjectFile &Obj,
                                              ScopedPrinter &Writer);
 
 void dumpCOFFImportFile(const object::COFFImportFile *File,
                         ScopedPrinter &Writer);
 
 void dumpCodeViewMergedTypes(ScopedPrinter &Writer,
                              ArrayRef<ArrayRef<uint8_t>> IpiRecords,
                              ArrayRef<ArrayRef<uint8_t>> TpiRecords);
 
 } // namespace llvm
 
 #endif

llvm/tools/llvm-readobj/llvm-readobj.cpp

 //===- llvm-readobj.cpp - Dump contents of an Object File -----------------===//
 //
 // 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-readobj.h"
 #include "ObjDumper.h"
 #include "WindowsResourceDumper.h"
 #include "llvm/DebugInfo/CodeView/GlobalTypeTableBuilder.h"
 #include "llvm/DebugInfo/CodeView/MergingTypeTableBuilder.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/GOFFObjectFile.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Object/WindowsResource.h"
 #include "llvm/Object/XCOFFObjectFile.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/DataTypes.h"
if (const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(&Obj))
     return createCOFFDumper(*COFFObj, Writer);
 
   if (const ELFObjectFileBase *ELFObj = dyn_cast<ELFObjectFileBase>(&Obj))
     return createELFDumper(*ELFObj, Writer);
 
   if (const MachOObjectFile *MachOObj = dyn_cast<MachOObjectFile>(&Obj))
     return createMachODumper(*MachOObj, Writer);
 
+  if (const GOFFObjectFile *GOFFObj = dyn_cast<GOFFObjectFile>(&Obj))
+    return createGOFFDumper(*GOFFObj, Writer);
+
   if (const WasmObjectFile *WasmObj = dyn_cast<WasmObjectFile>(&Obj))
     return createWasmDumper(*WasmObj, Writer);
 
   if (const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(&Obj))
     return createXCOFFDumper(*XObj, Writer);
 
   return createStringError(errc::invalid_argument,
                            "unsupported object file format");