RuntimeDyldMachO.cpp revision b442d7c6bf920b892b4b098923c1652700ee07e6
1//===-- RuntimeDyldMachO.cpp - Run-time dynamic linker for MC-JIT -*- C++ -*-=// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// Implementation of the MC-JIT runtime dynamic linker. 11// 12//===----------------------------------------------------------------------===// 13 14#define DEBUG_TYPE "dyld" 15#include "llvm/ADT/OwningPtr.h" 16#include "llvm/ADT/StringRef.h" 17#include "llvm/ADT/STLExtras.h" 18#include "RuntimeDyldImpl.h" 19using namespace llvm; 20using namespace llvm::object; 21 22namespace llvm { 23 24bool RuntimeDyldMachO:: 25resolveRelocation(uint8_t *Address, uint64_t Value, bool isPCRel, 26 unsigned Type, unsigned Size, int64_t Addend) { 27 // This just dispatches to the proper target specific routine. 28 switch (CPUType) { 29 default: assert(0 && "Unsupported CPU type!"); 30 case mach::CTM_x86_64: 31 return resolveX86_64Relocation((uintptr_t)Address, (uintptr_t)Value, 32 isPCRel, Type, Size, Addend); 33 case mach::CTM_ARM: 34 return resolveARMRelocation((uintptr_t)Address, (uintptr_t)Value, 35 isPCRel, Type, Size, Addend); 36 } 37 llvm_unreachable(""); 38} 39 40bool RuntimeDyldMachO:: 41resolveX86_64Relocation(uintptr_t Address, uintptr_t Value, bool isPCRel, 42 unsigned Type, unsigned Size, int64_t Addend) { 43 // If the relocation is PC-relative, the value to be encoded is the 44 // pointer difference. 45 if (isPCRel) 46 // FIXME: It seems this value needs to be adjusted by 4 for an effective PC 47 // address. Is that expected? Only for branches, perhaps? 48 Value -= Address + 4; 49 50 switch(Type) { 51 default: 52 llvm_unreachable("Invalid relocation type!"); 53 case macho::RIT_X86_64_Signed1: 54 case macho::RIT_X86_64_Signed2: 55 case macho::RIT_X86_64_Signed4: 56 case macho::RIT_X86_64_Signed: 57 case macho::RIT_X86_64_Unsigned: 58 case macho::RIT_X86_64_Branch: { 59 Value += Addend; 60 // Mask in the target value a byte at a time (we don't have an alignment 61 // guarantee for the target address, so this is safest). 62 uint8_t *p = (uint8_t*)Address; 63 for (unsigned i = 0; i < Size; ++i) { 64 *p++ = (uint8_t)Value; 65 Value >>= 8; 66 } 67 return false; 68 } 69 case macho::RIT_X86_64_GOTLoad: 70 case macho::RIT_X86_64_GOT: 71 case macho::RIT_X86_64_Subtractor: 72 case macho::RIT_X86_64_TLV: 73 return Error("Relocation type not implemented yet!"); 74 } 75} 76 77bool RuntimeDyldMachO:: 78resolveARMRelocation(uintptr_t Address, uintptr_t Value, bool isPCRel, 79 unsigned Type, unsigned Size, int64_t Addend) { 80 // If the relocation is PC-relative, the value to be encoded is the 81 // pointer difference. 82 if (isPCRel) { 83 Value -= Address; 84 // ARM PCRel relocations have an effective-PC offset of two instructions 85 // (four bytes in Thumb mode, 8 bytes in ARM mode). 86 // FIXME: For now, assume ARM mode. 87 Value -= 8; 88 } 89 90 switch(Type) { 91 default: 92 llvm_unreachable("Invalid relocation type!"); 93 case macho::RIT_Vanilla: { 94 llvm_unreachable("Invalid relocation type!"); 95 // Mask in the target value a byte at a time (we don't have an alignment 96 // guarantee for the target address, so this is safest). 97 uint8_t *p = (uint8_t*)Address; 98 for (unsigned i = 0; i < Size; ++i) { 99 *p++ = (uint8_t)Value; 100 Value >>= 8; 101 } 102 break; 103 } 104 case macho::RIT_ARM_Branch24Bit: { 105 // Mask the value into the target address. We know instructions are 106 // 32-bit aligned, so we can do it all at once. 107 uint32_t *p = (uint32_t*)Address; 108 // The low two bits of the value are not encoded. 109 Value >>= 2; 110 // Mask the value to 24 bits. 111 Value &= 0xffffff; 112 // FIXME: If the destination is a Thumb function (and the instruction 113 // is a non-predicated BL instruction), we need to change it to a BLX 114 // instruction instead. 115 116 // Insert the value into the instruction. 117 *p = (*p & ~0xffffff) | Value; 118 break; 119 } 120 case macho::RIT_ARM_ThumbBranch22Bit: 121 case macho::RIT_ARM_ThumbBranch32Bit: 122 case macho::RIT_ARM_Half: 123 case macho::RIT_ARM_HalfDifference: 124 case macho::RIT_Pair: 125 case macho::RIT_Difference: 126 case macho::RIT_ARM_LocalDifference: 127 case macho::RIT_ARM_PreboundLazyPointer: 128 return Error("Relocation type not implemented yet!"); 129 } 130 return false; 131} 132 133bool RuntimeDyldMachO:: 134loadSegment32(const MachOObject *Obj, 135 const MachOObject::LoadCommandInfo *SegmentLCI, 136 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC) { 137 // FIXME: This should really be combined w/ loadSegment64. Templatized 138 // function on the 32/64 datatypes maybe? 139 InMemoryStruct<macho::SegmentLoadCommand> SegmentLC; 140 Obj->ReadSegmentLoadCommand(*SegmentLCI, SegmentLC); 141 if (!SegmentLC) 142 return Error("unable to load segment load command"); 143 144 145 SmallVector<unsigned, 16> SectionMap; 146 for (unsigned SectNum = 0; SectNum != SegmentLC->NumSections; ++SectNum) { 147 InMemoryStruct<macho::Section> Sect; 148 Obj->ReadSection(*SegmentLCI, SectNum, Sect); 149 if (!Sect) 150 return Error("unable to load section: '" + Twine(SectNum) + "'"); 151 152 // Allocate memory via the MM for the section. 153 uint8_t *Buffer; 154 uint32_t SectionID = Sections.size(); 155 if (Sect->Flags != 0x80000400) 156 Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); 157 else 158 Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); 159 160 DEBUG(dbgs() << "Loading " 161 << ((Sect->Flags == 0x80000400) ? "text" : "data") 162 << " (ID #" << SectionID << ")" 163 << " '" << Sect->SegmentName << "," 164 << Sect->Name << "' of size " << Sect->Size 165 << " to address " << Buffer << ".\n"); 166 167 // Copy the payload from the object file into the allocated buffer. 168 uint8_t *Base = (uint8_t*)Obj->getData(SegmentLC->FileOffset, 169 SegmentLC->FileSize).data(); 170 memcpy(Buffer, Base + Sect->Address, Sect->Size); 171 172 // Remember what got allocated for this SectionID. 173 Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size)); 174 SectionLocalMemToID[Buffer] = SectionID; 175 176 // By default, the load address of a section is its memory buffer. 177 SectionLoadAddress.push_back((uint64_t)Buffer); 178 179 // Keep a map of object file section numbers to corresponding SectionIDs 180 // while processing the file. 181 SectionMap.push_back(SectionID); 182 } 183 184 // Process the symbol table. 185 SmallVector<StringRef, 64> SymbolNames; 186 processSymbols32(Obj, SectionMap, SymbolNames, SymtabLC); 187 188 // Process the relocations for each section we're loading. 189 Relocations.grow(Relocations.size() + SegmentLC->NumSections); 190 for (unsigned SectNum = 0; SectNum != SegmentLC->NumSections; ++SectNum) { 191 InMemoryStruct<macho::Section> Sect; 192 Obj->ReadSection(*SegmentLCI, SectNum, Sect); 193 if (!Sect) 194 return Error("unable to load section: '" + Twine(SectNum) + "'"); 195 for (unsigned j = 0; j != Sect->NumRelocationTableEntries; ++j) { 196 InMemoryStruct<macho::RelocationEntry> RE; 197 Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j, RE); 198 if (RE->Word0 & macho::RF_Scattered) 199 return Error("NOT YET IMPLEMENTED: scattered relocations."); 200 // Word0 of the relocation is the offset into the section where the 201 // relocation should be applied. We need to translate that into an 202 // offset into a function since that's our atom. 203 uint32_t Offset = RE->Word0; 204 bool isExtern = (RE->Word1 >> 27) & 1; 205 206 // FIXME: Get the relocation addend from the target address. 207 // FIXME: VERY imporant for internal relocations. 208 209 // Figure out the source symbol of the relocation. If isExtern is true, 210 // this relocation references the symbol table, otherwise it references 211 // a section in the same object, numbered from 1 through NumSections 212 // (SectionBases is [0, NumSections-1]). 213 uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value 214 if (!isExtern) { 215 assert(SourceNum > 0 && "Invalid relocation section number!"); 216 unsigned SectionID = SectionMap[SourceNum - 1]; 217 unsigned TargetID = SectionMap[SectNum]; 218 DEBUG(dbgs() << "Internal relocation at Section #" 219 << TargetID << " + " << Offset 220 << " from Section #" 221 << SectionID << " (Word1: " 222 << format("0x%x", RE->Word1) << ")\n"); 223 224 // Store the relocation information. It will get resolved when 225 // the section addresses are assigned. 226 Relocations[SectionID].push_back(RelocationEntry(TargetID, 227 Offset, 228 RE->Word1, 229 0 /*Addend*/)); 230 } else { 231 StringRef SourceName = SymbolNames[SourceNum]; 232 233 // Now store the relocation information. Associate it with the source 234 // symbol. Just add it to the unresolved list and let the general 235 // path post-load resolve it if we know where the symbol is. 236 UnresolvedRelocations[SourceName].push_back(RelocationEntry(SectNum, 237 Offset, 238 RE->Word1, 239 0 /*Addend*/)); 240 DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << Offset 241 << " from '" << SourceName << "(Word1: " 242 << format("0x%x", RE->Word1) << ")\n"); 243 } 244 } 245 } 246 247 // Resolve the addresses of any symbols that were defined in this segment. 248 for (int i = 0, e = SymbolNames.size(); i != e; ++i) 249 resolveSymbol(SymbolNames[i]); 250 251 return false; 252} 253 254 255bool RuntimeDyldMachO:: 256loadSegment64(const MachOObject *Obj, 257 const MachOObject::LoadCommandInfo *SegmentLCI, 258 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC) { 259 InMemoryStruct<macho::Segment64LoadCommand> Segment64LC; 260 Obj->ReadSegment64LoadCommand(*SegmentLCI, Segment64LC); 261 if (!Segment64LC) 262 return Error("unable to load segment load command"); 263 264 265 SmallVector<unsigned, 16> SectionMap; 266 for (unsigned SectNum = 0; SectNum != Segment64LC->NumSections; ++SectNum) { 267 InMemoryStruct<macho::Section64> Sect; 268 Obj->ReadSection64(*SegmentLCI, SectNum, Sect); 269 if (!Sect) 270 return Error("unable to load section: '" + Twine(SectNum) + "'"); 271 272 // Allocate memory via the MM for the section. 273 uint8_t *Buffer; 274 uint32_t SectionID = Sections.size(); 275 if (Sect->Flags == 0x80000400) 276 Buffer = MemMgr->allocateCodeSection(Sect->Size, Sect->Align, SectionID); 277 else 278 Buffer = MemMgr->allocateDataSection(Sect->Size, Sect->Align, SectionID); 279 280 DEBUG(dbgs() << "Loading " 281 << ((Sect->Flags == 0x80000400) ? "text" : "data") 282 << " (ID #" << SectionID << ")" 283 << " '" << Sect->SegmentName << "," 284 << Sect->Name << "' of size " << Sect->Size 285 << " to address " << Buffer << ".\n"); 286 287 // Copy the payload from the object file into the allocated buffer. 288 uint8_t *Base = (uint8_t*)Obj->getData(Segment64LC->FileOffset, 289 Segment64LC->FileSize).data(); 290 memcpy(Buffer, Base + Sect->Address, Sect->Size); 291 292 // Remember what got allocated for this SectionID. 293 Sections.push_back(sys::MemoryBlock(Buffer, Sect->Size)); 294 SectionLocalMemToID[Buffer] = SectionID; 295 296 // By default, the load address of a section is its memory buffer. 297 SectionLoadAddress.push_back((uint64_t)Buffer); 298 299 // Keep a map of object file section numbers to corresponding SectionIDs 300 // while processing the file. 301 SectionMap.push_back(SectionID); 302 } 303 304 // Process the symbol table. 305 SmallVector<StringRef, 64> SymbolNames; 306 processSymbols64(Obj, SectionMap, SymbolNames, SymtabLC); 307 308 // Process the relocations for each section we're loading. 309 Relocations.grow(Relocations.size() + Segment64LC->NumSections); 310 for (unsigned SectNum = 0; SectNum != Segment64LC->NumSections; ++SectNum) { 311 InMemoryStruct<macho::Section64> Sect; 312 Obj->ReadSection64(*SegmentLCI, SectNum, Sect); 313 if (!Sect) 314 return Error("unable to load section: '" + Twine(SectNum) + "'"); 315 for (unsigned j = 0; j != Sect->NumRelocationTableEntries; ++j) { 316 InMemoryStruct<macho::RelocationEntry> RE; 317 Obj->ReadRelocationEntry(Sect->RelocationTableOffset, j, RE); 318 if (RE->Word0 & macho::RF_Scattered) 319 return Error("NOT YET IMPLEMENTED: scattered relocations."); 320 // Word0 of the relocation is the offset into the section where the 321 // relocation should be applied. We need to translate that into an 322 // offset into a function since that's our atom. 323 uint32_t Offset = RE->Word0; 324 bool isExtern = (RE->Word1 >> 27) & 1; 325 326 // FIXME: Get the relocation addend from the target address. 327 // FIXME: VERY imporant for internal relocations. 328 329 // Figure out the source symbol of the relocation. If isExtern is true, 330 // this relocation references the symbol table, otherwise it references 331 // a section in the same object, numbered from 1 through NumSections 332 // (SectionBases is [0, NumSections-1]). 333 uint32_t SourceNum = RE->Word1 & 0xffffff; // 24-bit value 334 if (!isExtern) { 335 assert(SourceNum > 0 && "Invalid relocation section number!"); 336 unsigned SectionID = SectionMap[SourceNum - 1]; 337 unsigned TargetID = SectionMap[SectNum]; 338 DEBUG(dbgs() << "Internal relocation at Section #" 339 << TargetID << " + " << Offset 340 << " from Section #" 341 << SectionID << " (Word1: " 342 << format("0x%x", RE->Word1) << ")\n"); 343 344 // Store the relocation information. It will get resolved when 345 // the section addresses are assigned. 346 Relocations[SectionID].push_back(RelocationEntry(TargetID, 347 Offset, 348 RE->Word1, 349 0 /*Addend*/)); 350 } else { 351 StringRef SourceName = SymbolNames[SourceNum]; 352 353 // Now store the relocation information. Associate it with the source 354 // symbol. Just add it to the unresolved list and let the general 355 // path post-load resolve it if we know where the symbol is. 356 UnresolvedRelocations[SourceName].push_back(RelocationEntry(SectNum, 357 Offset, 358 RE->Word1, 359 0 /*Addend*/)); 360 DEBUG(dbgs() << "Relocation at Section #" << SectNum << " + " << Offset 361 << " from '" << SourceName << "(Word1: " 362 << format("0x%x", RE->Word1) << ")\n"); 363 } 364 } 365 } 366 367 // Resolve the addresses of any symbols that were defined in this segment. 368 for (int i = 0, e = SymbolNames.size(); i != e; ++i) 369 resolveSymbol(SymbolNames[i]); 370 371 return false; 372} 373 374bool RuntimeDyldMachO:: 375processSymbols32(const MachOObject *Obj, 376 SmallVectorImpl<unsigned> &SectionMap, 377 SmallVectorImpl<StringRef> &SymbolNames, 378 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC) { 379 // FIXME: Combine w/ processSymbols64. Factor 64/32 datatype and such. 380 for (unsigned i = 0; i != SymtabLC->NumSymbolTableEntries; ++i) { 381 InMemoryStruct<macho::SymbolTableEntry> STE; 382 Obj->ReadSymbolTableEntry(SymtabLC->SymbolTableOffset, i, STE); 383 if (!STE) 384 return Error("unable to read symbol: '" + Twine(i) + "'"); 385 // Get the symbol name. 386 StringRef Name = Obj->getStringAtIndex(STE->StringIndex); 387 SymbolNames.push_back(Name); 388 389 // FIXME: Check the symbol type and flags. 390 if (STE->Type != 0xF) // external, defined in this segment. 391 continue; 392 // Flags in the upper nibble we don't care about. 393 if ((STE->Flags & 0xf) != 0x0) 394 continue; 395 396 // Remember the symbol. 397 uint32_t SectionID = SectionMap[STE->SectionIndex - 1]; 398 SymbolTable[Name] = SymbolLoc(SectionID, STE->Value); 399 400 DEBUG(dbgs() << "Symbol: '" << Name << "' @ " 401 << (getSectionAddress(SectionID) + STE->Value) 402 << "\n"); 403 } 404 return false; 405} 406 407bool RuntimeDyldMachO:: 408processSymbols64(const MachOObject *Obj, 409 SmallVectorImpl<unsigned> &SectionMap, 410 SmallVectorImpl<StringRef> &SymbolNames, 411 const InMemoryStruct<macho::SymtabLoadCommand> &SymtabLC) { 412 for (unsigned i = 0; i != SymtabLC->NumSymbolTableEntries; ++i) { 413 InMemoryStruct<macho::Symbol64TableEntry> STE; 414 Obj->ReadSymbol64TableEntry(SymtabLC->SymbolTableOffset, i, STE); 415 if (!STE) 416 return Error("unable to read symbol: '" + Twine(i) + "'"); 417 // Get the symbol name. 418 StringRef Name = Obj->getStringAtIndex(STE->StringIndex); 419 SymbolNames.push_back(Name); 420 421 // FIXME: Check the symbol type and flags. 422 if (STE->Type != 0xF) // external, defined in this segment. 423 continue; 424 // Flags in the upper nibble we don't care about. 425 if ((STE->Flags & 0xf) != 0x0) 426 continue; 427 428 // Remember the symbol. 429 uint32_t SectionID = SectionMap[STE->SectionIndex - 1]; 430 SymbolTable[Name] = SymbolLoc(SectionID, STE->Value); 431 432 DEBUG(dbgs() << "Symbol: '" << Name << "' @ " 433 << (getSectionAddress(SectionID) + STE->Value) 434 << "\n"); 435 } 436 return false; 437} 438 439// resolveSymbol - Resolve any relocations to the specified symbol if 440// we know where it lives. 441void RuntimeDyldMachO::resolveSymbol(StringRef Name) { 442 StringMap<SymbolLoc>::const_iterator Loc = SymbolTable.find(Name); 443 if (Loc == SymbolTable.end()) 444 return; 445 446 RelocationList &Relocs = UnresolvedRelocations[Name]; 447 DEBUG(dbgs() << "Resolving symbol '" << Name << "'\n"); 448 for (int i = 0, e = Relocs.size(); i != e; ++i) { 449 // Change the relocation to be section relative rather than symbol 450 // relative and move it to the resolved relocation list. 451 RelocationEntry Entry = Relocs[i]; 452 Entry.Addend += Loc->second.second; 453 Relocations[Loc->second.first].push_back(Entry); 454 } 455 // FIXME: Keep a worklist of the relocations we've added so that we can 456 // resolve more selectively later. 457 Relocs.clear(); 458} 459 460bool RuntimeDyldMachO::loadObject(MemoryBuffer *InputBuffer) { 461 // If the linker is in an error state, don't do anything. 462 if (hasError()) 463 return true; 464 // Load the Mach-O wrapper object. 465 std::string ErrorStr; 466 OwningPtr<MachOObject> Obj( 467 MachOObject::LoadFromBuffer(InputBuffer, &ErrorStr)); 468 if (!Obj) 469 return Error("unable to load object: '" + ErrorStr + "'"); 470 471 // Get the CPU type information from the header. 472 const macho::Header &Header = Obj->getHeader(); 473 474 // FIXME: Error checking that the loaded object is compatible with 475 // the system we're running on. 476 CPUType = Header.CPUType; 477 CPUSubtype = Header.CPUSubtype; 478 479 // Validate that the load commands match what we expect. 480 const MachOObject::LoadCommandInfo *SegmentLCI = 0, *SymtabLCI = 0, 481 *DysymtabLCI = 0; 482 for (unsigned i = 0; i != Header.NumLoadCommands; ++i) { 483 const MachOObject::LoadCommandInfo &LCI = Obj->getLoadCommandInfo(i); 484 switch (LCI.Command.Type) { 485 case macho::LCT_Segment: 486 case macho::LCT_Segment64: 487 if (SegmentLCI) 488 return Error("unexpected input object (multiple segments)"); 489 SegmentLCI = &LCI; 490 break; 491 case macho::LCT_Symtab: 492 if (SymtabLCI) 493 return Error("unexpected input object (multiple symbol tables)"); 494 SymtabLCI = &LCI; 495 break; 496 case macho::LCT_Dysymtab: 497 if (DysymtabLCI) 498 return Error("unexpected input object (multiple symbol tables)"); 499 DysymtabLCI = &LCI; 500 break; 501 default: 502 return Error("unexpected input object (unexpected load command"); 503 } 504 } 505 506 if (!SymtabLCI) 507 return Error("no symbol table found in object"); 508 if (!SegmentLCI) 509 return Error("no segments found in object"); 510 511 // Read and register the symbol table data. 512 InMemoryStruct<macho::SymtabLoadCommand> SymtabLC; 513 Obj->ReadSymtabLoadCommand(*SymtabLCI, SymtabLC); 514 if (!SymtabLC) 515 return Error("unable to load symbol table load command"); 516 Obj->RegisterStringTable(*SymtabLC); 517 518 // Read the dynamic link-edit information, if present (not present in static 519 // objects). 520 if (DysymtabLCI) { 521 InMemoryStruct<macho::DysymtabLoadCommand> DysymtabLC; 522 Obj->ReadDysymtabLoadCommand(*DysymtabLCI, DysymtabLC); 523 if (!DysymtabLC) 524 return Error("unable to load dynamic link-exit load command"); 525 526 // FIXME: We don't support anything interesting yet. 527// if (DysymtabLC->LocalSymbolsIndex != 0) 528// return Error("NOT YET IMPLEMENTED: local symbol entries"); 529// if (DysymtabLC->ExternalSymbolsIndex != 0) 530// return Error("NOT YET IMPLEMENTED: non-external symbol entries"); 531// if (DysymtabLC->UndefinedSymbolsIndex != SymtabLC->NumSymbolTableEntries) 532// return Error("NOT YET IMPLEMENTED: undefined symbol entries"); 533 } 534 535 // Load the segment load command. 536 if (SegmentLCI->Command.Type == macho::LCT_Segment) { 537 if (loadSegment32(Obj.get(), SegmentLCI, SymtabLC)) 538 return true; 539 } else { 540 if (loadSegment64(Obj.get(), SegmentLCI, SymtabLC)) 541 return true; 542 } 543 544 // Assign the addresses of the sections from the object so that any 545 // relocations to them get set properly. 546 // FIXME: This is done directly from the client at the moment. We should 547 // default the values to the local storage, at least when the target arch 548 // is the same as the host arch. 549 550 return false; 551} 552 553// Assign an address to a symbol name and resolve all the relocations 554// associated with it. 555void RuntimeDyldMachO::reassignSectionAddress(unsigned SectionID, 556 uint64_t Addr) { 557 // The address to use for relocation resolution is not 558 // the address of the local section buffer. We must be doing 559 // a remote execution environment of some sort. Re-apply any 560 // relocations referencing this section with the given address. 561 // 562 // Addr is a uint64_t because we can't assume the pointer width 563 // of the target is the same as that of the host. Just use a generic 564 // "big enough" type. 565 566 SectionLoadAddress[SectionID] = Addr; 567 568 RelocationList &Relocs = Relocations[SectionID]; 569 for (unsigned i = 0, e = Relocs.size(); i != e; ++i) { 570 RelocationEntry &RE = Relocs[i]; 571 uint8_t *Target = (uint8_t*)Sections[RE.SectionID].base() + RE.Offset; 572 bool isPCRel = (RE.Data >> 24) & 1; 573 unsigned Type = (RE.Data >> 28) & 0xf; 574 unsigned Size = 1 << ((RE.Data >> 25) & 3); 575 576 DEBUG(dbgs() << "Resolving relocation at Section #" << RE.SectionID 577 << " + " << RE.Offset << " (" << format("%p", Target) << ")" 578 << " from Section #" << SectionID << " (" << format("%p", Addr) << ")" 579 << "(" << (isPCRel ? "pcrel" : "absolute") 580 << ", type: " << Type << ", Size: " << Size << ", Addend: " 581 << RE.Addend << ").\n"); 582 583 resolveRelocation(Target, Addr, isPCRel, Type, Size, RE.Addend); 584 } 585} 586 587bool RuntimeDyldMachO::isKnownFormat(const MemoryBuffer *InputBuffer) { 588 StringRef Magic = InputBuffer->getBuffer().slice(0, 4); 589 if (Magic == "\xFE\xED\xFA\xCE") return true; 590 if (Magic == "\xCE\xFA\xED\xFE") return true; 591 if (Magic == "\xFE\xED\xFA\xCF") return true; 592 if (Magic == "\xCF\xFA\xED\xFE") return true; 593 return false; 594} 595 596} // end namespace llvm 597