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 } 484