diff --git a/llvm/include/llvm/BinaryFormat/XCOFF.h b/llvm/include/llvm/BinaryFormat/XCOFF.h --- a/llvm/include/llvm/BinaryFormat/XCOFF.h +++ b/llvm/include/llvm/BinaryFormat/XCOFF.h @@ -33,6 +33,8 @@ enum ReservedSectionNum : int16_t { N_DEBUG = -2, N_ABS = -1, N_UNDEF = 0 }; +enum MagicNumber : uint16_t { XCOFF32 = 0x01DF, XCOFF64 = 0x01F7 }; + // x_smclas field of x_csect from system header: /usr/include/syms.h /// Storage Mapping Class definitions. enum StorageMappingClass : uint8_t { diff --git a/llvm/include/llvm/ObjectYAML/ObjectYAML.h b/llvm/include/llvm/ObjectYAML/ObjectYAML.h --- a/llvm/include/llvm/ObjectYAML/ObjectYAML.h +++ b/llvm/include/llvm/ObjectYAML/ObjectYAML.h @@ -15,6 +15,7 @@ #include "llvm/ObjectYAML/MachOYAML.h" #include "llvm/ObjectYAML/MinidumpYAML.h" #include "llvm/ObjectYAML/WasmYAML.h" +#include "llvm/ObjectYAML/XCOFFYAML.h" #include "llvm/Support/YAMLTraits.h" #include @@ -31,6 +32,7 @@ std::unique_ptr FatMachO; std::unique_ptr Minidump; std::unique_ptr Wasm; + std::unique_ptr Xcoff; }; template <> struct MappingTraits { diff --git a/llvm/include/llvm/ObjectYAML/XCOFFYAML.h b/llvm/include/llvm/ObjectYAML/XCOFFYAML.h --- a/llvm/include/llvm/ObjectYAML/XCOFFYAML.h +++ b/llvm/include/llvm/ObjectYAML/XCOFFYAML.h @@ -23,29 +23,55 @@ llvm::yaml::Hex16 Magic; uint16_t NumberOfSections; int32_t TimeStamp; - llvm::yaml::Hex32 SymbolTableOffset; // File offset to symbol table. - int32_t NumberOfSymTableEntries; + llvm::yaml::Hex64 SymbolTableOffset; + uint32_t NumberOfSymTableEntries; uint16_t AuxHeaderSize; llvm::yaml::Hex16 Flags; }; +struct Relocation { + llvm::yaml::Hex64 VirtualAddress; + llvm::yaml::Hex64 SymbolIndex; + llvm::yaml::Hex8 Info; + llvm::yaml::Hex8 Type; +}; + +struct Section { + StringRef SectionName; + llvm::yaml::Hex64 Address; + llvm::yaml::Hex64 Size; + llvm::yaml::Hex64 FileOffsetToData; + llvm::yaml::Hex64 FileOffsetToRelocations; + llvm::yaml::Hex64 FileOffsetToLineNumbers; // Line number pointer. Not supported yet. + llvm::yaml::Hex16 NumberOfRelocations; + llvm::yaml::Hex16 NumberOfLineNumbers; // Line number counts. Not supported yet. + llvm::yaml::Hex32 Flags; + yaml::BinaryRef SectionData; + std::vector Relocations; +}; + struct Symbol { StringRef SymbolName; - llvm::yaml::Hex32 Value; // Symbol value; storage class-dependent. + llvm::yaml::Hex64 Value; // Symbol value; storage class-dependent. StringRef SectionName; llvm::yaml::Hex16 Type; XCOFF::StorageClass StorageClass; - uint8_t NumberOfAuxEntries; // Number of auxiliary entries + uint8_t NumberOfAuxEntries; }; struct Object { FileHeader Header; + std::vector
Sections; std::vector Symbols; Object(); }; } // namespace XCOFFYAML } // namespace llvm + LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Symbol) +LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Relocation) +LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Section) + namespace llvm { namespace yaml { @@ -57,14 +83,23 @@ static void mapping(IO &IO, XCOFFYAML::FileHeader &H); }; -template <> struct MappingTraits { - static void mapping(IO &IO, XCOFFYAML::Object &Obj); -}; template <> struct MappingTraits { static void mapping(IO &IO, XCOFFYAML::Symbol &S); }; +template <> struct MappingTraits { + static void mapping(IO &IO, XCOFFYAML::Relocation &R); +}; + +template <> struct MappingTraits { + static void mapping(IO &IO, XCOFFYAML::Section &Sec); +}; + +template <> struct MappingTraits { + static void mapping(IO &IO, XCOFFYAML::Object &Obj); +}; + } // namespace yaml } // namespace llvm diff --git a/llvm/include/llvm/ObjectYAML/yaml2obj.h b/llvm/include/llvm/ObjectYAML/yaml2obj.h --- a/llvm/include/llvm/ObjectYAML/yaml2obj.h +++ b/llvm/include/llvm/ObjectYAML/yaml2obj.h @@ -40,6 +40,10 @@ struct Object; } +namespace XCOFFYAML { +struct Object; +} + namespace ArchYAML { struct Archive; } @@ -58,6 +62,7 @@ bool yaml2minidump(MinidumpYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH); bool yaml2wasm(WasmYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH); +bool yaml2xcoff(XCOFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH); bool convertYAML(Input &YIn, raw_ostream &Out, ErrorHandler ErrHandler, unsigned DocNum = 1, uint64_t MaxSize = UINT64_MAX); diff --git a/llvm/lib/ObjectYAML/CMakeLists.txt b/llvm/lib/ObjectYAML/CMakeLists.txt --- a/llvm/lib/ObjectYAML/CMakeLists.txt +++ b/llvm/lib/ObjectYAML/CMakeLists.txt @@ -18,6 +18,7 @@ MinidumpYAML.cpp WasmEmitter.cpp WasmYAML.cpp + XCOFFEmitter.cpp XCOFFYAML.cpp YAML.cpp yaml2obj.cpp diff --git a/llvm/lib/ObjectYAML/ObjectYAML.cpp b/llvm/lib/ObjectYAML/ObjectYAML.cpp --- a/llvm/lib/ObjectYAML/ObjectYAML.cpp +++ b/llvm/lib/ObjectYAML/ObjectYAML.cpp @@ -59,6 +59,9 @@ } else if (IO.mapTag("!WASM")) { ObjectFile.Wasm.reset(new WasmYAML::Object()); MappingTraits::mapping(IO, *ObjectFile.Wasm); + } else if (IO.mapTag("!XCOFF")) { + ObjectFile.Xcoff.reset(new XCOFFYAML::Object()); + MappingTraits::mapping(IO, *ObjectFile.Xcoff); } else if (const Node *N = In.getCurrentNode()) { if (N->getRawTag().empty()) IO.setError("YAML Object File missing document type tag!"); diff --git a/llvm/lib/ObjectYAML/XCOFFEmitter.cpp b/llvm/lib/ObjectYAML/XCOFFEmitter.cpp --- a/llvm/lib/ObjectYAML/XCOFFEmitter.cpp +++ b/llvm/lib/ObjectYAML/XCOFFEmitter.cpp @@ -0,0 +1,305 @@ +//===- yaml2xcoff - Convert YAML to a xcoff 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 +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// The xcoff component of yaml2obj. +/// +//===----------------------------------------------------------------------===// +#include "llvm/ADT/StringSwitch.h" +#include "llvm/BinaryFormat/XCOFF.h" +#include "llvm/Object/XCOFFObjectFile.h" +#include "llvm/ObjectYAML/ObjectYAML.h" +#include "llvm/ObjectYAML/yaml2obj.h" +#include "llvm/Support/EndianStream.h" +#include "llvm/Support/raw_ostream.h" + +using namespace llvm; + +namespace { + +constexpr unsigned DefaultSectionAlign = 4; +constexpr int16_t MaxSectionIndex = INT16_MAX; +constexpr uint32_t MaxRawDataSize = UINT32_MAX; + +class XCOFFWriter { +public: + XCOFFWriter(XCOFFYAML::Object &Obj, raw_ostream &OS, yaml::ErrorHandler EH) + : Obj(Obj), W(OS, support::big), ErrHandler(EH) {} + bool writeXCOFF(); + +private: + bool initFileHeader(uint64_t CurrentOffset); + bool initSectionHeader(uint64_t &CurrentOffset); + bool initRelocations(uint64_t &CurrentOffset); + bool assignAddressesAndIndices(); + void writeFileHeader(); + void writeSectionHeader(); + bool writeSectionData(); + bool writeRelocations(); + bool writeSymbols(); + + XCOFFYAML::Object &Obj; + support::endian::Writer W; + yaml::ErrorHandler ErrHandler; + uint64_t StartOffset; + // Map the section name to its corrresponding section index. + DenseMap SectionIndexMap = { + {StringRef("N_DEBUG"), XCOFF::N_DEBUG}, + {StringRef("N_ABS"), XCOFF::N_ABS}, + {StringRef("N_UNDEF"), XCOFF::N_UNDEF}}; + XCOFFYAML::FileHeader InitFileHdr = Obj.Header; + std::vector InitSections = Obj.Sections; +}; + +bool XCOFFWriter::initRelocations(uint64_t &CurrentOffset) { + for (uint16_t I = 0, E = InitSections.size(); I < E; ++I) { + if (!InitSections[I].Relocations.empty()) { + InitSections[I].NumberOfRelocations = InitSections[I].Relocations.size(); + InitSections[I].FileOffsetToRelocations = CurrentOffset; + CurrentOffset += InitSections[I].NumberOfRelocations * + XCOFF::RelocationSerializationSize32; + if (CurrentOffset > MaxRawDataSize) { + ErrHandler("relocation data overflowed the MaxRawDataSize: " + + Twine(MaxRawDataSize)); + return false; + } + } + } + return true; +} + +bool XCOFFWriter::initSectionHeader(uint64_t &CurrentOffset) { + uint64_t CurrentSecAddr = 0; + for (uint16_t I = 0, E = InitSections.size(); I < E; ++I) { + if (CurrentOffset > MaxRawDataSize) { + ErrHandler("section data overflowed the MaxRawDataSize: " + + Twine(MaxRawDataSize)); + return false; + } + + // Assign indices for sections. + if (!SectionIndexMap[InitSections[I].SectionName]) { + // The section index starts from 1. + SectionIndexMap[InitSections[I].SectionName] = I + 1; + if ((I + 1) > MaxSectionIndex) { + ErrHandler("section index overflowed the MaxSectionIndex: " + + Twine(MaxSectionIndex)); + return false; + } + } + + // Calculate the physical/virtual address. + // This field should contain 0 for all sections except the .text, .data and + // .bss sections. + if (InitSections[I].Flags != XCOFF::STYP_TEXT && + InitSections[I].Flags != XCOFF::STYP_DATA && + InitSections[I].Flags != XCOFF::STYP_BSS) + InitSections[I].Address = 0; + else + InitSections[I].Address = CurrentSecAddr; + + // Calculate the FileOffsetToData and data size for sections. + if (InitSections[I].SectionData.binary_size()) { + InitSections[I].FileOffsetToData = CurrentOffset; + CurrentOffset += InitSections[I].SectionData.binary_size(); + // Ensure the address is aligned to DefaultSectionAlign. + CurrentOffset = alignTo(CurrentOffset, DefaultSectionAlign); + InitSections[I].Size = CurrentOffset - InitSections[I].FileOffsetToData; + CurrentSecAddr += InitSections[I].Size; + } + } + if (!initRelocations(CurrentOffset)) + return false; + return true; +} + +bool XCOFFWriter::initFileHeader(uint64_t CurrentOffset) { + // The default format of the object file is XCOFF32. + InitFileHdr.Magic = XCOFF::XCOFF32; + InitFileHdr.NumberOfSections = Obj.Sections.size(); + + // Count the number of auxiliary symbols into the total number. + InitFileHdr.NumberOfSymTableEntries = Obj.Symbols.size(); + for (XCOFFYAML::Symbol YamlSym : Obj.Symbols) + InitFileHdr.NumberOfSymTableEntries += YamlSym.NumberOfAuxEntries; + + // Calculate SymbolTableOffset for the file header. + if (InitFileHdr.NumberOfSymTableEntries) { + InitFileHdr.SymbolTableOffset = CurrentOffset; + CurrentOffset += + InitFileHdr.NumberOfSymTableEntries * XCOFF::SymbolTableEntrySize; + if (CurrentOffset > MaxRawDataSize) { + ErrHandler("symbol address overflowed the MaxRawDataSize: " + + Twine(MaxRawDataSize)); + return false; + } + } + // TODO: Calculate FileOffsetToLineNumbers when line number supported. + return true; +} + +bool XCOFFWriter::assignAddressesAndIndices() { + // TODO: Add support for 64-bit. + if ((uint16_t)Obj.Header.Magic != XCOFF::XCOFF32) { + ErrHandler("only XCOFF32 is supported now"); + return false; + } + uint64_t CurrentOffset = + sizeof(XCOFF::FileHeader32) /* TODO: + auxiliaryHeaderSize() */ + + InitSections.size() * sizeof(XCOFF::SectionHeader32); + + // Calculate section header info. + if (!initSectionHeader(CurrentOffset)) + return false; + // Calculate file header info. + return initFileHeader(CurrentOffset); +} + +void XCOFFWriter::writeFileHeader() { + W.write(Obj.Header.Magic ? Obj.Header.Magic : InitFileHdr.Magic); + W.write(Obj.Header.NumberOfSections ? Obj.Header.NumberOfSections + : InitFileHdr.NumberOfSections); + W.write(Obj.Header.TimeStamp); + W.write(Obj.Header.SymbolTableOffset + ? Obj.Header.SymbolTableOffset + : InitFileHdr.SymbolTableOffset); + W.write(Obj.Header.NumberOfSymTableEntries + ? Obj.Header.NumberOfSymTableEntries + : InitFileHdr.NumberOfSymTableEntries); + W.write(Obj.Header.AuxHeaderSize); + W.write(Obj.Header.Flags); +} + +void XCOFFWriter::writeSectionHeader() { + for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) { + XCOFFYAML::Section YamlSec = Obj.Sections[I]; + XCOFFYAML::Section DerivedSec = InitSections[I]; + W.OS.write(YamlSec.SectionName.data(), sizeof(XCOFF::NameSize)); + // Virtual address is the same as physical address. + llvm::yaml::Hex64 SectionAddress = + YamlSec.Address ? YamlSec.Address : DerivedSec.Address; + W.write(SectionAddress); + W.write(SectionAddress); + W.write(YamlSec.Size ? YamlSec.Size : DerivedSec.Size); + W.write(YamlSec.FileOffsetToData ? YamlSec.FileOffsetToData + : DerivedSec.FileOffsetToData); + W.write(YamlSec.FileOffsetToRelocations + ? YamlSec.FileOffsetToRelocations + : DerivedSec.FileOffsetToRelocations); + W.write(YamlSec.FileOffsetToLineNumbers); + W.write(YamlSec.NumberOfRelocations + ? YamlSec.NumberOfRelocations + : DerivedSec.NumberOfRelocations); + W.write(YamlSec.NumberOfLineNumbers); + W.write(YamlSec.Flags); + } +} + +bool XCOFFWriter::writeSectionData() { + for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) { + XCOFFYAML::Section YamlSec = Obj.Sections[I]; + if (YamlSec.SectionData.binary_size()) { + // Fill the padding size with zeros. + int64_t PaddingSize = + InitSections[I].FileOffsetToData - (W.OS.tell() - StartOffset); + if (PaddingSize < 0) { + ErrHandler("redundant data was written before section data"); + return false; + } + W.OS.write_zeros(PaddingSize); + YamlSec.SectionData.writeAsBinary(W.OS); + } + } + return true; +} + +bool XCOFFWriter::writeRelocations() { + for (uint16_t I = 0, E = Obj.Sections.size(); I < E; ++I) { + XCOFFYAML::Section YamlSec = Obj.Sections[I]; + if (!YamlSec.Relocations.empty()) { + int64_t PaddingSize = + InitSections[I].FileOffsetToRelocations - (W.OS.tell() - StartOffset); + if (PaddingSize < 0) { + ErrHandler("redundant data was written before relocations"); + return false; + } + W.OS.write_zeros(PaddingSize); + for (XCOFFYAML::Relocation &YamlRel : YamlSec.Relocations) { + W.write(YamlRel.VirtualAddress); + W.write(YamlRel.SymbolIndex); + W.write(YamlRel.Info); + W.write(YamlRel.Type); + } + } + } + return true; +} + +bool XCOFFWriter::writeSymbols() { + int64_t PaddingSize = + (uint64_t)InitFileHdr.SymbolTableOffset - (W.OS.tell() - StartOffset); + if (PaddingSize < 0) { + ErrHandler("redundant data was written before symbols"); + return false; + } + W.OS.write_zeros(PaddingSize); + for (XCOFFYAML::Symbol &YamlSym : Obj.Symbols) { + if (YamlSym.SymbolName.size() > XCOFF::NameSize) { + ErrHandler("string table is not supported yet"); + return false; + } + W.OS.write(YamlSym.SymbolName.data(), sizeof(XCOFF::NameSize)); + W.write(YamlSym.Value); + W.write(SectionIndexMap[YamlSym.SectionName]); + W.write(YamlSym.Type); + W.write(YamlSym.StorageClass); + W.write(YamlSym.NumberOfAuxEntries); + + // Now output the auxiliary entry. + for (uint8_t I = 0, E = YamlSym.NumberOfAuxEntries; I < E; ++I) { + // TODO: Auxiliary entry is not supported yet. + // The auxiliary entries for a symbol follow its symbol table entry. The + // length of each auxiliary entry is the same as a symbol table entry (18 + // bytes). The format and quantity of auxiliary entries depend on the + // storage class (n_sclass) and type (n_type) of the symbol table entry. + W.OS.write_zeros(18); + } + } + return true; +} + +bool XCOFFWriter::writeXCOFF() { + if (!assignAddressesAndIndices()) + return false; + StartOffset = W.OS.tell(); + writeFileHeader(); + if (!Obj.Sections.empty()) { + writeSectionHeader(); + if (!writeSectionData()) + return false; + if (!writeRelocations()) + return false; + } + if (!Obj.Symbols.empty()) + return writeSymbols(); + // TODO: Add support for the string table. + return true; +} + +} // end anonymous namespace + +namespace llvm { +namespace yaml { + +bool yaml2xcoff(XCOFFYAML::Object &Doc, raw_ostream &Out, ErrorHandler EH) { + XCOFFWriter Writer(Doc, Out, EH); + return Writer.writeXCOFF(); +} + +} // namespace yaml +} // namespace llvm diff --git a/llvm/lib/ObjectYAML/XCOFFYAML.cpp b/llvm/lib/ObjectYAML/XCOFFYAML.cpp --- a/llvm/lib/ObjectYAML/XCOFFYAML.cpp +++ b/llvm/lib/ObjectYAML/XCOFFYAML.cpp @@ -81,28 +81,52 @@ void MappingTraits::mapping( IO &IO, XCOFFYAML::FileHeader &FileHdr) { - IO.mapRequired("MagicNumber", FileHdr.Magic); - IO.mapRequired("NumberOfSections", FileHdr.NumberOfSections); - IO.mapRequired("CreationTime", FileHdr.TimeStamp); - IO.mapRequired("OffsetToSymbolTable", FileHdr.SymbolTableOffset); - IO.mapRequired("EntriesInSymbolTable", FileHdr.NumberOfSymTableEntries); - IO.mapRequired("AuxiliaryHeaderSize", FileHdr.AuxHeaderSize); - IO.mapRequired("Flags", FileHdr.Flags); + IO.mapOptional("MagicNumber", FileHdr.Magic); + IO.mapOptional("NumberOfSections", FileHdr.NumberOfSections); + IO.mapOptional("CreationTime", FileHdr.TimeStamp); + IO.mapOptional("OffsetToSymbolTable", FileHdr.SymbolTableOffset); + IO.mapOptional("EntriesInSymbolTable", FileHdr.NumberOfSymTableEntries); + IO.mapOptional("AuxiliaryHeaderSize", FileHdr.AuxHeaderSize); + IO.mapOptional("Flags", FileHdr.Flags); +} + +void MappingTraits::mapping(IO &IO, + XCOFFYAML::Relocation &R) { + IO.mapRequired("Address", R.VirtualAddress); + IO.mapOptional("Symbol", R.SymbolIndex); + IO.mapOptional("Info", R.Info); + IO.mapRequired("Type", R.Type); +} + +void MappingTraits::mapping(IO &IO, + XCOFFYAML::Section &Sec) { + IO.mapOptional("Name", Sec.SectionName); + IO.mapOptional("Address", Sec.Address); + IO.mapOptional("Size", Sec.Size); + IO.mapOptional("FileOffsetToData", Sec.FileOffsetToData); + IO.mapOptional("FileOffsetToRelocations", Sec.FileOffsetToRelocations); + IO.mapOptional("FileOffsetToLineNumbers", Sec.FileOffsetToLineNumbers); + IO.mapOptional("NumberOfRelocations", Sec.NumberOfRelocations); + IO.mapOptional("NumberOfLineNumbers", Sec.NumberOfLineNumbers); + IO.mapRequired("Flags", Sec.Flags); + IO.mapOptional("SectionData", Sec.SectionData); + IO.mapOptional("Relocations", Sec.Relocations); } void MappingTraits::mapping(IO &IO, XCOFFYAML::Symbol &S) { IO.mapRequired("Name", S.SymbolName); - IO.mapRequired("Value", S.Value); + IO.mapOptional("Value", S.Value); IO.mapRequired("Section", S.SectionName); - IO.mapRequired("Type", S.Type); - IO.mapRequired("StorageClass", S.StorageClass); - IO.mapRequired("NumberOfAuxEntries", S.NumberOfAuxEntries); + IO.mapOptional("Type", S.Type); + IO.mapOptional("StorageClass", S.StorageClass); + IO.mapOptional("NumberOfAuxEntries", S.NumberOfAuxEntries); } void MappingTraits::mapping(IO &IO, XCOFFYAML::Object &Obj) { IO.mapTag("!XCOFF", true); IO.mapRequired("FileHeader", Obj.Header); - IO.mapRequired("Symbols", Obj.Symbols); + IO.mapOptional("Sections", Obj.Sections); + IO.mapOptional("Symbols", Obj.Symbols); } } // namespace yaml diff --git a/llvm/lib/ObjectYAML/yaml2obj.cpp b/llvm/lib/ObjectYAML/yaml2obj.cpp --- a/llvm/lib/ObjectYAML/yaml2obj.cpp +++ b/llvm/lib/ObjectYAML/yaml2obj.cpp @@ -44,6 +44,8 @@ return yaml2minidump(*Doc.Minidump, Out, ErrHandler); if (Doc.Wasm) return yaml2wasm(*Doc.Wasm, Out, ErrHandler); + if (Doc.Xcoff) + return yaml2xcoff(*Doc.Xcoff, Out, ErrHandler); ErrHandler("unknown document type"); return false; diff --git a/llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml b/llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml --- a/llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml +++ b/llvm/test/tools/yaml2obj/XCOFF/basic-doc.yaml @@ -0,0 +1,149 @@ +# Check that yaml2obj automatically assigns ommited fields with values. +# RUN: yaml2obj %s -o %t +# RUN: llvm-readobj --headers %t | FileCheck %s --check-prefix=CHECK-HEADERS +# RUN: llvm-readobj --symbols %t | FileCheck %s --check-prefix=CHECK-SYMBOLS + +--- !XCOFF +FileHeader: + MagicNumber: 0x1DF +Sections: + - Name: .text + Flags: 0x20 + SectionData: "9061FFF8808200008064000038630001906400008061FFF8386300019061FFF88061FFF88082000480840000888400007C6322149061FFF88061FFF84E8000200000000000092040800001010000000000000040000466756E310000600000007C0802A693E1FFFC900100089421FFB07C3F0B7838600000907F004880620008907F0044808300003884000190830000806300004BFFFF6D60000000807F0044806300004BFFFF5D60000000382100508001000883E1FFFC7C0803A64E8000200000000000092261800100010000006000046D61696E1F006162636400000000" + - Name: .data + Flags: 0x40 + SectionData: "00000000000000FC0000000000000060000000FC00000000000000D800000108000000F800000000" + Relocations: + - Address: 0x3A + Symbol: 1 + Info: 0x04 + Type: 0x02 + - Name: .bss + Flags: 0x80 +Symbols: + - Name: .file + Value: 0x0 + Section: N_DEBUG + Type: 0x0 + StorageClass: C_FILE + NumberOfAuxEntries: 1 + - Name: .text + Value: 0x0 + Section: .text + Type: 0x0 + StorageClass: C_HIDEXT + NumberOfAuxEntries: 1 + - Name: i + Value: 0x0 + Section: .data + Type: 0x0 + StorageClass: C_EXT + NumberOfAuxEntries: 1 + +# CHECK-HEADERS: FileHeader { +# CHECK-HEADERS-NEXT: Magic: 0x1DF +# CHECK-HEADERS-NEXT: NumberOfSections: 3 +# CHECK-HEADERS-NEXT: TimeStamp: None (0x0) +# CHECK-HEADERS-NEXT: SymbolTableOffset: 0x19E +# CHECK-HEADERS-NEXT: SymbolTableEntries: 6 +# CHECK-HEADERS-NEXT: OptionalHeaderSize: 0x0 +# CHECK-HEADERS-NEXT: Flags: 0x0 +# CHECK-HEADERS-NEXT: } +# CHECK-HEADERS: Sections [ +# CHECK-HEADERS-NEXT: Section { +# CHECK-HEADERS-NEXT: Index: 1 +# CHECK-HEADERS-NEXT: Name: .text +# CHECK-HEADERS: PhysicalAddress: 0x0 +# CHECK-HEADERS-NEXT: VirtualAddress: 0x0 +# CHECK-HEADERS-NEXT: Size: 0xE0 +# CHECK-HEADERS-NEXT: RawDataOffset: 0x8C +# CHECK-HEADERS-NEXT: RelocationPointer: 0x0 +# CHECK-HEADERS-NEXT: LineNumberPointer: 0x0 +# CHECK-HEADERS-NEXT: NumberOfRelocations: 0 +# CHECK-HEADERS-NEXT: NumberOfLineNumbers: 0 +# CHECK-HEADERS-NEXT: Type: STYP_TEXT (0x20) +# CHECK-HEADERS-NEXT: } +# CHECK-HEADERS-NEXT: Section { +# CHECK-HEADERS-NEXT: Index: 2 +# CHECK-HEADERS-NEXT: Name: .data +# CHECK-HEADERS: PhysicalAddress: 0xE0 +# CHECK-HEADERS-NEXT: VirtualAddress: 0xE0 +# CHECK-HEADERS-NEXT: Size: 0x28 +# CHECK-HEADERS-NEXT: RawDataOffset: 0x16C +# CHECK-HEADERS-NEXT: RelocationPointer: 0x194 +# CHECK-HEADERS-NEXT: LineNumberPointer: 0x0 +# CHECK-HEADERS-NEXT: NumberOfRelocations: 1 +# CHECK-HEADERS-NEXT: NumberOfLineNumbers: 0 +# CHECK-HEADERS-NEXT: Type: STYP_DATA (0x40) +# CHECK-HEADERS-NEXT: } +# CHECK-HEADERS-NEXT: Section { +# CHECK-HEADERS-NEXT: Index: 3 +# CHECK-HEADERS-NEXT: Name: .bss +# CHECK-HEADERS: PhysicalAddress: 0x108 +# CHECK-HEADERS-NEXT: VirtualAddress: 0x108 +# CHECK-HEADERS-NEXT: Size: 0x0 +# CHECK-HEADERS-NEXT: RawDataOffset: 0x0 +# CHECK-HEADERS-NEXT: RelocationPointer: 0x0 +# CHECK-HEADERS-NEXT: LineNumberPointer: 0x0 +# CHECK-HEADERS-NEXT: NumberOfRelocations: 0 +# CHECK-HEADERS-NEXT: NumberOfLineNumbers: 0 +# CHECK-HEADERS-NEXT: Type: STYP_BSS (0x80) +# CHECK-HEADERS-NEXT: } +# CHECK-HEADERS-NEXT: ] + +# CHECK-SYMBOLS: Symbols [ +# CHECK-SYMBOLS-NEXT: Symbol { +# CHECK-SYMBOLS-NEXT: Index: 0 +# CHECK-SYMBOLS-NEXT: Name: .file +# CHECK-SYMBOLS: Value (SymbolTableIndex): 0x0 +# CHECK-SYMBOLS-NEXT: Section: N_DEBUG +# CHECK-SYMBOLS-NEXT: Source Language ID: TB_C (0x0) +# CHECK-SYMBOLS: StorageClass: C_FILE (0x67) +# CHECK-SYMBOLS-NEXT: NumberOfAuxEntries: 1 +# CHECK-SYMBOLS-NEXT: File Auxiliary Entry { +# CHECK-SYMBOLS-NEXT: Index: 1 +# CHECK-SYMBOLS-NEXT: Name: +# CHECK-SYMBOLS-NEXT: Type: XFT_FN (0x0) +# CHECK-SYMBOLS-NEXT: } +# CHECK-SYMBOLS-NEXT: } +# CHECK-SYMBOLS-NEXT: Symbol { +# CHECK-SYMBOLS-NEXT: Index: 2 +# CHECK-SYMBOLS-NEXT: Name: .text +# CHECK-SYMBOLS: Value (RelocatableAddress): 0x0 +# CHECK-SYMBOLS-NEXT: Section: .text +# CHECK-SYMBOLS: Type: 0x0 +# CHECK-SYMBOLS-NEXT: StorageClass: C_HIDEXT (0x6B) +# CHECK-SYMBOLS-NEXT: NumberOfAuxEntries: 1 +# CHECK-SYMBOLS-NEXT: CSECT Auxiliary Entry { +# CHECK-SYMBOLS-NEXT: Index: 3 +# CHECK-SYMBOLS-NEXT: SectionLen: 0 +# CHECK-SYMBOLS-NEXT: ParameterHashIndex: 0x0 +# CHECK-SYMBOLS-NEXT: TypeChkSectNum: 0x0 +# CHECK-SYMBOLS-NEXT: SymbolAlignmentLog2: 0 +# CHECK-SYMBOLS-NEXT: SymbolType: XTY_ER (0x0) +# CHECK-SYMBOLS-NEXT: StorageMappingClass: XMC_PR (0x0) +# CHECK-SYMBOLS-NEXT: StabInfoIndex: 0x0 +# CHECK-SYMBOLS-NEXT: StabSectNum: 0x0 +# CHECK-SYMBOLS-NEXT: } +# CHECK-SYMBOLS-NEXT: } +# CHECK-SYMBOLS-NEXT: Symbol { +# CHECK-SYMBOLS-NEXT: Index: 4 +# CHECK-SYMBOLS-NEXT: Name: i +# CHECK-SYMBOLS: Value (RelocatableAddress): 0x0 +# CHECK-SYMBOLS-NEXT: Section: .data +# CHECK-SYMBOLS: Type: 0x0 +# CHECK-SYMBOLS-NEXT: StorageClass: C_EXT (0x2) +# CHECK-SYMBOLS-NEXT: NumberOfAuxEntries: 1 +# CHECK-SYMBOLS-NEXT: CSECT Auxiliary Entry { +# CHECK-SYMBOLS-NEXT: Index: 5 +# CHECK-SYMBOLS-NEXT: SectionLen: 0 +# CHECK-SYMBOLS-NEXT: ParameterHashIndex: 0x0 +# CHECK-SYMBOLS-NEXT: TypeChkSectNum: 0x0 +# CHECK-SYMBOLS-NEXT: SymbolAlignmentLog2: 0 +# CHECK-SYMBOLS-NEXT: SymbolType: XTY_ER (0x0) +# CHECK-SYMBOLS-NEXT: StorageMappingClass: XMC_PR (0x0) +# CHECK-SYMBOLS-NEXT: StabInfoIndex: 0x0 +# CHECK-SYMBOLS-NEXT: StabSectNum: 0x0 +# CHECK-SYMBOLS-NEXT: } +# CHECK-SYMBOLS-NEXT: } +# CHECK-SYMBOLS-NEXT: ] diff --git a/llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn b/llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn --- a/llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn +++ b/llvm/utils/gn/secondary/llvm/lib/ObjectYAML/BUILD.gn @@ -26,6 +26,7 @@ "ObjectYAML.cpp", "WasmEmitter.cpp", "WasmYAML.cpp", + "XCOFFEmitter.cpp" "XCOFFYAML.cpp", "YAML.cpp", "yaml2obj.cpp",