1 //===--- XCOFFObjectFile.cpp - XCOFF object file implementation -----------===// 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 defines the XCOFFObjectFile class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Object/XCOFFObjectFile.h" 14 #include "llvm/ADT/ArrayRef.h" 15 #include "llvm/Support/BinaryStreamReader.h" 16 #include "llvm/Support/Endian.h" 17 #include "llvm/Support/ErrorHandling.h" 18 #include "llvm/Support/MathExtras.h" 19 #include <cstddef> 20 #include <cstring> 21 22 namespace llvm { 23 namespace object { 24 25 enum { XCOFF32FileHeaderSize = 20 }; 26 static_assert(sizeof(XCOFFFileHeader) == XCOFF32FileHeaderSize, 27 "Wrong size for XCOFF file header."); 28 29 // Sets Obj unless any bytes in [addr, addr + size) fall outsize of m. 30 // Returns unexpected_eof on error. 31 template <typename T> 32 static std::error_code getObject(const T *&Obj, MemoryBufferRef M, 33 const void *Ptr, 34 const uint64_t Size = sizeof(T)) { 35 uintptr_t Addr = uintptr_t(Ptr); 36 if (std::error_code EC = Binary::checkOffset(M, Addr, Size)) 37 return EC; 38 Obj = reinterpret_cast<const T *>(Addr); 39 return std::error_code(); 40 } 41 42 template <typename T> static const T *viewAs(uintptr_t in) { 43 return reinterpret_cast<const T *>(in); 44 } 45 46 const XCOFFSectionHeader *XCOFFObjectFile::toSection(DataRefImpl Ref) const { 47 auto Sec = viewAs<XCOFFSectionHeader>(Ref.p); 48 #ifndef NDEBUG 49 if (Sec < SectionHdrTablePtr || 50 Sec >= (SectionHdrTablePtr + getNumberOfSections())) 51 report_fatal_error("Section header outside of section header table."); 52 53 uintptr_t Offset = uintptr_t(Sec) - uintptr_t(SectionHdrTablePtr); 54 if (Offset % getSectionHeaderSize() != 0) 55 report_fatal_error( 56 "Section header pointer does not point to a valid section header."); 57 #endif 58 return Sec; 59 } 60 61 // The next 2 functions are not exactly necessary yet, but they are useful to 62 // abstract over the size difference between XCOFF32 and XCOFF64 structure 63 // definitions. 64 size_t XCOFFObjectFile::getFileHeaderSize() const { 65 return sizeof(XCOFFFileHeader); 66 } 67 68 size_t XCOFFObjectFile::getSectionHeaderSize() const { 69 return sizeof(XCOFFSectionHeader); 70 } 71 72 uint16_t XCOFFObjectFile::getNumberOfSections() const { 73 return FileHdrPtr->NumberOfSections; 74 } 75 76 void XCOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 77 llvm_unreachable("Not yet implemented!"); 78 return; 79 } 80 81 Expected<StringRef> XCOFFObjectFile::getSymbolName(DataRefImpl Symb) const { 82 StringRef Result; 83 llvm_unreachable("Not yet implemented!"); 84 return Result; 85 } 86 87 Expected<uint64_t> XCOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const { 88 uint64_t Result = 0; 89 llvm_unreachable("Not yet implemented!"); 90 return Result; 91 } 92 93 uint64_t XCOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const { 94 uint64_t Result = 0; 95 llvm_unreachable("Not yet implemented!"); 96 return Result; 97 } 98 99 uint64_t XCOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const { 100 uint64_t Result = 0; 101 llvm_unreachable("Not yet implemented!"); 102 return Result; 103 } 104 105 Expected<SymbolRef::Type> 106 XCOFFObjectFile::getSymbolType(DataRefImpl Symb) const { 107 llvm_unreachable("Not yet implemented!"); 108 return SymbolRef::ST_Other; 109 } 110 111 Expected<section_iterator> 112 XCOFFObjectFile::getSymbolSection(DataRefImpl Symb) const { 113 llvm_unreachable("Not yet implemented!"); 114 return section_iterator(SectionRef()); 115 } 116 117 void XCOFFObjectFile::moveSectionNext(DataRefImpl &Sec) const { 118 const char *Ptr = reinterpret_cast<const char *>(Sec.p); 119 Sec.p = reinterpret_cast<uintptr_t>(Ptr + getSectionHeaderSize()); 120 } 121 122 std::error_code XCOFFObjectFile::getSectionName(DataRefImpl Sec, 123 StringRef &Res) const { 124 const char *Name = toSection(Sec)->Name; 125 auto NulCharPtr = 126 static_cast<const char *>(memchr(Name, '\0', XCOFF::SectionNameSize)); 127 Res = NulCharPtr ? StringRef(Name, NulCharPtr - Name) 128 : StringRef(Name, XCOFF::SectionNameSize); 129 return std::error_code(); 130 } 131 132 uint64_t XCOFFObjectFile::getSectionAddress(DataRefImpl Sec) const { 133 return toSection(Sec)->VirtualAddress; 134 } 135 136 uint64_t XCOFFObjectFile::getSectionIndex(DataRefImpl Sec) const { 137 // Section numbers in XCOFF are numbered beginning at 1. A section number of 138 // zero is used to indicate that a symbol is being imported or is undefined. 139 return toSection(Sec) - SectionHdrTablePtr + 1; 140 } 141 142 uint64_t XCOFFObjectFile::getSectionSize(DataRefImpl Sec) const { 143 return toSection(Sec)->SectionSize; 144 } 145 146 std::error_code XCOFFObjectFile::getSectionContents(DataRefImpl Sec, 147 StringRef &Res) const { 148 llvm_unreachable("Not yet implemented!"); 149 return std::error_code(); 150 } 151 152 uint64_t XCOFFObjectFile::getSectionAlignment(DataRefImpl Sec) const { 153 uint64_t Result = 0; 154 llvm_unreachable("Not yet implemented!"); 155 return Result; 156 } 157 158 bool XCOFFObjectFile::isSectionCompressed(DataRefImpl Sec) const { 159 bool Result = false; 160 llvm_unreachable("Not yet implemented!"); 161 return Result; 162 } 163 164 bool XCOFFObjectFile::isSectionText(DataRefImpl Sec) const { 165 return toSection(Sec)->Flags & XCOFF::STYP_TEXT; 166 } 167 168 bool XCOFFObjectFile::isSectionData(DataRefImpl Sec) const { 169 unsigned Flags = toSection(Sec)->Flags; 170 return Flags & (XCOFF::STYP_DATA | XCOFF::STYP_TDATA); 171 } 172 173 bool XCOFFObjectFile::isSectionBSS(DataRefImpl Sec) const { 174 unsigned Flags = toSection(Sec)->Flags; 175 return Flags & (XCOFF::STYP_BSS | XCOFF::STYP_TBSS); 176 } 177 178 bool XCOFFObjectFile::isSectionVirtual(DataRefImpl Sec) const { 179 bool Result = false; 180 llvm_unreachable("Not yet implemented!"); 181 return Result; 182 } 183 184 relocation_iterator XCOFFObjectFile::section_rel_begin(DataRefImpl Sec) const { 185 llvm_unreachable("Not yet implemented!"); 186 return relocation_iterator(RelocationRef()); 187 } 188 189 relocation_iterator XCOFFObjectFile::section_rel_end(DataRefImpl Sec) const { 190 llvm_unreachable("Not yet implemented!"); 191 return relocation_iterator(RelocationRef()); 192 } 193 194 void XCOFFObjectFile::moveRelocationNext(DataRefImpl &Rel) const { 195 llvm_unreachable("Not yet implemented!"); 196 return; 197 } 198 199 uint64_t XCOFFObjectFile::getRelocationOffset(DataRefImpl Rel) const { 200 llvm_unreachable("Not yet implemented!"); 201 uint64_t Result = 0; 202 return Result; 203 } 204 205 symbol_iterator XCOFFObjectFile::getRelocationSymbol(DataRefImpl Rel) const { 206 llvm_unreachable("Not yet implemented!"); 207 return symbol_iterator(SymbolRef()); 208 } 209 210 uint64_t XCOFFObjectFile::getRelocationType(DataRefImpl Rel) const { 211 llvm_unreachable("Not yet implemented!"); 212 uint64_t Result = 0; 213 return Result; 214 } 215 216 void XCOFFObjectFile::getRelocationTypeName( 217 DataRefImpl Rel, SmallVectorImpl<char> &Result) const { 218 llvm_unreachable("Not yet implemented!"); 219 return; 220 } 221 222 uint32_t XCOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const { 223 uint32_t Result = 0; 224 llvm_unreachable("Not yet implemented!"); 225 return Result; 226 } 227 228 basic_symbol_iterator XCOFFObjectFile::symbol_begin() const { 229 llvm_unreachable("Not yet implemented!"); 230 return basic_symbol_iterator(SymbolRef()); 231 } 232 233 basic_symbol_iterator XCOFFObjectFile::symbol_end() const { 234 llvm_unreachable("Not yet implemented!"); 235 return basic_symbol_iterator(SymbolRef()); 236 } 237 238 section_iterator XCOFFObjectFile::section_begin() const { 239 DataRefImpl DRI; 240 DRI.p = reinterpret_cast<uintptr_t>(SectionHdrTablePtr); 241 return section_iterator(SectionRef(DRI, this)); 242 } 243 244 section_iterator XCOFFObjectFile::section_end() const { 245 DataRefImpl DRI; 246 DRI.p = 247 reinterpret_cast<uintptr_t>(SectionHdrTablePtr + getNumberOfSections()); 248 return section_iterator(SectionRef(DRI, this)); 249 } 250 251 uint8_t XCOFFObjectFile::getBytesInAddress() const { 252 uint8_t Result = 0; 253 llvm_unreachable("Not yet implemented!"); 254 return Result; 255 } 256 257 StringRef XCOFFObjectFile::getFileFormatName() const { 258 assert(getFileHeaderSize() == XCOFF32FileHeaderSize); 259 return "aixcoff-rs6000"; 260 } 261 262 Triple::ArchType XCOFFObjectFile::getArch() const { 263 assert(getFileHeaderSize() == XCOFF32FileHeaderSize); 264 return Triple::ppc; 265 } 266 267 SubtargetFeatures XCOFFObjectFile::getFeatures() const { 268 llvm_unreachable("Not yet implemented!"); 269 return SubtargetFeatures(); 270 } 271 272 bool XCOFFObjectFile::isRelocatableObject() const { 273 bool Result = false; 274 llvm_unreachable("Not yet implemented!"); 275 return Result; 276 } 277 278 Expected<uint64_t> XCOFFObjectFile::getStartAddress() const { 279 // TODO FIXME Should get from auxiliary_header->o_entry when support for the 280 // auxiliary_header is added. 281 return 0; 282 } 283 284 XCOFFObjectFile::XCOFFObjectFile(MemoryBufferRef Object, std::error_code &EC) 285 : ObjectFile(Binary::ID_XCOFF32, Object) { 286 287 // Current location within the file. 288 uint64_t CurPtr = 0; 289 290 if ((EC = getObject(FileHdrPtr, Data, base() + CurPtr))) 291 return; 292 293 CurPtr += getFileHeaderSize(); 294 // TODO FIXME we don't have support for an optional header yet, so just skip 295 // past it. 296 CurPtr += FileHdrPtr->AuxHeaderSize; 297 298 if (getNumberOfSections() != 0) { 299 if ((EC = getObject(SectionHdrTablePtr, Data, base() + CurPtr, 300 getNumberOfSections() * getSectionHeaderSize()))) 301 return; 302 } 303 } 304 305 Expected<std::unique_ptr<ObjectFile>> 306 ObjectFile::createXCOFFObjectFile(MemoryBufferRef Object) { 307 StringRef Data = Object.getBuffer(); 308 file_magic Type = identify_magic(Data); 309 std::error_code EC; 310 std::unique_ptr<ObjectFile> Ret; 311 312 if (Type == file_magic::xcoff_object_32) { 313 Ret.reset(new XCOFFObjectFile(Object, EC)); 314 } else { 315 llvm_unreachable("Encountered an unexpected binary file type!"); 316 } 317 318 if (EC) 319 return errorCodeToError(EC); 320 return std::move(Ret); 321 } 322 323 } // namespace object 324 } // namespace llvm 325