1 //===-- XCOFFDumper.cpp - XCOFF dumping utility -----------------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements an XCOFF specific dumper for llvm-readobj. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "Error.h" 14 #include "ObjDumper.h" 15 #include "llvm-readobj.h" 16 #include "llvm/Object/XCOFFObjectFile.h" 17 #include "llvm/Support/ScopedPrinter.h" 18 19 using namespace llvm; 20 using namespace object; 21 22 namespace { 23 24 class XCOFFDumper : public ObjDumper { 25 public: 26 XCOFFDumper(const XCOFFObjectFile &Obj, ScopedPrinter &Writer) 27 : ObjDumper(Writer), Obj(Obj) {} 28 29 void printFileHeaders() override; 30 void printSectionHeaders() override; 31 void printRelocations() override; 32 void printSymbols() override; 33 void printDynamicSymbols() override; 34 void printUnwindInfo() override; 35 void printStackMap() const override; 36 void printNeededLibraries() override; 37 38 private: 39 template <typename T> void printSectionHeaders(ArrayRef<T> Sections); 40 41 const XCOFFObjectFile &Obj; 42 43 // Least significant 3 bits are reserved. 44 static constexpr unsigned SectionFlagsReservedMask = 0x7; 45 }; 46 } // anonymous namespace 47 48 void XCOFFDumper::printFileHeaders() { 49 DictScope DS(W, "FileHeader"); 50 W.printHex("Magic", Obj.getMagic()); 51 W.printNumber("NumberOfSections", Obj.getNumberOfSections()); 52 53 // Negative timestamp values are reserved for future use. 54 int32_t TimeStamp = Obj.getTimeStamp(); 55 if (TimeStamp > 0) { 56 // This handling of the time stamp assumes that the host system's time_t is 57 // compatible with AIX time_t. If a platform is not compatible, the lit 58 // tests will let us know. 59 time_t TimeDate = TimeStamp; 60 61 char FormattedTime[21] = {}; 62 size_t BytesWritten = 63 strftime(FormattedTime, 21, "%Y-%m-%dT%H:%M:%SZ", gmtime(&TimeDate)); 64 if (BytesWritten) 65 W.printHex("TimeStamp", FormattedTime, TimeStamp); 66 else 67 W.printHex("Timestamp", TimeStamp); 68 } else { 69 W.printHex("TimeStamp", TimeStamp == 0 ? "None" : "Reserved Value", 70 TimeStamp); 71 } 72 73 // The number of symbol table entries is an unsigned value in 64-bit objects 74 // and a signed value (with negative values being 'reserved') in 32-bit 75 // objects. 76 if (Obj.is64Bit()) { 77 W.printHex("SymbolTableOffset", Obj.getSymbolTableOffset64()); 78 W.printNumber("SymbolTableEntries", Obj.getNumberOfSymbolTableEntries64()); 79 } else { 80 W.printHex("SymbolTableOffset", Obj.getSymbolTableOffset32()); 81 int32_t SymTabEntries = Obj.getRawNumberOfSymbolTableEntries32(); 82 if (SymTabEntries >= 0) 83 W.printNumber("SymbolTableEntries", SymTabEntries); 84 else 85 W.printHex("SymbolTableEntries", "Reserved Value", SymTabEntries); 86 } 87 88 W.printHex("OptionalHeaderSize", Obj.getOptionalHeaderSize()); 89 W.printHex("Flags", Obj.getFlags()); 90 91 // TODO FIXME Add support for the auxiliary header (if any) once 92 // XCOFFObjectFile has the necessary support. 93 } 94 95 void XCOFFDumper::printSectionHeaders() { 96 if (Obj.is64Bit()) 97 printSectionHeaders(Obj.sections64()); 98 else 99 printSectionHeaders(Obj.sections32()); 100 } 101 102 void XCOFFDumper::printRelocations() { 103 llvm_unreachable("Unimplemented functionality for XCOFFDumper"); 104 } 105 106 void XCOFFDumper::printSymbols() { 107 llvm_unreachable("Unimplemented functionality for XCOFFDumper"); 108 } 109 110 void XCOFFDumper::printDynamicSymbols() { 111 llvm_unreachable("Unimplemented functionality for XCOFFDumper"); 112 } 113 114 void XCOFFDumper::printUnwindInfo() { 115 llvm_unreachable("Unimplemented functionality for XCOFFDumper"); 116 } 117 118 void XCOFFDumper::printStackMap() const { 119 llvm_unreachable("Unimplemented functionality for XCOFFDumper"); 120 } 121 122 void XCOFFDumper::printNeededLibraries() { 123 llvm_unreachable("Unimplemented functionality for XCOFFDumper"); 124 } 125 126 static const EnumEntry<XCOFF::SectionTypeFlags> SectionTypeFlagsNames[] = { 127 #define ECase(X) \ 128 { #X, XCOFF::X } 129 ECase(STYP_PAD), ECase(STYP_DWARF), ECase(STYP_TEXT), 130 ECase(STYP_DATA), ECase(STYP_BSS), ECase(STYP_EXCEPT), 131 ECase(STYP_INFO), ECase(STYP_TDATA), ECase(STYP_TBSS), 132 ECase(STYP_LOADER), ECase(STYP_DEBUG), ECase(STYP_TYPCHK), 133 ECase(STYP_OVRFLO) 134 #undef ECase 135 }; 136 137 template <typename T> 138 void XCOFFDumper::printSectionHeaders(ArrayRef<T> Sections) { 139 ListScope Group(W, "Sections"); 140 141 uint16_t Index = 1; 142 for (const T &Sec : Sections) { 143 DictScope SecDS(W, "Section"); 144 145 W.printNumber("Index", Index++); 146 W.printString("Name", Sec.getName()); 147 148 W.printHex("PhysicalAddress", Sec.PhysicalAddress); 149 W.printHex("VirtualAddress", Sec.VirtualAddress); 150 W.printHex("Size", Sec.SectionSize); 151 W.printHex("RawDataOffset", Sec.FileOffsetToRawData); 152 W.printHex("RelocationPointer", Sec.FileOffsetToRelocationInfo); 153 W.printHex("LineNumberPointer", Sec.FileOffsetToLineNumberInfo); 154 155 // TODO Need to add overflow handling when NumberOfX == _OVERFLOW_MARKER 156 // in 32-bit object files. 157 W.printNumber("NumberOfRelocations", Sec.NumberOfRelocations); 158 W.printNumber("NumberOfLineNumbers", Sec.NumberOfLineNumbers); 159 160 // The most significant 16-bits represent the DWARF section subtype. For 161 // now we just dump the section type flags. 162 uint16_t Flags = Sec.Flags & 0xffffu; 163 if (Flags & SectionFlagsReservedMask) 164 W.printHex("Flags", "Reserved", Flags); 165 else 166 W.printEnum("Type", Flags, makeArrayRef(SectionTypeFlagsNames)); 167 } 168 169 if (opts::SectionRelocations) 170 report_fatal_error("Dumping section relocations is unimplemented"); 171 172 if (opts::SectionSymbols) 173 report_fatal_error("Dumping symbols is unimplemented"); 174 175 if (opts::SectionData) 176 report_fatal_error("Dumping section data is unimplemented"); 177 } 178 179 namespace llvm { 180 std::error_code createXCOFFDumper(const object::ObjectFile *Obj, 181 ScopedPrinter &Writer, 182 std::unique_ptr<ObjDumper> &Result) { 183 const XCOFFObjectFile *XObj = dyn_cast<XCOFFObjectFile>(Obj); 184 if (!XObj) 185 return readobj_error::unsupported_obj_file_format; 186 187 Result.reset(new XCOFFDumper(*XObj, Writer)); 188 return readobj_error::success; 189 } 190 } // namespace llvm 191