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