llvm/lib/Object/GOFFObjectFile.cpp

   1 //===- GOFFObjectFile.cpp - GOFF 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 // Implementation of the GOFFObjectFile class.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Object/GOFFObjectFile.h"
  14 #include "llvm/BinaryFormat/GOFF.h"
  15 #include "llvm/Object/GOFF.h"
  16 #include "llvm/Support/Debug.h"
  17 #include "llvm/Support/Errc.h"
  18 #include "llvm/Support/raw_ostream.h"
  19
  20 #ifndef DEBUG_TYPE
  21 #define DEBUG_TYPE "goff"
  22 #endif
  23
  24 using namespace llvm::object;
  25 using namespace llvm;
  26
  27 Expected<std::unique_ptr<ObjectFile>>
  28 ObjectFile::createGOFFObjectFile(MemoryBufferRef Object) {
  29   Error Err = Error::success();
  30   std::unique_ptr<GOFFObjectFile> Ret(new GOFFObjectFile(Object, Err));
  31   if (Err)
  32     return std::move(Err);
  33   return std::move(Ret);
  34 }
  35
  36 GOFFObjectFile::GOFFObjectFile(MemoryBufferRef Object, Error &Err)
  37     : ObjectFile(Binary::ID_GOFF, Object) {
  38   ErrorAsOutParameter ErrAsOutParam(&Err);
  39   // Object file isn't the right size, bail out early.
  40   if ((Object.getBufferSize() % GOFF::RecordLength) != 0) {
  41     Err = createStringError(
  42         object_error::unexpected_eof,
  43         "object file is not the right size. Must be a multiple "
  44         "of 80 bytes, but is " +
  45             std::to_string(Object.getBufferSize()) + " bytes");
  46     return;
  47   }
  48   // Object file doesn't start/end with HDR/END records.
  49   // Bail out early.
  50   if (Object.getBufferSize() != 0) {
  51     if ((base()[1] & 0xF0) >> 4 != GOFF::RT_HDR) {
  52       Err = createStringError(object_error::parse_failed,
  53                               "object file must start with HDR record");
  54       return;
  55     }
  56     if ((base()[Object.getBufferSize() - GOFF::RecordLength + 1] & 0xF0) >> 4 !=
  57         GOFF::RT_END) {
  58       Err = createStringError(object_error::parse_failed,
  59                               "object file must end with END record");
  60       return;
  61     }
  62   }
  63
  64   SectionEntryImpl DummySection;
  65   SectionList.emplace_back(DummySection); // Dummy entry at index 0.
  66
  67   uint8_t PrevRecordType = 0;
  68   uint8_t PrevContinuationBits = 0;
  69   const uint8_t *End = reinterpret_cast<const uint8_t *>(Data.getBufferEnd());
  70   for (const uint8_t *I = base(); I < End; I += GOFF::RecordLength) {
  71     uint8_t RecordType = (I[1] & 0xF0) >> 4;
  72     bool IsContinuation = I[1] & 0x02;
  73     bool PrevWasContinued = PrevContinuationBits & 0x01;
  74     size_t RecordNum = (I - base()) / GOFF::RecordLength;
  75
  76     // If the previous record was continued, the current record should be a
  77     // continuation.
  78     if (PrevWasContinued && !IsContinuation) {
  79       if (PrevRecordType == RecordType) {
  80         Err = createStringError(object_error::parse_failed,
  81                                 "record " + std::to_string(RecordNum) +
  82                                     " is not a continuation record but the "
  83                                     "preceding record is continued");
  84         return;
  85       }
  86     }
  87     // Don't parse continuations records, only parse initial record.
  88     if (IsContinuation) {
  89       if (RecordType != PrevRecordType) {
  90         Err = createStringError(object_error::parse_failed,
  91                                 "record " + std::to_string(RecordNum) +
  92                                     " is a continuation record that does not "
  93                                     "match the type of the previous record");
  94         return;
  95       }
  96       if (!PrevWasContinued) {
  97         Err = createStringError(object_error::parse_failed,
  98                                 "record " + std::to_string(RecordNum) +
  99                                     " is a continuation record that is not "
 100                                     "preceded by a continued record");
 101         return;
 102       }
 103       PrevRecordType = RecordType;
 104       PrevContinuationBits = I[1] & 0x03;
 105       continue;
 106     }
 107
 108 #ifndef NDEBUG
 109     for (size_t J = 0; J < GOFF::RecordLength; ++J) {
 110       const uint8_t *P = I + J;
 111       if (J % 8 == 0)
 112         dbgs() << "  ";
 113
 114       dbgs() << format("%02hhX", *P);
 115     }
 116 #endif
 117     switch (RecordType) {
 118     case GOFF::RT_ESD: {
 119       // Save ESD record.
 120       uint32_t EsdId;
 121       ESDRecord::getEsdId(I, EsdId);
 122       EsdPtrs.grow(EsdId);
 123       EsdPtrs[EsdId] = I;
 124
 125       // Determine and save the "sections" in GOFF.
 126       // A section is saved as a tuple of the form
 127       // case (1): (ED,child PR)
 128       //    - where the PR must have non-zero length.
 129       // case (2a) (ED,0)
 130       //   - where the ED is of non-zero length.
 131       // case (2b) (ED,0)
 132       //   - where the ED is zero length but
 133       //     contains a label (LD).
 134       GOFF::ESDSymbolType SymbolType;
 135       ESDRecord::getSymbolType(I, SymbolType);
 136       SectionEntryImpl Section;
 137       uint32_t Length;
 138       ESDRecord::getLength(I, Length);
 139       if (SymbolType == GOFF::ESD_ST_ElementDefinition) {
 140         // case (2a)
 141         if (Length != 0) {
 142           Section.d.a = EsdId;
 143           SectionList.emplace_back(Section);
 144         }
 145       } else if (SymbolType == GOFF::ESD_ST_PartReference) {
 146         // case (1)
 147         if (Length != 0) {
 148           uint32_t SymEdId;
 149           ESDRecord::getParentEsdId(I, SymEdId);
 150           Section.d.a = SymEdId;
 151           Section.d.b = EsdId;
 152           SectionList.emplace_back(Section);
 153         }
 154       } else if (SymbolType == GOFF::ESD_ST_LabelDefinition) {
 155         // case (2b)
 156         uint32_t SymEdId;
 157         ESDRecord::getParentEsdId(I, SymEdId);
 158         const uint8_t *SymEdRecord = EsdPtrs[SymEdId];
 159         uint32_t EdLength;
 160         ESDRecord::getLength(SymEdRecord, EdLength);
 161         if (!EdLength) { // [ EDID, PRID ]
 162           // LD child of a zero length parent ED.
 163           // Add the section ED which was previously ignored.
 164           Section.d.a = SymEdId;
 165           SectionList.emplace_back(Section);
 166         }
 167       }
 168       LLVM_DEBUG(dbgs() << "  --  ESD " << EsdId << "\n");
 169       break;
 170     }
 171     case GOFF::RT_END:
 172       LLVM_DEBUG(dbgs() << "  --  END (GOFF record type) unhandled\n");
 173       break;
 174     case GOFF::RT_HDR:
 175       LLVM_DEBUG(dbgs() << "  --  HDR (GOFF record type) unhandled\n");
 176       break;
 177     default:
 178       llvm_unreachable("Unknown record type");
 179     }
 180     PrevRecordType = RecordType;
 181     PrevContinuationBits = I[1] & 0x03;
 182   }
 183 }
 184
 185 const uint8_t *GOFFObjectFile::getSymbolEsdRecord(DataRefImpl Symb) const {
 186   const uint8_t *EsdRecord = EsdPtrs[Symb.d.a];
 187   return EsdRecord;
 188 }
 189
 190 Expected<StringRef> GOFFObjectFile::getSymbolName(DataRefImpl Symb) const {
 191   if (EsdNamesCache.count(Symb.d.a)) {
 192     auto &StrPtr = EsdNamesCache[Symb.d.a];
 193     return StringRef(StrPtr.second.get(), StrPtr.first);
 194   }
 195
 196   SmallString<256> SymbolName;
 197   if (auto Err = ESDRecord::getData(getSymbolEsdRecord(Symb), SymbolName))
 198     return std::move(Err);
 199
 200   SmallString<256> SymbolNameConverted;
 201   ConverterEBCDIC::convertToUTF8(SymbolName, SymbolNameConverted);
 202
 203   size_t Size = SymbolNameConverted.size();
 204   auto StrPtr = std::make_pair(Size, std::make_unique<char[]>(Size));
 205   char *Buf = StrPtr.second.get();
 206   memcpy(Buf, SymbolNameConverted.data(), Size);
 207   EsdNamesCache[Symb.d.a] = std::move(StrPtr);
 208   return StringRef(Buf, Size);
 209 }
 210
 211 Expected<StringRef> GOFFObjectFile::getSymbolName(SymbolRef Symbol) const {
 212   return getSymbolName(Symbol.getRawDataRefImpl());
 213 }
 214
 215 Expected<uint64_t> GOFFObjectFile::getSymbolAddress(DataRefImpl Symb) const {
 216   uint32_t Offset;
 217   const uint8_t *EsdRecord = getSymbolEsdRecord(Symb);
 218   ESDRecord::getOffset(EsdRecord, Offset);
 219   return static_cast<uint64_t>(Offset);
 220 }
 221
 222 uint64_t GOFFObjectFile::getSymbolValueImpl(DataRefImpl Symb) const {
 223   uint32_t Offset;
 224   const uint8_t *EsdRecord = getSymbolEsdRecord(Symb);
 225   ESDRecord::getOffset(EsdRecord, Offset);
 226   return static_cast<uint64_t>(Offset);
 227 }
 228
 229 uint64_t GOFFObjectFile::getCommonSymbolSizeImpl(DataRefImpl Symb) const {
 230   return 0;
 231 }
 232
 233 bool GOFFObjectFile::isSymbolUnresolved(DataRefImpl Symb) const {
 234   const uint8_t *Record = getSymbolEsdRecord(Symb);
 235   GOFF::ESDSymbolType SymbolType;
 236   ESDRecord::getSymbolType(Record, SymbolType);
 237
 238   if (SymbolType == GOFF::ESD_ST_ExternalReference)
 239     return true;
 240   if (SymbolType == GOFF::ESD_ST_PartReference) {
 241     uint32_t Length;
 242     ESDRecord::getLength(Record, Length);
 243     if (Length == 0)
 244       return true;
 245   }
 246   return false;
 247 }
 248
 249 bool GOFFObjectFile::isSymbolIndirect(DataRefImpl Symb) const {
 250   const uint8_t *Record = getSymbolEsdRecord(Symb);
 251   bool Indirect;
 252   ESDRecord::getIndirectReference(Record, Indirect);
 253   return Indirect;
 254 }
 255
 256 Expected<uint32_t> GOFFObjectFile::getSymbolFlags(DataRefImpl Symb) const {
 257   uint32_t Flags = 0;
 258   if (isSymbolUnresolved(Symb))
 259     Flags |= SymbolRef::SF_Undefined;
 260
 261   const uint8_t *Record = getSymbolEsdRecord(Symb);
 262
 263   GOFF::ESDBindingStrength BindingStrength;
 264   ESDRecord::getBindingStrength(Record, BindingStrength);
 265   if (BindingStrength == GOFF::ESD_BST_Weak)
 266     Flags |= SymbolRef::SF_Weak;
 267
 268   GOFF::ESDBindingScope BindingScope;
 269   ESDRecord::getBindingScope(Record, BindingScope);
 270
 271   if (BindingScope != GOFF::ESD_BSC_Section) {
 272     Expected<StringRef> Name = getSymbolName(Symb);
 273     if (Name && *Name != " ") { // Blank name is local.
 274       Flags |= SymbolRef::SF_Global;
 275       if (BindingScope == GOFF::ESD_BSC_ImportExport)
 276         Flags |= SymbolRef::SF_Exported;
 277       else if (!(Flags & SymbolRef::SF_Undefined))
 278         Flags |= SymbolRef::SF_Hidden;
 279     }
 280   }
 281
 282   return Flags;
 283 }
 284
 285 Expected<SymbolRef::Type>
 286 GOFFObjectFile::getSymbolType(DataRefImpl Symb) const {
 287   const uint8_t *Record = getSymbolEsdRecord(Symb);
 288   GOFF::ESDSymbolType SymbolType;
 289   ESDRecord::getSymbolType(Record, SymbolType);
 290   GOFF::ESDExecutable Executable;
 291   ESDRecord::getExecutable(Record, Executable);
 292
 293   if (SymbolType != GOFF::ESD_ST_SectionDefinition &&
 294       SymbolType != GOFF::ESD_ST_ElementDefinition &&
 295       SymbolType != GOFF::ESD_ST_LabelDefinition &&
 296       SymbolType != GOFF::ESD_ST_PartReference &&
 297       SymbolType != GOFF::ESD_ST_ExternalReference) {
 298     uint32_t EsdId;
 299     ESDRecord::getEsdId(Record, EsdId);
 300     return createStringError(llvm::errc::invalid_argument,
 301                              "ESD record %" PRIu32
 302                              " has invalid symbol type 0x%02" PRIX8,
 303                              EsdId, SymbolType);
 304   }
 305   switch (SymbolType) {
 306   case GOFF::ESD_ST_SectionDefinition:
 307   case GOFF::ESD_ST_ElementDefinition:
 308     return SymbolRef::ST_Other;
 309   case GOFF::ESD_ST_LabelDefinition:
 310   case GOFF::ESD_ST_PartReference:
 311   case GOFF::ESD_ST_ExternalReference:
 312     if (Executable != GOFF::ESD_EXE_CODE && Executable != GOFF::ESD_EXE_DATA &&
 313         Executable != GOFF::ESD_EXE_Unspecified) {
 314       uint32_t EsdId;
 315       ESDRecord::getEsdId(Record, EsdId);
 316       return createStringError(llvm::errc::invalid_argument,
 317                                "ESD record %" PRIu32
 318                                " has unknown Executable type 0x%02X",
 319                                EsdId, Executable);
 320     }
 321     switch (Executable) {
 322     case GOFF::ESD_EXE_CODE:
 323       return SymbolRef::ST_Function;
 324     case GOFF::ESD_EXE_DATA:
 325       return SymbolRef::ST_Data;
 326     case GOFF::ESD_EXE_Unspecified:
 327       return SymbolRef::ST_Unknown;
 328     }
 329     llvm_unreachable("Unhandled ESDExecutable");
 330   }
 331   llvm_unreachable("Unhandled ESDSymbolType");
 332 }
 333
 334 Expected<section_iterator>
 335 GOFFObjectFile::getSymbolSection(DataRefImpl Symb) const {
 336   DataRefImpl Sec;
 337
 338   if (isSymbolUnresolved(Symb))
 339     return section_iterator(SectionRef(Sec, this));
 340
 341   const uint8_t *SymEsdRecord = EsdPtrs[Symb.d.a];
 342   uint32_t SymEdId;
 343   ESDRecord::getParentEsdId(SymEsdRecord, SymEdId);
 344   const uint8_t *SymEdRecord = EsdPtrs[SymEdId];
 345
 346   for (size_t I = 0, E = SectionList.size(); I < E; ++I) {
 347     bool Found;
 348     const uint8_t *SectionPrRecord = getSectionPrEsdRecord(I);
 349     if (SectionPrRecord) {
 350       Found = SymEsdRecord == SectionPrRecord;
 351     } else {
 352       const uint8_t *SectionEdRecord = getSectionEdEsdRecord(I);
 353       Found = SymEdRecord == SectionEdRecord;
 354     }
 355
 356     if (Found) {
 357       Sec.d.a = I;
 358       return section_iterator(SectionRef(Sec, this));
 359     }
 360   }
 361   return createStringError(llvm::errc::invalid_argument,
 362                            "symbol with ESD id " + std::to_string(Symb.d.a) +
 363                                " refers to invalid section with ESD id " +
 364                                std::to_string(SymEdId));
 365 }
 366
 367 const uint8_t *GOFFObjectFile::getSectionEdEsdRecord(DataRefImpl &Sec) const {
 368   SectionEntryImpl EsdIds = SectionList[Sec.d.a];
 369   const uint8_t *EsdRecord = EsdPtrs[EsdIds.d.a];
 370   return EsdRecord;
 371 }
 372
 373 const uint8_t *GOFFObjectFile::getSectionPrEsdRecord(DataRefImpl &Sec) const {
 374   SectionEntryImpl EsdIds = SectionList[Sec.d.a];
 375   const uint8_t *EsdRecord = nullptr;
 376   if (EsdIds.d.b)
 377     EsdRecord = EsdPtrs[EsdIds.d.b];
 378   return EsdRecord;
 379 }
 380
 381 const uint8_t *
 382 GOFFObjectFile::getSectionEdEsdRecord(uint32_t SectionIndex) const {
 383   DataRefImpl Sec;
 384   Sec.d.a = SectionIndex;
 385   const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec);
 386   return EsdRecord;
 387 }
 388
 389 const uint8_t *
 390 GOFFObjectFile::getSectionPrEsdRecord(uint32_t SectionIndex) const {
 391   DataRefImpl Sec;
 392   Sec.d.a = SectionIndex;
 393   const uint8_t *EsdRecord = getSectionPrEsdRecord(Sec);
 394   return EsdRecord;
 395 }
 396
 397 section_iterator GOFFObjectFile::section_begin() const {
 398   DataRefImpl Sec;
 399   moveSectionNext(Sec);
 400   return section_iterator(SectionRef(Sec, this));
 401 }
 402
 403 section_iterator GOFFObjectFile::section_end() const {
 404   DataRefImpl Sec;
 405   return section_iterator(SectionRef(Sec, this));
 406 }
 407
 408 void GOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
 409   for (uint32_t I = Symb.d.a + 1, E = EsdPtrs.size(); I < E; ++I) {
 410     if (EsdPtrs[I]) {
 411       const uint8_t *EsdRecord = EsdPtrs[I];
 412       GOFF::ESDSymbolType SymbolType;
 413       ESDRecord::getSymbolType(EsdRecord, SymbolType);
 414       // Skip EDs - i.e. section symbols.
 415       bool IgnoreSpecialGOFFSymbols = true;
 416       bool SkipSymbol = ((SymbolType == GOFF::ESD_ST_ElementDefinition) ||
 417                          (SymbolType == GOFF::ESD_ST_SectionDefinition)) &&
 418                         IgnoreSpecialGOFFSymbols;
 419       if (!SkipSymbol) {
 420         Symb.d.a = I;
 421         return;
 422       }
 423     }
 424   }
 425   Symb.d.a = 0;
 426 }
 427
 428 basic_symbol_iterator GOFFObjectFile::symbol_begin() const {
 429   DataRefImpl Symb;
 430   moveSymbolNext(Symb);
 431   return basic_symbol_iterator(SymbolRef(Symb, this));
 432 }
 433
 434 basic_symbol_iterator GOFFObjectFile::symbol_end() const {
 435   DataRefImpl Symb;
 436   return basic_symbol_iterator(SymbolRef(Symb, this));
 437 }
 438
 439 Error Record::getContinuousData(const uint8_t *Record, uint16_t DataLength,
 440                                 int DataIndex, SmallString<256> &CompleteData) {
 441   // First record.
 442   const uint8_t *Slice = Record + DataIndex;
 443   size_t SliceLength =
 444       std::min(DataLength, (uint16_t)(GOFF::RecordLength - DataIndex));
 445   CompleteData.append(Slice, Slice + SliceLength);
 446   DataLength -= SliceLength;
 447   Slice += SliceLength;
 448
 449   // Continuation records.
 450   for (; DataLength > 0;
 451        DataLength -= SliceLength, Slice += GOFF::PayloadLength) {
 452     // Slice points to the start of the new record.
 453     // Check that this block is a Continuation.
 454     assert(Record::isContinuation(Slice) && "Continuation bit must be set");
 455     // Check that the last Continuation is terminated correctly.
 456     if (DataLength <= 77 && Record::isContinued(Slice))
 457       return createStringError(object_error::parse_failed,
 458                                "continued bit should not be set");
 459
 460     SliceLength = std::min(DataLength, (uint16_t)GOFF::PayloadLength);
 461     Slice += GOFF::RecordPrefixLength;
 462     CompleteData.append(Slice, Slice + SliceLength);
 463   }
 464   return Error::success();
 465 }
 466
 467 Error HDRRecord::getData(const uint8_t *Record,
 468                          SmallString<256> &CompleteData) {
 469   uint16_t Length = getPropertyModuleLength(Record);
 470   return getContinuousData(Record, Length, 60, CompleteData);
 471 }
 472
 473 Error ESDRecord::getData(const uint8_t *Record,
 474                          SmallString<256> &CompleteData) {
 475   uint16_t DataSize = getNameLength(Record);
 476   return getContinuousData(Record, DataSize, 72, CompleteData);
 477 }
 478
 479 Error ENDRecord::getData(const uint8_t *Record,
 480                          SmallString<256> &CompleteData) {
 481   uint16_t Length = getNameLength(Record);
 482   return getContinuousData(Record, Length, 26, CompleteData);
 483 }