lib/Target/X86/X86JITInfo.cpp

   1 //===-- X86JITInfo.cpp - Implement the JIT interfaces for the X86 target --===//
   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 implements the JIT interfaces for the X86 target.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "jit"
  15 #include <cstdlib>
  16 #include "X86JITInfo.h"
  17 #include "X86Relocations.h"
  18 #include "llvm/CodeGen/MachineCodeEmitter.h"
  19 #include "llvm/Config/alloca.h"
  20 using namespace llvm;
  21
  22 void X86JITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
  23   unsigned char *OldByte = (unsigned char *)Old;
  24   *OldByte++ = 0xE9;                // Emit JMP opcode.
  25   unsigned *OldWord = (unsigned *)OldByte;
  26   unsigned NewAddr = (intptr_t)New;
  27   unsigned OldAddr = (intptr_t)OldWord;
  28   *OldWord = NewAddr - OldAddr - 4; // Emit PC-relative addr of New code.
  29 }
  30
  31
  32 /// JITCompilerFunction - This contains the address of the JIT function used to
  33 /// compile a function lazily.
  34 static TargetJITInfo::JITCompilerFn JITCompilerFunction;
  35
  36 // Provide a wrapper for X86CompilationCallback2 that saves non-traditional
  37 // callee saved registers, for the fastcc calling convention.
  38 extern "C" {
  39 #if defined(__i386__) || defined(i386) || defined(_M_IX86)
  40 #ifndef _MSC_VER
  41   void X86CompilationCallback(void);
  42   asm(
  43     ".text\n"
  44     ".align 8\n"
  45     ".globl X86CompilationCallback\n"
  46   "X86CompilationCallback:\n"
  47     "pushl   %ebp\n"
  48     "movl    %esp, %ebp\n"    // Standard prologue
  49     "pushl   %eax\n"
  50     "pushl   %edx\n"          // save EAX/EDX
  51     "call X86CompilationCallback2\n"
  52     "popl    %edx\n"
  53     "popl    %eax\n"
  54     "popl    %ebp\n"
  55     "ret\n");
  56 #else
  57   extern "C" void *_AddressOfReturnAddress(void);
  58   #pragma intrinsic(_AddressOfReturnAddress)
  59
  60   void X86CompilationCallback2(void);
  61
  62   _declspec(naked) void X86CompilationCallback(void) {
  63     __asm {
  64       push  eax
  65       push  edx
  66       call  X86CompilationCallback2
  67       pop   edx
  68       pop   eax
  69       ret
  70     }
  71   }
  72 #endif // _MSC_VER
  73
  74 #else // Not an i386 host
  75   void X86CompilationCallback() {
  76     std::cerr << "Cannot call X86CompilationCallback() on a non-x86 arch!\n";
  77     abort();
  78   }
  79 #endif
  80 }
  81
  82 /// X86CompilationCallback - This is the target-specific function invoked by the
  83 /// function stub when we did not know the real target of a call.  This function
  84 /// must locate the start of the stub or call site and pass it into the JIT
  85 /// compiler function.
  86 extern "C" void X86CompilationCallback2() {
  87 #ifdef _MSC_VER
  88   assert(sizeof(size_t) == 4); // FIXME: handle Win64
  89   unsigned *RetAddrLoc = (unsigned *)_AddressOfReturnAddress();
  90   RetAddrLoc += 3;  // skip over ret addr, edx, eax
  91   unsigned RetAddr = *RetAddrLoc;
  92 #else
  93   unsigned *StackPtr = (unsigned*)__builtin_frame_address(1);
  94   unsigned RetAddr = (unsigned)(intptr_t)__builtin_return_address(1);
  95   unsigned *RetAddrLoc = &StackPtr[1];
  96
  97   // NOTE: __builtin_frame_address doesn't work if frame pointer elimination has
  98   // been performed.  Having a variable sized alloca disables frame pointer
  99   // elimination currently, even if it's dead.  This is a gross hack.
 100   alloca(10+(RetAddr >> 31));
 101
 102 #endif
 103   assert(*RetAddrLoc == RetAddr &&
 104          "Could not find return address on the stack!");
 105
 106   // It's a stub if there is an interrupt marker after the call.
 107   bool isStub = ((unsigned char*)(intptr_t)RetAddr)[0] == 0xCD;
 108
 109   // The call instruction should have pushed the return value onto the stack...
 110   RetAddr -= 4;  // Backtrack to the reference itself...
 111
 112 #if 0
 113   DEBUG(std::cerr << "In callback! Addr=" << (void*)RetAddr
 114                   << " ESP=" << (void*)StackPtr
 115                   << ": Resolving call to function: "
 116                   << TheVM->getFunctionReferencedName((void*)RetAddr) << "\n");
 117 #endif
 118
 119   // Sanity check to make sure this really is a call instruction.
 120   assert(((unsigned char*)(intptr_t)RetAddr)[-1] == 0xE8 &&"Not a call instr!");
 121
 122   unsigned NewVal = (intptr_t)JITCompilerFunction((void*)(intptr_t)RetAddr);
 123
 124   // Rewrite the call target... so that we don't end up here every time we
 125   // execute the call.
 126   *(unsigned*)(intptr_t)RetAddr = NewVal-RetAddr-4;
 127
 128   if (isStub) {
 129     // If this is a stub, rewrite the call into an unconditional branch
 130     // instruction so that two return addresses are not pushed onto the stack
 131     // when the requested function finally gets called.  This also makes the
 132     // 0xCD byte (interrupt) dead, so the marker doesn't effect anything.
 133     ((unsigned char*)(intptr_t)RetAddr)[-1] = 0xE9;
 134   }
 135
 136   // Change the return address to reexecute the call instruction...
 137   *RetAddrLoc -= 5;
 138 }
 139
 140 TargetJITInfo::LazyResolverFn
 141 X86JITInfo::getLazyResolverFunction(JITCompilerFn F) {
 142   JITCompilerFunction = F;
 143   return X86CompilationCallback;
 144 }
 145
 146 void *X86JITInfo::emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) {
 147   if (Fn != X86CompilationCallback) {
 148     MCE.startFunctionStub(5);
 149     MCE.emitByte(0xE9);
 150     MCE.emitWord((intptr_t)Fn-MCE.getCurrentPCValue()-4);
 151     return MCE.finishFunctionStub(0);
 152   }
 153
 154   MCE.startFunctionStub(6);
 155   MCE.emitByte(0xE8);   // Call with 32 bit pc-rel destination...
 156
 157   MCE.emitWord((intptr_t)Fn-MCE.getCurrentPCValue()-4);
 158
 159   MCE.emitByte(0xCD);   // Interrupt - Just a marker identifying the stub!
 160   return MCE.finishFunctionStub(0);
 161 }
 162
 163 /// relocate - Before the JIT can run a block of code that has been emitted,
 164 /// it must rewrite the code to contain the actual addresses of any
 165 /// referenced global symbols.
 166 void X86JITInfo::relocate(void *Function, MachineRelocation *MR,
 167                           unsigned NumRelocs) {
 168   for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
 169     void *RelocPos = (char*)Function + MR->getMachineCodeOffset();
 170     intptr_t ResultPtr = (intptr_t)MR->getResultPointer();
 171     switch ((X86::RelocationType)MR->getRelocationType()) {
 172     case X86::reloc_pcrel_word:
 173       // PC relative relocation, add the relocated value to the value already in
 174       // memory, after we adjust it for where the PC is.
 175       ResultPtr = ResultPtr-(intptr_t)RelocPos-4;
 176       *((intptr_t*)RelocPos) += ResultPtr;
 177       break;
 178     case X86::reloc_absolute_word:
 179       // Absolute relocation, just add the relocated value to the value already
 180       // in memory.
 181       *((intptr_t*)RelocPos) += ResultPtr;
 182       break;
 183     }
 184   }
 185 }