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 "X86JITInfo.h"
  16 #include "X86Relocations.h"
  17 #include "X86Subtarget.h"
  18 #include "llvm/CodeGen/MachineCodeEmitter.h"
  19 #include "llvm/Config/alloca.h"
  20 #include <cstdlib>
  21 using namespace llvm;
  22
  23 #ifdef _MSC_VER
  24   extern "C" void *_AddressOfReturnAddress(void);
  25   #pragma intrinsic(_AddressOfReturnAddress)
  26 #endif
  27
  28 void X86JITInfo::replaceMachineCodeForFunction(void *Old, void *New) {
  29   unsigned char *OldByte = (unsigned char *)Old;
  30   *OldByte++ = 0xE9;                // Emit JMP opcode.
  31   unsigned *OldWord = (unsigned *)OldByte;
  32   unsigned NewAddr = (intptr_t)New;
  33   unsigned OldAddr = (intptr_t)OldWord;
  34   *OldWord = NewAddr - OldAddr - 4; // Emit PC-relative addr of New code.
  35 }
  36
  37
  38 /// JITCompilerFunction - This contains the address of the JIT function used to
  39 /// compile a function lazily.
  40 static TargetJITInfo::JITCompilerFn JITCompilerFunction;
  41
  42 // Get the ASMPREFIX for the current host.  This is often '_'.
  43 #ifndef __USER_LABEL_PREFIX__
  44 #define __USER_LABEL_PREFIX__
  45 #endif
  46 #define GETASMPREFIX2(X) #X
  47 #define GETASMPREFIX(X) GETASMPREFIX2(X)
  48 #define ASMPREFIX GETASMPREFIX(__USER_LABEL_PREFIX__)
  49
  50 #if defined(__APPLE__)
  51 # define CFI(x)
  52 #else
  53 # define CFI(x) x
  54 #endif
  55
  56 // Provide a wrapper for X86CompilationCallback2 that saves non-traditional
  57 // callee saved registers, for the fastcc calling convention.
  58 extern "C" {
  59 #if defined(__x86_64__)
  60   // No need to save EAX/EDX for X86-64.
  61   void X86CompilationCallback(void);
  62   asm(
  63     ".text\n"
  64     ".align 8\n"
  65     ".globl " ASMPREFIX "X86CompilationCallback\n"
  66   ASMPREFIX "X86CompilationCallback:\n"
  67     CFI(".cfi_startproc\n")
  68     // Save RBP
  69     "pushq   %rbp\n"
  70     CFI(".cfi_def_cfa_offset 16\n")
  71     CFI(".cfi_offset %rbp, -16\n")
  72     // Save RSP
  73     "movq    %rsp, %rbp\n"
  74     CFI(".cfi_def_cfa_register %rbp\n")
  75     // Save all int arg registers
  76     "pushq   %rdi\n"
  77     CFI(".cfi_rel_offset %rdi, 0\n")
  78     "pushq   %rsi\n"
  79     CFI(".cfi_rel_offset %rsi, 8\n")
  80     "pushq   %rdx\n"
  81     CFI(".cfi_rel_offset %rdx, 16\n")
  82     "pushq   %rcx\n"
  83     CFI(".cfi_rel_offset %rcx, 24\n")
  84     "pushq   %r8\n"
  85     CFI(".cfi_rel_offset %r8, 32\n")
  86     "pushq   %r9\n"
  87     CFI(".cfi_rel_offset %r9, 40\n")
  88     // Align stack on 16-byte boundary. ESP might not be properly aligned
  89     // (8 byte) if this is called from an indirect stub.
  90     "andq    $-16, %rsp\n"
  91     // Save all XMM arg registers
  92     "subq    $128, %rsp\n"
  93     "movaps  %xmm0, (%rsp)\n"
  94     "movaps  %xmm1, 16(%rsp)\n"
  95     "movaps  %xmm2, 32(%rsp)\n"
  96     "movaps  %xmm3, 48(%rsp)\n"
  97     "movaps  %xmm4, 64(%rsp)\n"
  98     "movaps  %xmm5, 80(%rsp)\n"
  99     "movaps  %xmm6, 96(%rsp)\n"
 100     "movaps  %xmm7, 112(%rsp)\n"
 101     // JIT callee
 102     "movq    %rbp, %rdi\n"    // Pass prev frame and return address
 103     "movq    8(%rbp), %rsi\n"
 104     "call    " ASMPREFIX "X86CompilationCallback2\n"
 105     // Restore all XMM arg registers
 106     "movaps  112(%rsp), %xmm7\n"
 107     "movaps  96(%rsp), %xmm6\n"
 108     "movaps  80(%rsp), %xmm5\n"
 109     "movaps  64(%rsp), %xmm4\n"
 110     "movaps  48(%rsp), %xmm3\n"
 111     "movaps  32(%rsp), %xmm2\n"
 112     "movaps  16(%rsp), %xmm1\n"
 113     "movaps  (%rsp), %xmm0\n"
 114     // Restore RSP
 115     "movq    %rbp, %rsp\n"
 116     CFI(".cfi_def_cfa_register esp\n")
 117     // Restore all int arg registers
 118     "subq    $48, %rsp\n"
 119     CFI(".cfi_adjust_cfa_offset 48\n")
 120     "popq    %r9\n"
 121     CFI(".cfi_adjust_cfa_offset -8\n")
 122     CFI(".cfi_restore %r9\n")
 123     "popq    %r8\n"
 124     CFI(".cfi_adjust_cfa_offset -8\n")
 125     CFI(".cfi_restore %r8\n")
 126     "popq    %rcx\n"
 127     CFI(".cfi_adjust_cfa_offset -8\n")
 128     CFI(".cfi_restore %rcx\n")
 129     "popq    %rdx\n"
 130     CFI(".cfi_adjust_cfa_offset -8\n")
 131     CFI(".cfi_restore %rdx\n")
 132     "popq    %rsi\n"
 133     CFI(".cfi_adjust_cfa_offset -8\n")
 134     CFI(".cfi_restore %rsi\n")
 135     "popq    %rdi\n"
 136     CFI(".cfi_adjust_cfa_offset -8\n")
 137     CFI(".cfi_restore %rdi\n")
 138     // Restore RBP
 139     "popq    %rbp\n"
 140     CFI(".cfi_adjust_cfa_offset -8\n")
 141     CFI(".cfi_restore %rbp\n")
 142     "ret\n"
 143     CFI(".cfi_endproc\n")
 144   );
 145 #elif defined(__i386__) || defined(i386) || defined(_M_IX86)
 146 #ifndef _MSC_VER
 147   void X86CompilationCallback(void);
 148   asm(
 149     ".text\n"
 150     ".align 8\n"
 151     ".globl " ASMPREFIX  "X86CompilationCallback\n"
 152   ASMPREFIX "X86CompilationCallback:\n"
 153     CFI(".cfi_startproc\n")
 154     "pushl   %ebp\n"
 155     CFI(".cfi_def_cfa_offset 8\n")
 156     CFI(".cfi_offset %ebp, -8\n")
 157     "movl    %esp, %ebp\n"    // Standard prologue
 158     CFI(".cfi_def_cfa_register %ebp\n")
 159     "pushl   %eax\n"
 160     CFI(".cfi_rel_offset %eax, 0\n")
 161     "pushl   %edx\n"          // Save EAX/EDX/ECX
 162     CFI(".cfi_rel_offset %edx, 4\n")
 163     "pushl   %ecx\n"
 164     CFI(".cfi_rel_offset %ecx, 8\n")
 165 #if defined(__APPLE__)
 166     "andl    $-16, %esp\n"    // Align ESP on 16-byte boundary
 167 #endif
 168     "subl    $16, %esp\n"
 169     "movl    4(%ebp), %eax\n" // Pass prev frame and return address
 170     "movl    %eax, 4(%esp)\n"
 171     "movl    %ebp, (%esp)\n"
 172     "call    " ASMPREFIX "X86CompilationCallback2\n"
 173     "movl    %ebp, %esp\n"    // Restore ESP
 174     CFI(".cfi_def_cfa_register %esp\n")
 175     "subl    $12, %esp\n"
 176     CFI(".cfi_adjust_cfa_offset 12\n")
 177     "popl    %ecx\n"
 178     CFI(".cfi_adjust_cfa_offset -4\n")
 179     CFI(".cfi_restore %ecx\n")
 180     "popl    %edx\n"
 181     CFI(".cfi_adjust_cfa_offset -4\n")
 182     CFI(".cfi_restore %edx\n")
 183     "popl    %eax\n"
 184     CFI(".cfi_adjust_cfa_offset -4\n")
 185     CFI(".cfi_restore %eax\n")
 186     "popl    %ebp\n"
 187     CFI(".cfi_adjust_cfa_offset -4\n")
 188     CFI(".cfi_restore %ebp\n")
 189     "ret\n"
 190     CFI(".cfi_endproc\n")
 191   );
 192
 193   // Same as X86CompilationCallback but also saves XMM argument registers.
 194   void X86CompilationCallback_SSE(void);
 195   asm(
 196     ".text\n"
 197     ".align 8\n"
 198     ".globl " ASMPREFIX  "X86CompilationCallback_SSE\n"
 199   ASMPREFIX "X86CompilationCallback_SSE:\n"
 200     CFI(".cfi_startproc\n")
 201     "pushl   %ebp\n"
 202     CFI(".cfi_def_cfa_offset 8\n")
 203     CFI(".cfi_offset %ebp, -8\n")
 204     "movl    %esp, %ebp\n"    // Standard prologue
 205     CFI(".cfi_def_cfa_register %ebp\n")
 206     "pushl   %eax\n"
 207     CFI(".cfi_rel_offset %eax, 0\n")
 208     "pushl   %edx\n"          // Save EAX/EDX/ECX
 209     CFI(".cfi_rel_offset %edx, 4\n")
 210     "pushl   %ecx\n"
 211     CFI(".cfi_rel_offset %ecx, 8\n")
 212     "andl    $-16, %esp\n"    // Align ESP on 16-byte boundary
 213     // Save all XMM arg registers
 214     "subl    $64, %esp\n"
 215     // FIXME: provide frame move information for xmm registers.
 216     // This can be tricky, because CFA register is ebp (unaligned)
 217     // and we need to produce offsets relative to it.
 218     "movaps  %xmm0, (%esp)\n"
 219     "movaps  %xmm1, 16(%esp)\n"
 220     "movaps  %xmm2, 32(%esp)\n"
 221     "movaps  %xmm3, 48(%esp)\n"
 222     "subl    $16, %esp\n"
 223     "movl    4(%ebp), %eax\n" // Pass prev frame and return address
 224     "movl    %eax, 4(%esp)\n"
 225     "movl    %ebp, (%esp)\n"
 226     "call    " ASMPREFIX "X86CompilationCallback2\n"
 227     "addl    $16, %esp\n"
 228     "movaps  48(%esp), %xmm3\n"
 229     CFI(".cfi_restore %xmm3\n")
 230     "movaps  32(%esp), %xmm2\n"
 231     CFI(".cfi_restore %xmm2\n")
 232     "movaps  16(%esp), %xmm1\n"
 233     CFI(".cfi_restore %xmm1\n")
 234     "movaps  (%esp), %xmm0\n"
 235     CFI(".cfi_restore %xmm0\n")
 236     "movl    %ebp, %esp\n"    // Restore ESP
 237     CFI(".cfi_def_cfa_register esp\n")
 238     "subl    $12, %esp\n"
 239     CFI(".cfi_adjust_cfa_offset 12\n")
 240     "popl    %ecx\n"
 241     CFI(".cfi_adjust_cfa_offset -4\n")
 242     CFI(".cfi_restore %ecx\n")
 243     "popl    %edx\n"
 244     CFI(".cfi_adjust_cfa_offset -4\n")
 245     CFI(".cfi_restore %edx\n")
 246     "popl    %eax\n"
 247     CFI(".cfi_adjust_cfa_offset -4\n")
 248     CFI(".cfi_restore %eax\n")
 249     "popl    %ebp\n"
 250     CFI(".cfi_adjust_cfa_offset -4\n")
 251     CFI(".cfi_restore %ebp\n")
 252     "ret\n"
 253     CFI(".cfi_endproc\n")
 254   );
 255 #else
 256   void X86CompilationCallback2(void);
 257
 258   _declspec(naked) void X86CompilationCallback(void) {
 259     __asm {
 260       push  eax
 261       push  edx
 262       push  ecx
 263       call  X86CompilationCallback2
 264       pop   ecx
 265       pop   edx
 266       pop   eax
 267       ret
 268     }
 269   }
 270 #endif // _MSC_VER
 271
 272 #else // Not an i386 host
 273   void X86CompilationCallback() {
 274     assert(0 && "Cannot call X86CompilationCallback() on a non-x86 arch!\n");
 275     abort();
 276   }
 277 #endif
 278 }
 279
 280 /// X86CompilationCallback - This is the target-specific function invoked by the
 281 /// function stub when we did not know the real target of a call.  This function
 282 /// must locate the start of the stub or call site and pass it into the JIT
 283 /// compiler function.
 284 #ifdef _MSC_VER
 285 extern "C" void X86CompilationCallback2() {
 286   assert(sizeof(size_t) == 4); // FIXME: handle Win64
 287   intptr_t *RetAddrLoc = (intptr_t *)_AddressOfReturnAddress();
 288   RetAddrLoc += 4;  // skip over ret addr, edx, eax, ecx
 289   intptr_t RetAddr = *RetAddrLoc;
 290 #else
 291 extern "C" void X86CompilationCallback2(intptr_t *StackPtr, intptr_t RetAddr) {
 292   intptr_t *RetAddrLoc = &StackPtr[1];
 293 #endif
 294   assert(*RetAddrLoc == RetAddr &&
 295          "Could not find return address on the stack!");
 296
 297   // It's a stub if there is an interrupt marker after the call.
 298   bool isStub = ((unsigned char*)RetAddr)[0] == 0xCD;
 299
 300   // The call instruction should have pushed the return value onto the stack...
 301 #ifdef __x86_64__
 302   RetAddr--;     // Backtrack to the reference itself...
 303 #else
 304   RetAddr -= 4;  // Backtrack to the reference itself...
 305 #endif
 306
 307 #if 0
 308   DOUT << "In callback! Addr=" << (void*)RetAddr
 309        << " ESP=" << (void*)StackPtr
 310        << ": Resolving call to function: "
 311        << TheVM->getFunctionReferencedName((void*)RetAddr) << "\n";
 312 #endif
 313
 314   // Sanity check to make sure this really is a call instruction.
 315 #ifdef __x86_64__
 316   assert(((unsigned char*)RetAddr)[-2] == 0x41 &&"Not a call instr!");
 317   assert(((unsigned char*)RetAddr)[-1] == 0xFF &&"Not a call instr!");
 318 #else
 319   assert(((unsigned char*)RetAddr)[-1] == 0xE8 &&"Not a call instr!");
 320 #endif
 321
 322   intptr_t NewVal = (intptr_t)JITCompilerFunction((void*)RetAddr);
 323
 324   // Rewrite the call target... so that we don't end up here every time we
 325   // execute the call.
 326 #ifdef __x86_64__
 327   *(intptr_t *)(RetAddr - 0xa) = NewVal;
 328 #else
 329   *(intptr_t *)RetAddr = (intptr_t)(NewVal-RetAddr-4);
 330 #endif
 331
 332   if (isStub) {
 333     // If this is a stub, rewrite the call into an unconditional branch
 334     // instruction so that two return addresses are not pushed onto the stack
 335     // when the requested function finally gets called.  This also makes the
 336     // 0xCD byte (interrupt) dead, so the marker doesn't effect anything.
 337 #ifdef __x86_64__
 338     ((unsigned char*)RetAddr)[0] = (2 | (4 << 3) | (3 << 6));
 339 #else
 340     ((unsigned char*)RetAddr)[-1] = 0xE9;
 341 #endif
 342   }
 343
 344   // Change the return address to reexecute the call instruction...
 345 #ifdef __x86_64__
 346   *RetAddrLoc -= 0xd;
 347 #else
 348   *RetAddrLoc -= 5;
 349 #endif
 350 }
 351
 352 TargetJITInfo::LazyResolverFn
 353 X86JITInfo::getLazyResolverFunction(JITCompilerFn F) {
 354   JITCompilerFunction = F;
 355
 356 #if (defined(__i386__) || defined(i386) || defined(_M_IX86)) && \
 357   !defined(_MSC_VER) && !defined(__x86_64__)
 358   unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
 359   union {
 360     unsigned u[3];
 361     char     c[12];
 362   } text;
 363
 364   if (!X86::GetCpuIDAndInfo(0, &EAX, text.u+0, text.u+2, text.u+1)) {
 365     // FIXME: support for AMD family of processors.
 366     if (memcmp(text.c, "GenuineIntel", 12) == 0) {
 367       X86::GetCpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX);
 368       if ((EDX >> 25) & 0x1)
 369         return X86CompilationCallback_SSE;
 370     }
 371   }
 372 #endif
 373
 374   return X86CompilationCallback;
 375 }
 376
 377 void *X86JITInfo::emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) {
 378   // Note, we cast to intptr_t here to silence a -pedantic warning that
 379   // complains about casting a function pointer to a normal pointer.
 380 #if (defined(__i386__) || defined(i386) || defined(_M_IX86)) && \
 381   !defined(_MSC_VER) && !defined(__x86_64__)
 382   bool NotCC = (Fn != (void*)(intptr_t)X86CompilationCallback &&
 383                 Fn != (void*)(intptr_t)X86CompilationCallback_SSE);
 384 #else
 385   bool NotCC = Fn != (void*)(intptr_t)X86CompilationCallback;
 386 #endif
 387   if (NotCC) {
 388 #ifdef __x86_64__
 389     MCE.startFunctionStub(13, 4);
 390     MCE.emitByte(0x49);          // REX prefix
 391     MCE.emitByte(0xB8+2);        // movabsq r10
 392     MCE.emitWordLE(((unsigned *)&Fn)[0]);
 393     MCE.emitWordLE(((unsigned *)&Fn)[1]);
 394     MCE.emitByte(0x41);          // REX prefix
 395     MCE.emitByte(0xFF);          // jmpq *r10
 396     MCE.emitByte(2 | (4 << 3) | (3 << 6));
 397 #else
 398     MCE.startFunctionStub(5, 4);
 399     MCE.emitByte(0xE9);
 400     MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4);
 401 #endif
 402     return MCE.finishFunctionStub(0);
 403   }
 404
 405 #ifdef __x86_64__
 406   MCE.startFunctionStub(14, 4);
 407   MCE.emitByte(0x49);          // REX prefix
 408   MCE.emitByte(0xB8+2);        // movabsq r10
 409   MCE.emitWordLE(((unsigned *)&Fn)[0]);
 410   MCE.emitWordLE(((unsigned *)&Fn)[1]);
 411   MCE.emitByte(0x41);          // REX prefix
 412   MCE.emitByte(0xFF);          // callq *r10
 413   MCE.emitByte(2 | (2 << 3) | (3 << 6));
 414 #else
 415   MCE.startFunctionStub(6, 4);
 416   MCE.emitByte(0xE8);   // Call with 32 bit pc-rel destination...
 417
 418   MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4);
 419 #endif
 420
 421   MCE.emitByte(0xCD);   // Interrupt - Just a marker identifying the stub!
 422   return MCE.finishFunctionStub(0);
 423 }
 424
 425 /// relocate - Before the JIT can run a block of code that has been emitted,
 426 /// it must rewrite the code to contain the actual addresses of any
 427 /// referenced global symbols.
 428 void X86JITInfo::relocate(void *Function, MachineRelocation *MR,
 429                           unsigned NumRelocs, unsigned char* GOTBase) {
 430   for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
 431     void *RelocPos = (char*)Function + MR->getMachineCodeOffset();
 432     intptr_t ResultPtr = (intptr_t)MR->getResultPointer();
 433     switch ((X86::RelocationType)MR->getRelocationType()) {
 434     case X86::reloc_pcrel_word: {
 435       // PC relative relocation, add the relocated value to the value already in
 436       // memory, after we adjust it for where the PC is.
 437       ResultPtr = ResultPtr-(intptr_t)RelocPos-4-MR->getConstantVal();
 438       *((unsigned*)RelocPos) += (unsigned)ResultPtr;
 439       break;
 440     }
 441     case X86::reloc_absolute_word:
 442       // Absolute relocation, just add the relocated value to the value already
 443       // in memory.
 444       *((unsigned*)RelocPos) += (unsigned)ResultPtr;
 445       break;
 446     case X86::reloc_absolute_dword:
 447       *((intptr_t*)RelocPos) += ResultPtr;
 448       break;
 449     }
 450   }
 451 }