include/llvm/Object/XCOFFObjectFile.h

   1 //===- XCOFFObjectFile.h - XCOFF object file implementation -----*- 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 declares the XCOFFObjectFile class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #ifndef LLVM_OBJECT_XCOFFOBJECTFILE_H
  14 #define LLVM_OBJECT_XCOFFOBJECTFILE_H
  15
  16 #include "llvm/BinaryFormat/XCOFF.h"
  17 #include "llvm/Object/ObjectFile.h"
  18
  19 namespace llvm {
  20 namespace object {
  21
  22 struct XCOFFFileHeader32 {
  23   support::ubig16_t Magic;
  24   support::ubig16_t NumberOfSections;
  25
  26   // Unix time value, value of 0 indicates no timestamp.
  27   // Negative values are reserved.
  28   support::big32_t TimeStamp;
  29
  30   support::ubig32_t SymbolTableOffset; // File offset to symbol table.
  31   support::big32_t NumberOfSymTableEntries;
  32   support::ubig16_t AuxHeaderSize;
  33   support::ubig16_t Flags;
  34 };
  35
  36 struct XCOFFFileHeader64 {
  37   support::ubig16_t Magic;
  38   support::ubig16_t NumberOfSections;
  39
  40   // Unix time value, value of 0 indicates no timestamp.
  41   // Negative values are reserved.
  42   support::big32_t TimeStamp;
  43
  44   support::ubig64_t SymbolTableOffset; // File offset to symbol table.
  45   support::ubig16_t AuxHeaderSize;
  46   support::ubig16_t Flags;
  47   support::ubig32_t NumberOfSymTableEntries;
  48 };
  49
  50 struct XCOFFSectionHeader32 {
  51   char Name[XCOFF::NameSize];
  52   support::ubig32_t PhysicalAddress;
  53   support::ubig32_t VirtualAddress;
  54   support::ubig32_t SectionSize;
  55   support::ubig32_t FileOffsetToRawData;
  56   support::ubig32_t FileOffsetToRelocationInfo;
  57   support::ubig32_t FileOffsetToLineNumberInfo;
  58   support::ubig16_t NumberOfRelocations;
  59   support::ubig16_t NumberOfLineNumbers;
  60   support::big32_t Flags;
  61
  62   StringRef getName() const;
  63 };
  64
  65 struct XCOFFSectionHeader64 {
  66   char Name[XCOFF::NameSize];
  67   support::ubig64_t PhysicalAddress;
  68   support::ubig64_t VirtualAddress;
  69   support::ubig64_t SectionSize;
  70   support::big64_t FileOffsetToRawData;
  71   support::big64_t FileOffsetToRelocationInfo;
  72   support::big64_t FileOffsetToLineNumberInfo;
  73   support::ubig32_t NumberOfRelocations;
  74   support::ubig32_t NumberOfLineNumbers;
  75   support::big32_t Flags;
  76   char Padding[4];
  77
  78   StringRef getName() const;
  79 };
  80
  81 struct XCOFFSymbolEntry {
  82   enum { NAME_IN_STR_TBL_MAGIC = 0x0 };
  83   typedef struct {
  84     support::big32_t Magic; // Zero indicates name in string table.
  85     support::ubig32_t Offset;
  86   } NameInStrTblType;
  87
  88   typedef struct {
  89     uint8_t LanguageId;
  90     uint8_t CpuTypeId;
  91   } CFileLanguageIdAndTypeIdType;
  92
  93   union {
  94     char SymbolName[XCOFF::NameSize];
  95     NameInStrTblType NameInStrTbl;
  96   };
  97
  98   support::ubig32_t Value; // Symbol value; storage class-dependent.
  99   support::big16_t SectionNumber;
 100
 101   union {
 102     support::ubig16_t SymbolType;
 103     CFileLanguageIdAndTypeIdType CFileLanguageIdAndTypeId;
 104   };
 105
 106   XCOFF::StorageClass StorageClass;
 107   uint8_t NumberOfAuxEntries;
 108 };
 109
 110 struct XCOFFStringTable {
 111   uint32_t Size;
 112   const char *Data;
 113 };
 114
 115 struct XCOFFCsectAuxEnt32 {
 116   support::ubig32_t SectionLen;
 117   support::ubig32_t ParameterHashIndex;
 118   support::ubig16_t TypeChkSectNum;
 119   uint8_t SymbolAlignmentAndType;
 120   XCOFF::StorageMappingClass StorageMappingClass;
 121   support::ubig32_t StabInfoIndex;
 122   support::ubig16_t StabSectNum;
 123 };
 124
 125 struct XCOFFFileAuxEnt {
 126   typedef struct {
 127     support::big32_t Magic; // Zero indicates name in string table.
 128     support::ubig32_t Offset;
 129     char NamePad[XCOFF::FileNamePadSize];
 130   } NameInStrTblType;
 131   union {
 132     char Name[XCOFF::NameSize + XCOFF::FileNamePadSize];
 133     NameInStrTblType NameInStrTbl;
 134   };
 135   XCOFF::CFileStringType Type;
 136   uint8_t ReservedZeros[2];
 137   uint8_t AuxType; // 64-bit XCOFF file only.
 138 };
 139
 140 struct XCOFFSectAuxEntForStat {
 141   support::ubig32_t SectionLength;
 142   support::ubig16_t NumberOfRelocEnt;
 143   support::ubig16_t NumberOfLineNum;
 144   uint8_t Pad[10];
 145 };
 146
 147 class XCOFFObjectFile : public ObjectFile {
 148 private:
 149   const void *FileHeader = nullptr;
 150   const void *SectionHeaderTable = nullptr;
 151
 152   const XCOFFSymbolEntry *SymbolTblPtr = nullptr;
 153   XCOFFStringTable StringTable = {0, nullptr};
 154
 155   const XCOFFFileHeader32 *fileHeader32() const;
 156   const XCOFFFileHeader64 *fileHeader64() const;
 157
 158   const XCOFFSectionHeader32 *sectionHeaderTable32() const;
 159   const XCOFFSectionHeader64 *sectionHeaderTable64() const;
 160
 161   size_t getFileHeaderSize() const;
 162   size_t getSectionHeaderSize() const;
 163
 164   const XCOFFSectionHeader32 *toSection32(DataRefImpl Ref) const;
 165   const XCOFFSectionHeader64 *toSection64(DataRefImpl Ref) const;
 166   uintptr_t getSectionHeaderTableAddress() const;
 167   uintptr_t getEndOfSymbolTableAddress() const;
 168
 169   // This returns a pointer to the start of the storage for the name field of
 170   // the 32-bit or 64-bit SectionHeader struct. This string is *not* necessarily
 171   // null-terminated.
 172   const char *getSectionNameInternal(DataRefImpl Sec) const;
 173
 174   // This function returns string table entry.
 175   Expected<StringRef> getStringTableEntry(uint32_t Offset) const;
 176
 177   static bool isReservedSectionNumber(int16_t SectionNumber);
 178
 179   // Constructor and "create" factory function. The constructor is only a thin
 180   // wrapper around the base constructor. The "create" function fills out the
 181   // XCOFF-specific information and performs the error checking along the way.
 182   XCOFFObjectFile(unsigned Type, MemoryBufferRef Object);
 183   static Expected<std::unique_ptr<XCOFFObjectFile>> create(unsigned Type,
 184                                                            MemoryBufferRef MBR);
 185
 186   // Helper for parsing the StringTable. Returns an 'Error' if parsing failed
 187   // and an XCOFFStringTable if parsing succeeded.
 188   static Expected<XCOFFStringTable> parseStringTable(const XCOFFObjectFile *Obj,
 189                                                      uint64_t Offset);
 190
 191   // Make a friend so it can call the private 'create' function.
 192   friend Expected<std::unique_ptr<ObjectFile>>
 193   ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object, unsigned FileType);
 194
 195   void checkSectionAddress(uintptr_t Addr, uintptr_t TableAddr) const;
 196
 197 public:
 198   // Interface inherited from base classes.
 199   void moveSymbolNext(DataRefImpl &Symb) const override;
 200   uint32_t getSymbolFlags(DataRefImpl Symb) const override;
 201   basic_symbol_iterator symbol_begin() const override;
 202   basic_symbol_iterator symbol_end() const override;
 203
 204   Expected<StringRef> getSymbolName(DataRefImpl Symb) const override;
 205   Expected<uint64_t> getSymbolAddress(DataRefImpl Symb) const override;
 206   uint64_t getSymbolValueImpl(DataRefImpl Symb) const override;
 207   uint64_t getCommonSymbolSizeImpl(DataRefImpl Symb) const override;
 208   Expected<SymbolRef::Type> getSymbolType(DataRefImpl Symb) const override;
 209   Expected<section_iterator> getSymbolSection(DataRefImpl Symb) const override;
 210
 211   void moveSectionNext(DataRefImpl &Sec) const override;
 212   Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
 213   uint64_t getSectionAddress(DataRefImpl Sec) const override;
 214   uint64_t getSectionIndex(DataRefImpl Sec) const override;
 215   uint64_t getSectionSize(DataRefImpl Sec) const override;
 216   Expected<ArrayRef<uint8_t>>
 217   getSectionContents(DataRefImpl Sec) const override;
 218   uint64_t getSectionAlignment(DataRefImpl Sec) const override;
 219   bool isSectionCompressed(DataRefImpl Sec) const override;
 220   bool isSectionText(DataRefImpl Sec) const override;
 221   bool isSectionData(DataRefImpl Sec) const override;
 222   bool isSectionBSS(DataRefImpl Sec) const override;
 223
 224   bool isSectionVirtual(DataRefImpl Sec) const override;
 225   relocation_iterator section_rel_begin(DataRefImpl Sec) const override;
 226   relocation_iterator section_rel_end(DataRefImpl Sec) const override;
 227
 228   void moveRelocationNext(DataRefImpl &Rel) const override;
 229   uint64_t getRelocationOffset(DataRefImpl Rel) const override;
 230   symbol_iterator getRelocationSymbol(DataRefImpl Rel) const override;
 231   uint64_t getRelocationType(DataRefImpl Rel) const override;
 232   void getRelocationTypeName(DataRefImpl Rel,
 233                              SmallVectorImpl<char> &Result) const override;
 234
 235   section_iterator section_begin() const override;
 236   section_iterator section_end() const override;
 237   uint8_t getBytesInAddress() const override;
 238   StringRef getFileFormatName() const override;
 239   Triple::ArchType getArch() const override;
 240   SubtargetFeatures getFeatures() const override;
 241   Expected<uint64_t> getStartAddress() const override;
 242   bool isRelocatableObject() const override;
 243
 244   // Below here is the non-inherited interface.
 245   bool is64Bit() const;
 246
 247   const XCOFFSymbolEntry *getPointerToSymbolTable() const {
 248     assert(!is64Bit() && "Symbol table handling not supported yet.");
 249     return SymbolTblPtr;
 250   }
 251
 252   Expected<StringRef>
 253   getSymbolSectionName(const XCOFFSymbolEntry *SymEntPtr) const;
 254
 255   const XCOFFSymbolEntry *toSymbolEntry(DataRefImpl Ref) const;
 256
 257   // File header related interfaces.
 258   uint16_t getMagic() const;
 259   uint16_t getNumberOfSections() const;
 260   int32_t getTimeStamp() const;
 261
 262   // Symbol table offset and entry count are handled differently between
 263   // XCOFF32 and XCOFF64.
 264   uint32_t getSymbolTableOffset32() const;
 265   uint64_t getSymbolTableOffset64() const;
 266
 267   // Note that this value is signed and might return a negative value. Negative
 268   // values are reserved for future use.
 269   int32_t getRawNumberOfSymbolTableEntries32() const;
 270
 271   // The sanitized value appropriate to use as an index into the symbol table.
 272   uint32_t getLogicalNumberOfSymbolTableEntries32() const;
 273
 274   uint32_t getNumberOfSymbolTableEntries64() const;
 275   uint32_t getSymbolIndex(uintptr_t SymEntPtr) const;
 276
 277   Expected<StringRef> getCFileName(const XCOFFFileAuxEnt *CFileEntPtr) const;
 278   uint16_t getOptionalHeaderSize() const;
 279   uint16_t getFlags() const;
 280
 281   // Section header table related interfaces.
 282   ArrayRef<XCOFFSectionHeader32> sections32() const;
 283   ArrayRef<XCOFFSectionHeader64> sections64() const;
 284
 285   int32_t getSectionFlags(DataRefImpl Sec) const;
 286   Expected<DataRefImpl> getSectionByNum(int16_t Num) const;
 287
 288   void checkSymbolEntryPointer(uintptr_t SymbolEntPtr) const;
 289 }; // XCOFFObjectFile
 290
 291 class XCOFFSymbolRef {
 292   const DataRefImpl SymEntDataRef;
 293   const XCOFFObjectFile *const OwningObjectPtr;
 294
 295 public:
 296   XCOFFSymbolRef(DataRefImpl SymEntDataRef,
 297                  const XCOFFObjectFile *OwningObjectPtr)
 298       : SymEntDataRef(SymEntDataRef), OwningObjectPtr(OwningObjectPtr){};
 299
 300   XCOFF::StorageClass getStorageClass() const;
 301   uint8_t getNumberOfAuxEntries() const;
 302   const XCOFFCsectAuxEnt32 *getXCOFFCsectAuxEnt32() const;
 303   uint16_t getType() const;
 304   int16_t getSectionNumber() const;
 305
 306   bool hasCsectAuxEnt() const;
 307   bool isFunction() const;
 308 };
 309
 310 } // namespace object
 311 } // namespace llvm
 312
 313 #endif // LLVM_OBJECT_XCOFFOBJECTFILE_H