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 } 330 } 331 332 Expected<section_iterator> 333 GOFFObjectFile::getSymbolSection(DataRefImpl Symb) const { 334 DataRefImpl Sec; 335 336 if (isSymbolUnresolved(Symb)) 337 return section_iterator(SectionRef(Sec, this)); 338 339 const uint8_t *SymEsdRecord = EsdPtrs[Symb.d.a]; 340 uint32_t SymEdId; 341 ESDRecord::getParentEsdId(SymEsdRecord, SymEdId); 342 const uint8_t *SymEdRecord = EsdPtrs[SymEdId]; 343 344 for (size_t I = 0, E = SectionList.size(); I < E; ++I) { 345 bool Found; 346 const uint8_t *SectionPrRecord = getSectionPrEsdRecord(I); 347 if (SectionPrRecord) { 348 Found = SymEsdRecord == SectionPrRecord; 349 } else { 350 const uint8_t *SectionEdRecord = getSectionEdEsdRecord(I); 351 Found = SymEdRecord == SectionEdRecord; 352 } 353 354 if (Found) { 355 Sec.d.a = I; 356 return section_iterator(SectionRef(Sec, this)); 357 } 358 } 359 return createStringError(llvm::errc::invalid_argument, 360 "symbol with ESD id " + std::to_string(Symb.d.a) + 361 " refers to invalid section with ESD id " + 362 std::to_string(SymEdId)); 363 } 364 365 const uint8_t *GOFFObjectFile::getSectionEdEsdRecord(DataRefImpl &Sec) const { 366 SectionEntryImpl EsdIds = SectionList[Sec.d.a]; 367 const uint8_t *EsdRecord = EsdPtrs[EsdIds.d.a]; 368 return EsdRecord; 369 } 370 371 const uint8_t *GOFFObjectFile::getSectionPrEsdRecord(DataRefImpl &Sec) const { 372 SectionEntryImpl EsdIds = SectionList[Sec.d.a]; 373 const uint8_t *EsdRecord = nullptr; 374 if (EsdIds.d.b) 375 EsdRecord = EsdPtrs[EsdIds.d.b]; 376 return EsdRecord; 377 } 378 379 const uint8_t * 380 GOFFObjectFile::getSectionEdEsdRecord(uint32_t SectionIndex) const { 381 DataRefImpl Sec; 382 Sec.d.a = SectionIndex; 383 const uint8_t *EsdRecord = getSectionEdEsdRecord(Sec); 384 return EsdRecord; 385 } 386 387 const uint8_t * 388 GOFFObjectFile::getSectionPrEsdRecord(uint32_t SectionIndex) const { 389 DataRefImpl Sec; 390 Sec.d.a = SectionIndex; 391 const uint8_t *EsdRecord = getSectionPrEsdRecord(Sec); 392 return EsdRecord; 393 } 394 395 section_iterator GOFFObjectFile::section_begin() const { 396 DataRefImpl Sec; 397 moveSectionNext(Sec); 398 return section_iterator(SectionRef(Sec, this)); 399 } 400 401 section_iterator GOFFObjectFile::section_end() const { 402 DataRefImpl Sec; 403 return section_iterator(SectionRef(Sec, this)); 404 } 405 406 void GOFFObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 407 for (uint32_t I = Symb.d.a + 1, E = EsdPtrs.size(); I < E; ++I) { 408 if (EsdPtrs[I]) { 409 const uint8_t *EsdRecord = EsdPtrs[I]; 410 GOFF::ESDSymbolType SymbolType; 411 ESDRecord::getSymbolType(EsdRecord, SymbolType); 412 // Skip EDs - i.e. section symbols. 413 bool IgnoreSpecialGOFFSymbols = true; 414 bool SkipSymbol = ((SymbolType == GOFF::ESD_ST_ElementDefinition) || 415 (SymbolType == GOFF::ESD_ST_SectionDefinition)) && 416 IgnoreSpecialGOFFSymbols; 417 if (!SkipSymbol) { 418 Symb.d.a = I; 419 return; 420 } 421 } 422 } 423 Symb.d.a = 0; 424 } 425 426 basic_symbol_iterator GOFFObjectFile::symbol_begin() const { 427 DataRefImpl Symb; 428 moveSymbolNext(Symb); 429 return basic_symbol_iterator(SymbolRef(Symb, this)); 430 } 431 432 basic_symbol_iterator GOFFObjectFile::symbol_end() const { 433 DataRefImpl Symb; 434 return basic_symbol_iterator(SymbolRef(Symb, this)); 435 } 436 437 Error Record::getContinuousData(const uint8_t *Record, uint16_t DataLength, 438 int DataIndex, SmallString<256> &CompleteData) { 439 // First record. 440 const uint8_t *Slice = Record + DataIndex; 441 size_t SliceLength = 442 std::min(DataLength, (uint16_t)(GOFF::RecordLength - DataIndex)); 443 CompleteData.append(Slice, Slice + SliceLength); 444 DataLength -= SliceLength; 445 Slice += SliceLength; 446 447 // Continuation records. 448 for (; DataLength > 0; 449 DataLength -= SliceLength, Slice += GOFF::PayloadLength) { 450 // Slice points to the start of the new record. 451 // Check that this block is a Continuation. 452 assert(Record::isContinuation(Slice) && "Continuation bit must be set"); 453 // Check that the last Continuation is terminated correctly. 454 if (DataLength <= 77 && Record::isContinued(Slice)) 455 return createStringError(object_error::parse_failed, 456 "continued bit should not be set"); 457 458 SliceLength = std::min(DataLength, (uint16_t)GOFF::PayloadLength); 459 Slice += GOFF::RecordPrefixLength; 460 CompleteData.append(Slice, Slice + SliceLength); 461 } 462 return Error::success(); 463 } 464 465 Error HDRRecord::getData(const uint8_t *Record, 466 SmallString<256> &CompleteData) { 467 uint16_t Length = getPropertyModuleLength(Record); 468 return getContinuousData(Record, Length, 60, CompleteData); 469 } 470 471 Error ESDRecord::getData(const uint8_t *Record, 472 SmallString<256> &CompleteData) { 473 uint16_t DataSize = getNameLength(Record); 474 return getContinuousData(Record, DataSize, 72, CompleteData); 475 } 476 477 Error ENDRecord::getData(const uint8_t *Record, 478 SmallString<256> &CompleteData) { 479 uint16_t Length = getNameLength(Record); 480 return getContinuousData(Record, Length, 26, CompleteData); 481 } 482