JITEmitter.cpp revision 3ed469ccd7b028a030b550d84b7336d146f5d8fa
1//===-- JITEmitter.cpp - Write machine code to executable memory ----------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines a MachineCodeEmitter object that is used by the JIT to 11// write machine code to memory and remember where relocatable values are. 12// 13//===----------------------------------------------------------------------===// 14 15#define DEBUG_TYPE "jit" 16#include "JIT.h" 17#include "llvm/Constant.h" 18#include "llvm/Module.h" 19#include "llvm/Type.h" 20#include "llvm/CodeGen/MachineCodeEmitter.h" 21#include "llvm/CodeGen/MachineFunction.h" 22#include "llvm/CodeGen/MachineConstantPool.h" 23#include "llvm/CodeGen/MachineJumpTableInfo.h" 24#include "llvm/CodeGen/MachineRelocation.h" 25#include "llvm/ExecutionEngine/GenericValue.h" 26#include "llvm/Target/TargetData.h" 27#include "llvm/Target/TargetJITInfo.h" 28#include "llvm/Support/Debug.h" 29#include "llvm/Support/MutexGuard.h" 30#include "llvm/ADT/Statistic.h" 31#include "llvm/System/Memory.h" 32#include <algorithm> 33#include <iostream> 34using namespace llvm; 35 36namespace { 37 Statistic<> NumBytes("jit", "Number of bytes of machine code compiled"); 38 Statistic<> NumRelos("jit", "Number of relocations applied"); 39 JIT *TheJIT = 0; 40} 41 42 43//===----------------------------------------------------------------------===// 44// JITMemoryManager code. 45// 46namespace { 47 /// MemoryRangeHeader - For a range of memory, this is the header that we put 48 /// on the block of memory. It is carefully crafted to be one word of memory. 49 /// Allocated blocks have just this header, free'd blocks have FreeRangeHeader 50 /// which starts with this. 51 struct FreeRangeHeader; 52 struct MemoryRangeHeader { 53 /// ThisAllocated - This is true if this block is currently allocated. If 54 /// not, this can be converted to a FreeRangeHeader. 55 intptr_t ThisAllocated : 1; 56 57 /// PrevAllocated - Keep track of whether the block immediately before us is 58 /// allocated. If not, the word immediately before this header is the size 59 /// of the previous block. 60 intptr_t PrevAllocated : 1; 61 62 /// BlockSize - This is the size in bytes of this memory block, 63 /// including this header. 64 uintptr_t BlockSize : (sizeof(intptr_t)*8 - 2); 65 66 67 /// getBlockAfter - Return the memory block immediately after this one. 68 /// 69 MemoryRangeHeader &getBlockAfter() const { 70 return *(MemoryRangeHeader*)((char*)this+BlockSize); 71 } 72 73 /// getFreeBlockBefore - If the block before this one is free, return it, 74 /// otherwise return null. 75 FreeRangeHeader *getFreeBlockBefore() const { 76 if (PrevAllocated) return 0; 77 intptr_t PrevSize = ((intptr_t *)this)[-1]; 78 return (FreeRangeHeader*)((char*)this-PrevSize); 79 } 80 81 /// FreeBlock - Turn an allocated block into a free block, adjusting 82 /// bits in the object headers, and adding an end of region memory block. 83 FreeRangeHeader *FreeBlock(FreeRangeHeader *FreeList); 84 85 /// TrimAllocationToSize - If this allocated block is significantly larger 86 /// than NewSize, split it into two pieces (where the former is NewSize 87 /// bytes, including the header), and add the new block to the free list. 88 FreeRangeHeader *TrimAllocationToSize(FreeRangeHeader *FreeList, 89 uint64_t NewSize); 90 }; 91 92 /// FreeRangeHeader - For a memory block that isn't already allocated, this 93 /// keeps track of the current block and has a pointer to the next free block. 94 /// Free blocks are kept on a circularly linked list. 95 struct FreeRangeHeader : public MemoryRangeHeader { 96 FreeRangeHeader *Prev; 97 FreeRangeHeader *Next; 98 99 /// getMinBlockSize - Get the minimum size for a memory block. Blocks 100 /// smaller than this size cannot be created. 101 static unsigned getMinBlockSize() { 102 return sizeof(FreeRangeHeader)+sizeof(intptr_t); 103 } 104 105 /// SetEndOfBlockSizeMarker - The word at the end of every free block is 106 /// known to be the size of the free block. Set it for this block. 107 void SetEndOfBlockSizeMarker() { 108 void *EndOfBlock = (char*)this + BlockSize; 109 ((intptr_t *)EndOfBlock)[-1] = BlockSize; 110 } 111 112 FreeRangeHeader *RemoveFromFreeList() { 113 assert(Next->Prev == this && Prev->Next == this && "Freelist broken!"); 114 Next->Prev = Prev; 115 return Prev->Next = Next; 116 } 117 118 void AddToFreeList(FreeRangeHeader *FreeList) { 119 Next = FreeList; 120 Prev = FreeList->Prev; 121 Prev->Next = this; 122 Next->Prev = this; 123 } 124 125 /// GrowBlock - The block after this block just got deallocated. Merge it 126 /// into the current block. 127 void GrowBlock(uintptr_t NewSize); 128 129 /// AllocateBlock - Mark this entire block allocated, updating freelists 130 /// etc. This returns a pointer to the circular free-list. 131 FreeRangeHeader *AllocateBlock(); 132 }; 133} 134 135 136/// AllocateBlock - Mark this entire block allocated, updating freelists 137/// etc. This returns a pointer to the circular free-list. 138FreeRangeHeader *FreeRangeHeader::AllocateBlock() { 139 assert(!ThisAllocated && !getBlockAfter().PrevAllocated && 140 "Cannot allocate an allocated block!"); 141 // Mark this block allocated. 142 ThisAllocated = 1; 143 getBlockAfter().PrevAllocated = 1; 144 145 // Remove it from the free list. 146 return RemoveFromFreeList(); 147} 148 149/// FreeBlock - Turn an allocated block into a free block, adjusting 150/// bits in the object headers, and adding an end of region memory block. 151/// If possible, coallesce this block with neighboring blocks. Return the 152/// FreeRangeHeader to allocate from. 153FreeRangeHeader *MemoryRangeHeader::FreeBlock(FreeRangeHeader *FreeList) { 154 MemoryRangeHeader *FollowingBlock = &getBlockAfter(); 155 assert(ThisAllocated && "This block is already allocated!"); 156 assert(FollowingBlock->PrevAllocated && "Flags out of sync!"); 157 158 FreeRangeHeader *FreeListToReturn = FreeList; 159 160 // If the block after this one is free, merge it into this block. 161 if (!FollowingBlock->ThisAllocated) { 162 FreeRangeHeader &FollowingFreeBlock = *(FreeRangeHeader *)FollowingBlock; 163 // "FreeList" always needs to be a valid free block. If we're about to 164 // coallesce with it, update our notion of what the free list is. 165 if (&FollowingFreeBlock == FreeList) { 166 FreeList = FollowingFreeBlock.Next; 167 FreeListToReturn = 0; 168 assert(&FollowingFreeBlock != FreeList && "No tombstone block?"); 169 } 170 FollowingFreeBlock.RemoveFromFreeList(); 171 172 // Include the following block into this one. 173 BlockSize += FollowingFreeBlock.BlockSize; 174 FollowingBlock = &FollowingFreeBlock.getBlockAfter(); 175 176 // Tell the block after the block we are coallescing that this block is 177 // allocated. 178 FollowingBlock->PrevAllocated = 1; 179 } 180 181 assert(FollowingBlock->ThisAllocated && "Missed coallescing?"); 182 183 if (FreeRangeHeader *PrevFreeBlock = getFreeBlockBefore()) { 184 PrevFreeBlock->GrowBlock(PrevFreeBlock->BlockSize + BlockSize); 185 return FreeListToReturn ? FreeListToReturn : PrevFreeBlock; 186 } 187 188 // Otherwise, mark this block free. 189 FreeRangeHeader &FreeBlock = *(FreeRangeHeader*)this; 190 FollowingBlock->PrevAllocated = 0; 191 FreeBlock.ThisAllocated = 0; 192 193 // Link this into the linked list of free blocks. 194 FreeBlock.AddToFreeList(FreeList); 195 196 // Add a marker at the end of the block, indicating the size of this free 197 // block. 198 FreeBlock.SetEndOfBlockSizeMarker(); 199 return FreeListToReturn ? FreeListToReturn : &FreeBlock; 200} 201 202/// GrowBlock - The block after this block just got deallocated. Merge it 203/// into the current block. 204void FreeRangeHeader::GrowBlock(uintptr_t NewSize) { 205 assert(NewSize > BlockSize && "Not growing block?"); 206 BlockSize = NewSize; 207 SetEndOfBlockSizeMarker(); 208 getBlockAfter().PrevAllocated = 0; 209} 210 211/// TrimAllocationToSize - If this allocated block is significantly larger 212/// than NewSize, split it into two pieces (where the former is NewSize 213/// bytes, including the header), and add the new block to the free list. 214FreeRangeHeader *MemoryRangeHeader:: 215TrimAllocationToSize(FreeRangeHeader *FreeList, uint64_t NewSize) { 216 assert(ThisAllocated && getBlockAfter().PrevAllocated && 217 "Cannot deallocate part of an allocated block!"); 218 219 // Round up size for alignment of header. 220 unsigned HeaderAlign = __alignof(FreeRangeHeader); 221 NewSize = (NewSize+ (HeaderAlign-1)) & ~(HeaderAlign-1); 222 223 // Size is now the size of the block we will remove from the start of the 224 // current block. 225 assert(NewSize <= BlockSize && 226 "Allocating more space from this block than exists!"); 227 228 // If splitting this block will cause the remainder to be too small, do not 229 // split the block. 230 if (BlockSize <= NewSize+FreeRangeHeader::getMinBlockSize()) 231 return FreeList; 232 233 // Otherwise, we splice the required number of bytes out of this block, form 234 // a new block immediately after it, then mark this block allocated. 235 MemoryRangeHeader &FormerNextBlock = getBlockAfter(); 236 237 // Change the size of this block. 238 BlockSize = NewSize; 239 240 // Get the new block we just sliced out and turn it into a free block. 241 FreeRangeHeader &NewNextBlock = (FreeRangeHeader &)getBlockAfter(); 242 NewNextBlock.BlockSize = (char*)&FormerNextBlock - (char*)&NewNextBlock; 243 NewNextBlock.ThisAllocated = 0; 244 NewNextBlock.PrevAllocated = 1; 245 NewNextBlock.SetEndOfBlockSizeMarker(); 246 FormerNextBlock.PrevAllocated = 0; 247 NewNextBlock.AddToFreeList(FreeList); 248 return &NewNextBlock; 249} 250 251 252namespace { 253 /// JITMemoryManager - Manage memory for the JIT code generation in a logical, 254 /// sane way. This splits a large block of MAP_NORESERVE'd memory into two 255 /// sections, one for function stubs, one for the functions themselves. We 256 /// have to do this because we may need to emit a function stub while in the 257 /// middle of emitting a function, and we don't know how large the function we 258 /// are emitting is. This never bothers to release the memory, because when 259 /// we are ready to destroy the JIT, the program exits. 260 class JITMemoryManager { 261 std::vector<sys::MemoryBlock> Blocks; // Memory blocks allocated by the JIT 262 FreeRangeHeader *FreeMemoryList; // Circular list of free blocks. 263 264 // When emitting code into a memory block, this is the block. 265 MemoryRangeHeader *CurBlock; 266 267 unsigned char *CurStubPtr, *StubBase; 268 unsigned char *GOTBase; // Target Specific reserved memory 269 270 // Centralize memory block allocation. 271 sys::MemoryBlock getNewMemoryBlock(unsigned size); 272 273 std::map<const Function*, MemoryRangeHeader*> FunctionBlocks; 274 public: 275 JITMemoryManager(bool useGOT); 276 ~JITMemoryManager(); 277 278 inline unsigned char *allocateStub(unsigned StubSize); 279 280 /// startFunctionBody - When a function starts, allocate a block of free 281 /// executable memory, returning a pointer to it and its actual size. 282 unsigned char *startFunctionBody(uintptr_t &ActualSize) { 283 CurBlock = FreeMemoryList; 284 285 // Allocate the entire memory block. 286 FreeMemoryList = FreeMemoryList->AllocateBlock(); 287 ActualSize = CurBlock->BlockSize-sizeof(MemoryRangeHeader); 288 return (unsigned char *)(CurBlock+1); 289 } 290 291 /// endFunctionBody - The function F is now allocated, and takes the memory 292 /// in the range [FunctionStart,FunctionEnd). 293 void endFunctionBody(const Function *F, unsigned char *FunctionStart, 294 unsigned char *FunctionEnd) { 295 assert(FunctionEnd > FunctionStart); 296 assert(FunctionStart == (unsigned char *)(CurBlock+1) && 297 "Mismatched function start/end!"); 298 299 uintptr_t BlockSize = FunctionEnd - (unsigned char *)CurBlock; 300 FunctionBlocks[F] = CurBlock; 301 302 // Release the memory at the end of this block that isn't needed. 303 FreeMemoryList =CurBlock->TrimAllocationToSize(FreeMemoryList, BlockSize); 304 } 305 306 unsigned char *getGOTBase() const { 307 return GOTBase; 308 } 309 bool isManagingGOT() const { 310 return GOTBase != NULL; 311 } 312 313 /// deallocateMemForFunction - Deallocate all memory for the specified 314 /// function body. 315 void deallocateMemForFunction(const Function *F) { 316 std::map<const Function*, MemoryRangeHeader*>::iterator 317 I = FunctionBlocks.find(F); 318 if (I == FunctionBlocks.end()) return; 319 320 // Find the block that is allocated for this function. 321 MemoryRangeHeader *MemRange = I->second; 322 assert(MemRange->ThisAllocated && "Block isn't allocated!"); 323 324 // Fill the buffer with garbage! 325 DEBUG(memset(MemRange+1, 0xCD, MemRange->BlockSize-sizeof(*MemRange))); 326 327 // Free the memory. 328 FreeMemoryList = MemRange->FreeBlock(FreeMemoryList); 329 330 // Finally, remove this entry from FunctionBlocks. 331 FunctionBlocks.erase(I); 332 } 333 }; 334} 335 336JITMemoryManager::JITMemoryManager(bool useGOT) { 337 // Allocate a 16M block of memory for functions. 338 sys::MemoryBlock MemBlock = getNewMemoryBlock(16 << 20); 339 340 unsigned char *MemBase = reinterpret_cast<unsigned char*>(MemBlock.base()); 341 342 // Allocate stubs backwards from the base, allocate functions forward 343 // from the base. 344 StubBase = MemBase; 345 CurStubPtr = MemBase + 512*1024; // Use 512k for stubs, working backwards. 346 347 // We set up the memory chunk with 4 mem regions, like this: 348 // [ START 349 // [ Free #0 ] -> Large space to allocate functions from. 350 // [ Allocated #1 ] -> Tiny space to separate regions. 351 // [ Free #2 ] -> Tiny space so there is always at least 1 free block. 352 // [ Allocated #3 ] -> Tiny space to prevent looking past end of block. 353 // END ] 354 // 355 // The last three blocks are never deallocated or touched. 356 357 // Add MemoryRangeHeader to the end of the memory region, indicating that 358 // the space after the block of memory is allocated. This is block #3. 359 MemoryRangeHeader *Mem3 = (MemoryRangeHeader*)(MemBase+MemBlock.size())-1; 360 Mem3->ThisAllocated = 1; 361 Mem3->PrevAllocated = 0; 362 Mem3->BlockSize = 0; 363 364 /// Add a tiny free region so that the free list always has one entry. 365 FreeRangeHeader *Mem2 = 366 (FreeRangeHeader *)(((char*)Mem3)-FreeRangeHeader::getMinBlockSize()); 367 Mem2->ThisAllocated = 0; 368 Mem2->PrevAllocated = 1; 369 Mem2->BlockSize = FreeRangeHeader::getMinBlockSize(); 370 Mem2->SetEndOfBlockSizeMarker(); 371 Mem2->Prev = Mem2; // Mem2 *is* the free list for now. 372 Mem2->Next = Mem2; 373 374 /// Add a tiny allocated region so that Mem2 is never coallesced away. 375 MemoryRangeHeader *Mem1 = (MemoryRangeHeader*)Mem2-1; 376 Mem1->ThisAllocated = 1; 377 Mem1->PrevAllocated = 0; 378 Mem1->BlockSize = (char*)Mem2 - (char*)Mem1; 379 380 // Add a FreeRangeHeader to the start of the function body region, indicating 381 // that the space is free. Mark the previous block allocated so we never look 382 // at it. 383 FreeRangeHeader *Mem0 = (FreeRangeHeader*)CurStubPtr; 384 Mem0->ThisAllocated = 0; 385 Mem0->PrevAllocated = 1; 386 Mem0->BlockSize = (char*)Mem1-(char*)Mem0; 387 Mem0->SetEndOfBlockSizeMarker(); 388 Mem0->AddToFreeList(Mem2); 389 390 // Start out with the freelist pointing to Mem0. 391 FreeMemoryList = Mem0; 392 393 // Allocate the GOT. 394 GOTBase = NULL; 395 if (useGOT) GOTBase = new unsigned char[sizeof(void*) * 8192]; 396} 397 398JITMemoryManager::~JITMemoryManager() { 399 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) 400 sys::Memory::ReleaseRWX(Blocks[i]); 401 402 delete[] GOTBase; 403 Blocks.clear(); 404} 405 406unsigned char *JITMemoryManager::allocateStub(unsigned StubSize) { 407 CurStubPtr -= StubSize; 408 if (CurStubPtr < StubBase) { 409 // FIXME: allocate a new block 410 std::cerr << "JIT ran out of memory for function stubs!\n"; 411 abort(); 412 } 413 return CurStubPtr; 414} 415 416sys::MemoryBlock JITMemoryManager::getNewMemoryBlock(unsigned size) { 417 // Allocate a new block close to the last one. 418 const sys::MemoryBlock *BOld = Blocks.empty() ? 0 : &Blocks.front(); 419 std::string ErrMsg; 420 sys::MemoryBlock B = sys::Memory::AllocateRWX(size, BOld, &ErrMsg); 421 if (B.base() == 0) { 422 std::cerr << "Allocation failed when allocating new memory in the JIT\n"; 423 std::cerr << ErrMsg << "\n"; 424 abort(); 425 } 426 Blocks.push_back(B); 427 return B; 428} 429 430//===----------------------------------------------------------------------===// 431// JIT lazy compilation code. 432// 433namespace { 434 class JITResolverState { 435 private: 436 /// FunctionToStubMap - Keep track of the stub created for a particular 437 /// function so that we can reuse them if necessary. 438 std::map<Function*, void*> FunctionToStubMap; 439 440 /// StubToFunctionMap - Keep track of the function that each stub 441 /// corresponds to. 442 std::map<void*, Function*> StubToFunctionMap; 443 444 public: 445 std::map<Function*, void*>& getFunctionToStubMap(const MutexGuard& locked) { 446 assert(locked.holds(TheJIT->lock)); 447 return FunctionToStubMap; 448 } 449 450 std::map<void*, Function*>& getStubToFunctionMap(const MutexGuard& locked) { 451 assert(locked.holds(TheJIT->lock)); 452 return StubToFunctionMap; 453 } 454 }; 455 456 /// JITResolver - Keep track of, and resolve, call sites for functions that 457 /// have not yet been compiled. 458 class JITResolver { 459 /// MCE - The MachineCodeEmitter to use to emit stubs with. 460 MachineCodeEmitter &MCE; 461 462 /// LazyResolverFn - The target lazy resolver function that we actually 463 /// rewrite instructions to use. 464 TargetJITInfo::LazyResolverFn LazyResolverFn; 465 466 JITResolverState state; 467 468 /// ExternalFnToStubMap - This is the equivalent of FunctionToStubMap for 469 /// external functions. 470 std::map<void*, void*> ExternalFnToStubMap; 471 472 //map addresses to indexes in the GOT 473 std::map<void*, unsigned> revGOTMap; 474 unsigned nextGOTIndex; 475 476 public: 477 JITResolver(MachineCodeEmitter &mce) : MCE(mce), nextGOTIndex(0) { 478 LazyResolverFn = 479 TheJIT->getJITInfo().getLazyResolverFunction(JITCompilerFn); 480 } 481 482 /// getFunctionStub - This returns a pointer to a function stub, creating 483 /// one on demand as needed. 484 void *getFunctionStub(Function *F); 485 486 /// getExternalFunctionStub - Return a stub for the function at the 487 /// specified address, created lazily on demand. 488 void *getExternalFunctionStub(void *FnAddr); 489 490 /// AddCallbackAtLocation - If the target is capable of rewriting an 491 /// instruction without the use of a stub, record the location of the use so 492 /// we know which function is being used at the location. 493 void *AddCallbackAtLocation(Function *F, void *Location) { 494 MutexGuard locked(TheJIT->lock); 495 /// Get the target-specific JIT resolver function. 496 state.getStubToFunctionMap(locked)[Location] = F; 497 return (void*)(intptr_t)LazyResolverFn; 498 } 499 500 /// getGOTIndexForAddress - Return a new or existing index in the GOT for 501 /// and address. This function only manages slots, it does not manage the 502 /// contents of the slots or the memory associated with the GOT. 503 unsigned getGOTIndexForAddr(void* addr); 504 505 /// JITCompilerFn - This function is called to resolve a stub to a compiled 506 /// address. If the LLVM Function corresponding to the stub has not yet 507 /// been compiled, this function compiles it first. 508 static void *JITCompilerFn(void *Stub); 509 }; 510} 511 512/// getJITResolver - This function returns the one instance of the JIT resolver. 513/// 514static JITResolver &getJITResolver(MachineCodeEmitter *MCE = 0) { 515 static JITResolver TheJITResolver(*MCE); 516 return TheJITResolver; 517} 518 519#if (defined(__POWERPC__) || defined (__ppc__) || defined(_POWER)) && \ 520 defined(__APPLE__) 521extern "C" void sys_icache_invalidate(const void *Addr, size_t len); 522#endif 523 524/// synchronizeICache - On some targets, the JIT emitted code must be 525/// explicitly refetched to ensure correct execution. 526static void synchronizeICache(const void *Addr, size_t len) { 527#if (defined(__POWERPC__) || defined (__ppc__) || defined(_POWER)) && \ 528 defined(__APPLE__) 529 sys_icache_invalidate(Addr, len); 530#endif 531} 532 533/// getFunctionStub - This returns a pointer to a function stub, creating 534/// one on demand as needed. 535void *JITResolver::getFunctionStub(Function *F) { 536 MutexGuard locked(TheJIT->lock); 537 538 // If we already have a stub for this function, recycle it. 539 void *&Stub = state.getFunctionToStubMap(locked)[F]; 540 if (Stub) return Stub; 541 542 // Call the lazy resolver function unless we already KNOW it is an external 543 // function, in which case we just skip the lazy resolution step. 544 void *Actual = (void*)(intptr_t)LazyResolverFn; 545 if (F->isExternal() && !F->hasNotBeenReadFromBytecode()) 546 Actual = TheJIT->getPointerToFunction(F); 547 548 // Otherwise, codegen a new stub. For now, the stub will call the lazy 549 // resolver function. 550 Stub = TheJIT->getJITInfo().emitFunctionStub(Actual, MCE); 551 552 if (Actual != (void*)(intptr_t)LazyResolverFn) { 553 // If we are getting the stub for an external function, we really want the 554 // address of the stub in the GlobalAddressMap for the JIT, not the address 555 // of the external function. 556 TheJIT->updateGlobalMapping(F, Stub); 557 } 558 559 // Invalidate the icache if necessary. 560 synchronizeICache(Stub, MCE.getCurrentPCValue()-(intptr_t)Stub); 561 562 DEBUG(std::cerr << "JIT: Stub emitted at [" << Stub << "] for function '" 563 << F->getName() << "'\n"); 564 565 // Finally, keep track of the stub-to-Function mapping so that the 566 // JITCompilerFn knows which function to compile! 567 state.getStubToFunctionMap(locked)[Stub] = F; 568 return Stub; 569} 570 571/// getExternalFunctionStub - Return a stub for the function at the 572/// specified address, created lazily on demand. 573void *JITResolver::getExternalFunctionStub(void *FnAddr) { 574 // If we already have a stub for this function, recycle it. 575 void *&Stub = ExternalFnToStubMap[FnAddr]; 576 if (Stub) return Stub; 577 578 Stub = TheJIT->getJITInfo().emitFunctionStub(FnAddr, MCE); 579 580 // Invalidate the icache if necessary. 581 synchronizeICache(Stub, MCE.getCurrentPCValue()-(intptr_t)Stub); 582 583 DEBUG(std::cerr << "JIT: Stub emitted at [" << Stub 584 << "] for external function at '" << FnAddr << "'\n"); 585 return Stub; 586} 587 588unsigned JITResolver::getGOTIndexForAddr(void* addr) { 589 unsigned idx = revGOTMap[addr]; 590 if (!idx) { 591 idx = ++nextGOTIndex; 592 revGOTMap[addr] = idx; 593 DEBUG(std::cerr << "Adding GOT entry " << idx 594 << " for addr " << addr << "\n"); 595 // ((void**)MemMgr.getGOTBase())[idx] = addr; 596 } 597 return idx; 598} 599 600/// JITCompilerFn - This function is called when a lazy compilation stub has 601/// been entered. It looks up which function this stub corresponds to, compiles 602/// it if necessary, then returns the resultant function pointer. 603void *JITResolver::JITCompilerFn(void *Stub) { 604 JITResolver &JR = getJITResolver(); 605 606 MutexGuard locked(TheJIT->lock); 607 608 // The address given to us for the stub may not be exactly right, it might be 609 // a little bit after the stub. As such, use upper_bound to find it. 610 std::map<void*, Function*>::iterator I = 611 JR.state.getStubToFunctionMap(locked).upper_bound(Stub); 612 assert(I != JR.state.getStubToFunctionMap(locked).begin() && 613 "This is not a known stub!"); 614 Function *F = (--I)->second; 615 616 // We might like to remove the stub from the StubToFunction map. 617 // We can't do that! Multiple threads could be stuck, waiting to acquire the 618 // lock above. As soon as the 1st function finishes compiling the function, 619 // the next one will be released, and needs to be able to find the function it 620 // needs to call. 621 //JR.state.getStubToFunctionMap(locked).erase(I); 622 623 DEBUG(std::cerr << "JIT: Lazily resolving function '" << F->getName() 624 << "' In stub ptr = " << Stub << " actual ptr = " 625 << I->first << "\n"); 626 627 void *Result = TheJIT->getPointerToFunction(F); 628 629 // We don't need to reuse this stub in the future, as F is now compiled. 630 JR.state.getFunctionToStubMap(locked).erase(F); 631 632 // FIXME: We could rewrite all references to this stub if we knew them. 633 634 // What we will do is set the compiled function address to map to the 635 // same GOT entry as the stub so that later clients may update the GOT 636 // if they see it still using the stub address. 637 // Note: this is done so the Resolver doesn't have to manage GOT memory 638 // Do this without allocating map space if the target isn't using a GOT 639 if(JR.revGOTMap.find(Stub) != JR.revGOTMap.end()) 640 JR.revGOTMap[Result] = JR.revGOTMap[Stub]; 641 642 return Result; 643} 644 645 646//===----------------------------------------------------------------------===// 647// JITEmitter code. 648// 649namespace { 650 /// JITEmitter - The JIT implementation of the MachineCodeEmitter, which is 651 /// used to output functions to memory for execution. 652 class JITEmitter : public MachineCodeEmitter { 653 JITMemoryManager MemMgr; 654 655 // When outputting a function stub in the context of some other function, we 656 // save BufferBegin/BufferEnd/CurBufferPtr here. 657 unsigned char *SavedBufferBegin, *SavedBufferEnd, *SavedCurBufferPtr; 658 659 /// Relocations - These are the relocations that the function needs, as 660 /// emitted. 661 std::vector<MachineRelocation> Relocations; 662 663 /// MBBLocations - This vector is a mapping from MBB ID's to their address. 664 /// It is filled in by the StartMachineBasicBlock callback and queried by 665 /// the getMachineBasicBlockAddress callback. 666 std::vector<intptr_t> MBBLocations; 667 668 /// ConstantPool - The constant pool for the current function. 669 /// 670 MachineConstantPool *ConstantPool; 671 672 /// ConstantPoolBase - A pointer to the first entry in the constant pool. 673 /// 674 void *ConstantPoolBase; 675 676 /// JumpTable - The jump tables for the current function. 677 /// 678 MachineJumpTableInfo *JumpTable; 679 680 /// JumpTableBase - A pointer to the first entry in the jump table. 681 /// 682 void *JumpTableBase; 683public: 684 JITEmitter(JIT &jit) : MemMgr(jit.getJITInfo().needsGOT()) { 685 TheJIT = &jit; 686 DEBUG(if (MemMgr.isManagingGOT()) std::cerr << "JIT is managing a GOT\n"); 687 } 688 689 virtual void startFunction(MachineFunction &F); 690 virtual bool finishFunction(MachineFunction &F); 691 692 void emitConstantPool(MachineConstantPool *MCP); 693 void initJumpTableInfo(MachineJumpTableInfo *MJTI); 694 void emitJumpTableInfo(MachineJumpTableInfo *MJTI); 695 696 virtual void startFunctionStub(unsigned StubSize); 697 virtual void* finishFunctionStub(const Function *F); 698 699 virtual void addRelocation(const MachineRelocation &MR) { 700 Relocations.push_back(MR); 701 } 702 703 virtual void StartMachineBasicBlock(MachineBasicBlock *MBB) { 704 if (MBBLocations.size() <= (unsigned)MBB->getNumber()) 705 MBBLocations.resize((MBB->getNumber()+1)*2); 706 MBBLocations[MBB->getNumber()] = getCurrentPCValue(); 707 } 708 709 virtual intptr_t getConstantPoolEntryAddress(unsigned Entry) const; 710 virtual intptr_t getJumpTableEntryAddress(unsigned Entry) const; 711 712 virtual intptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const { 713 assert(MBBLocations.size() > (unsigned)MBB->getNumber() && 714 MBBLocations[MBB->getNumber()] && "MBB not emitted!"); 715 return MBBLocations[MBB->getNumber()]; 716 } 717 718 /// deallocateMemForFunction - Deallocate all memory for the specified 719 /// function body. 720 void deallocateMemForFunction(Function *F) { 721 MemMgr.deallocateMemForFunction(F); 722 } 723 private: 724 void *getPointerToGlobal(GlobalValue *GV, void *Reference, bool NoNeedStub); 725 }; 726} 727 728void *JITEmitter::getPointerToGlobal(GlobalValue *V, void *Reference, 729 bool DoesntNeedStub) { 730 if (GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) { 731 /// FIXME: If we straightened things out, this could actually emit the 732 /// global immediately instead of queuing it for codegen later! 733 return TheJIT->getOrEmitGlobalVariable(GV); 734 } 735 736 // If we have already compiled the function, return a pointer to its body. 737 Function *F = cast<Function>(V); 738 void *ResultPtr = TheJIT->getPointerToGlobalIfAvailable(F); 739 if (ResultPtr) return ResultPtr; 740 741 if (F->isExternal() && !F->hasNotBeenReadFromBytecode()) { 742 // If this is an external function pointer, we can force the JIT to 743 // 'compile' it, which really just adds it to the map. 744 if (DoesntNeedStub) 745 return TheJIT->getPointerToFunction(F); 746 747 return getJITResolver(this).getFunctionStub(F); 748 } 749 750 // Okay, the function has not been compiled yet, if the target callback 751 // mechanism is capable of rewriting the instruction directly, prefer to do 752 // that instead of emitting a stub. 753 if (DoesntNeedStub) 754 return getJITResolver(this).AddCallbackAtLocation(F, Reference); 755 756 // Otherwise, we have to emit a lazy resolving stub. 757 return getJITResolver(this).getFunctionStub(F); 758} 759 760void JITEmitter::startFunction(MachineFunction &F) { 761 uintptr_t ActualSize; 762 BufferBegin = CurBufferPtr = MemMgr.startFunctionBody(ActualSize); 763 BufferEnd = BufferBegin+ActualSize; 764 765 emitConstantPool(F.getConstantPool()); 766 initJumpTableInfo(F.getJumpTableInfo()); 767 768 // About to start emitting the machine code for the function. 769 emitAlignment(std::max(F.getFunction()->getAlignment(), 8U)); 770 TheJIT->updateGlobalMapping(F.getFunction(), CurBufferPtr); 771 772 MBBLocations.clear(); 773} 774 775bool JITEmitter::finishFunction(MachineFunction &F) { 776 if (CurBufferPtr == BufferEnd) { 777 // FIXME: Allocate more space, then try again. 778 std::cerr << "JIT: Ran out of space for generated machine code!\n"; 779 abort(); 780 } 781 782 emitJumpTableInfo(F.getJumpTableInfo()); 783 784 // FnStart is the start of the text, not the start of the constant pool and 785 // other per-function data. 786 unsigned char *FnStart = 787 (unsigned char *)TheJIT->getPointerToGlobalIfAvailable(F.getFunction()); 788 unsigned char *FnEnd = CurBufferPtr; 789 790 MemMgr.endFunctionBody(F.getFunction(), BufferBegin, FnEnd); 791 NumBytes += FnEnd-FnStart; 792 793 if (!Relocations.empty()) { 794 NumRelos += Relocations.size(); 795 796 // Resolve the relocations to concrete pointers. 797 for (unsigned i = 0, e = Relocations.size(); i != e; ++i) { 798 MachineRelocation &MR = Relocations[i]; 799 void *ResultPtr; 800 if (MR.isString()) { 801 ResultPtr = TheJIT->getPointerToNamedFunction(MR.getString()); 802 803 // If the target REALLY wants a stub for this function, emit it now. 804 if (!MR.doesntNeedFunctionStub()) 805 ResultPtr = getJITResolver(this).getExternalFunctionStub(ResultPtr); 806 } else if (MR.isGlobalValue()) { 807 ResultPtr = getPointerToGlobal(MR.getGlobalValue(), 808 BufferBegin+MR.getMachineCodeOffset(), 809 MR.doesntNeedFunctionStub()); 810 } else if (MR.isBasicBlock()) { 811 ResultPtr = (void*)getMachineBasicBlockAddress(MR.getBasicBlock()); 812 } else if (MR.isConstantPoolIndex()){ 813 ResultPtr=(void*)getConstantPoolEntryAddress(MR.getConstantPoolIndex()); 814 } else { 815 assert(MR.isJumpTableIndex()); 816 ResultPtr=(void*)getJumpTableEntryAddress(MR.getJumpTableIndex()); 817 } 818 819 MR.setResultPointer(ResultPtr); 820 821 // if we are managing the GOT and the relocation wants an index, 822 // give it one 823 if (MemMgr.isManagingGOT() && MR.isGOTRelative()) { 824 unsigned idx = getJITResolver(this).getGOTIndexForAddr(ResultPtr); 825 MR.setGOTIndex(idx); 826 if (((void**)MemMgr.getGOTBase())[idx] != ResultPtr) { 827 DEBUG(std::cerr << "GOT was out of date for " << ResultPtr 828 << " pointing at " << ((void**)MemMgr.getGOTBase())[idx] 829 << "\n"); 830 ((void**)MemMgr.getGOTBase())[idx] = ResultPtr; 831 } 832 } 833 } 834 835 TheJIT->getJITInfo().relocate(BufferBegin, &Relocations[0], 836 Relocations.size(), MemMgr.getGOTBase()); 837 } 838 839 // Update the GOT entry for F to point to the new code. 840 if(MemMgr.isManagingGOT()) { 841 unsigned idx = getJITResolver(this).getGOTIndexForAddr((void*)BufferBegin); 842 if (((void**)MemMgr.getGOTBase())[idx] != (void*)BufferBegin) { 843 DEBUG(std::cerr << "GOT was out of date for " << (void*)BufferBegin 844 << " pointing at " << ((void**)MemMgr.getGOTBase())[idx] << "\n"); 845 ((void**)MemMgr.getGOTBase())[idx] = (void*)BufferBegin; 846 } 847 } 848 849 // Invalidate the icache if necessary. 850 synchronizeICache(FnStart, FnEnd-FnStart); 851 852 DEBUG(std::cerr << "JIT: Finished CodeGen of [" << (void*)FnStart 853 << "] Function: " << F.getFunction()->getName() 854 << ": " << (FnEnd-FnStart) << " bytes of text, " 855 << Relocations.size() << " relocations\n"); 856 Relocations.clear(); 857 return false; 858} 859 860void JITEmitter::emitConstantPool(MachineConstantPool *MCP) { 861 const std::vector<MachineConstantPoolEntry> &Constants = MCP->getConstants(); 862 if (Constants.empty()) return; 863 864 MachineConstantPoolEntry CPE = Constants.back(); 865 unsigned Size = CPE.Offset; 866 const Type *Ty = CPE.isMachineConstantPoolEntry() 867 ? CPE.Val.MachineCPVal->getType() : CPE.Val.ConstVal->getType(); 868 Size += TheJIT->getTargetData()->getTypeSize(Ty); 869 870 ConstantPoolBase = allocateSpace(Size, 1 << MCP->getConstantPoolAlignment()); 871 ConstantPool = MCP; 872 873 if (ConstantPoolBase == 0) return; // Buffer overflow. 874 875 // Initialize the memory for all of the constant pool entries. 876 for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 877 void *CAddr = (char*)ConstantPoolBase+Constants[i].Offset; 878 if (Constants[i].isMachineConstantPoolEntry()) { 879 // FIXME: add support to lower machine constant pool values into bytes! 880 std::cerr << "Initialize memory with machine specific constant pool entry" 881 << " has not been implemented!\n"; 882 abort(); 883 } 884 TheJIT->InitializeMemory(Constants[i].Val.ConstVal, CAddr); 885 } 886} 887 888void JITEmitter::initJumpTableInfo(MachineJumpTableInfo *MJTI) { 889 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 890 if (JT.empty()) return; 891 892 unsigned NumEntries = 0; 893 for (unsigned i = 0, e = JT.size(); i != e; ++i) 894 NumEntries += JT[i].MBBs.size(); 895 896 unsigned EntrySize = MJTI->getEntrySize(); 897 898 // Just allocate space for all the jump tables now. We will fix up the actual 899 // MBB entries in the tables after we emit the code for each block, since then 900 // we will know the final locations of the MBBs in memory. 901 JumpTable = MJTI; 902 JumpTableBase = allocateSpace(NumEntries * EntrySize, MJTI->getAlignment()); 903} 904 905void JITEmitter::emitJumpTableInfo(MachineJumpTableInfo *MJTI) { 906 const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables(); 907 if (JT.empty() || JumpTableBase == 0) return; 908 909 assert(MJTI->getEntrySize() == sizeof(void*) && "Cross JIT'ing?"); 910 911 // For each jump table, map each target in the jump table to the address of 912 // an emitted MachineBasicBlock. 913 intptr_t *SlotPtr = (intptr_t*)JumpTableBase; 914 915 for (unsigned i = 0, e = JT.size(); i != e; ++i) { 916 const std::vector<MachineBasicBlock*> &MBBs = JT[i].MBBs; 917 // Store the address of the basic block for this jump table slot in the 918 // memory we allocated for the jump table in 'initJumpTableInfo' 919 for (unsigned mi = 0, me = MBBs.size(); mi != me; ++mi) 920 *SlotPtr++ = getMachineBasicBlockAddress(MBBs[mi]); 921 } 922} 923 924void JITEmitter::startFunctionStub(unsigned StubSize) { 925 SavedBufferBegin = BufferBegin; 926 SavedBufferEnd = BufferEnd; 927 SavedCurBufferPtr = CurBufferPtr; 928 929 BufferBegin = CurBufferPtr = MemMgr.allocateStub(StubSize); 930 BufferEnd = BufferBegin+StubSize+1; 931} 932 933void *JITEmitter::finishFunctionStub(const Function *F) { 934 NumBytes += getCurrentPCOffset(); 935 std::swap(SavedBufferBegin, BufferBegin); 936 BufferEnd = SavedBufferEnd; 937 CurBufferPtr = SavedCurBufferPtr; 938 return SavedBufferBegin; 939} 940 941// getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry 942// in the constant pool that was last emitted with the 'emitConstantPool' 943// method. 944// 945intptr_t JITEmitter::getConstantPoolEntryAddress(unsigned ConstantNum) const { 946 assert(ConstantNum < ConstantPool->getConstants().size() && 947 "Invalid ConstantPoolIndex!"); 948 return (intptr_t)ConstantPoolBase + 949 ConstantPool->getConstants()[ConstantNum].Offset; 950} 951 952// getJumpTableEntryAddress - Return the address of the JumpTable with index 953// 'Index' in the jumpp table that was last initialized with 'initJumpTableInfo' 954// 955intptr_t JITEmitter::getJumpTableEntryAddress(unsigned Index) const { 956 const std::vector<MachineJumpTableEntry> &JT = JumpTable->getJumpTables(); 957 assert(Index < JT.size() && "Invalid jump table index!"); 958 959 unsigned Offset = 0; 960 unsigned EntrySize = JumpTable->getEntrySize(); 961 962 for (unsigned i = 0; i < Index; ++i) 963 Offset += JT[i].MBBs.size() * EntrySize; 964 965 return (intptr_t)((char *)JumpTableBase + Offset); 966} 967 968//===----------------------------------------------------------------------===// 969// Public interface to this file 970//===----------------------------------------------------------------------===// 971 972MachineCodeEmitter *JIT::createEmitter(JIT &jit) { 973 return new JITEmitter(jit); 974} 975 976// getPointerToNamedFunction - This function is used as a global wrapper to 977// JIT::getPointerToNamedFunction for the purpose of resolving symbols when 978// bugpoint is debugging the JIT. In that scenario, we are loading an .so and 979// need to resolve function(s) that are being mis-codegenerated, so we need to 980// resolve their addresses at runtime, and this is the way to do it. 981extern "C" { 982 void *getPointerToNamedFunction(const char *Name) { 983 if (Function *F = TheJIT->FindFunctionNamed(Name)) 984 return TheJIT->getPointerToFunction(F); 985 return TheJIT->getPointerToNamedFunction(Name); 986 } 987} 988 989// getPointerToFunctionOrStub - If the specified function has been 990// code-gen'd, return a pointer to the function. If not, compile it, or use 991// a stub to implement lazy compilation if available. 992// 993void *JIT::getPointerToFunctionOrStub(Function *F) { 994 // If we have already code generated the function, just return the address. 995 if (void *Addr = getPointerToGlobalIfAvailable(F)) 996 return Addr; 997 998 // Get a stub if the target supports it 999 return getJITResolver(MCE).getFunctionStub(F); 1000} 1001 1002/// freeMachineCodeForFunction - release machine code memory for given Function. 1003/// 1004void JIT::freeMachineCodeForFunction(Function *F) { 1005 // Delete translation for this from the ExecutionEngine, so it will get 1006 // retranslated next time it is used. 1007 updateGlobalMapping(F, 0); 1008 1009 // Free the actual memory for the function body and related stuff. 1010 assert(dynamic_cast<JITEmitter*>(MCE) && "Unexpected MCE?"); 1011 dynamic_cast<JITEmitter*>(MCE)->deallocateMemForFunction(F); 1012} 1013 1014