formatting change, reduce indentation. No functionality change.

[oota-llvm.git] / lib / Target / X86 / X86JITInfo.cpp

diff --git a/lib/Target/X86/X86JITInfo.cpp b/lib/Target/X86/X86JITInfo.cpp
index f8761dc87e2c8721b1d815f94f510939af7a34a5..4bbccf380c3fae347612a75d9d23e779b42a7866 100644 (file)
--- a/lib/Target/X86/X86JITInfo.cpp
+++ b/lib/Target/X86/X86JITInfo.cpp
@@ -59,6 +59,16 @@ static TargetJITInfo::JITCompilerFn JITCompilerFunction;
 #define ASMCALLSUFFIX
 #endif
 
+// For ELF targets, use a .size and .type directive, to let tools
+// know the extent of functions defined in assembler.
+#if defined(__ELF__)
+# define SIZE(sym) ".size " #sym ", . - " #sym "\n"
+# define TYPE_FUNCTION(sym) ".type " #sym ", @function\n"
+#else
+# define SIZE(sym)
+# define TYPE_FUNCTION(sym)
+#endif
+
 // Provide a convenient way for disabling usage of CFI directives.
 // This is needed for old/broken assemblers (for example, gas on
 // Darwin is pretty old and doesn't support these directives)
@@ -82,6 +92,7 @@ extern "C" {
     ".text\n"
     ".align 8\n"
     ".globl " ASMPREFIX "X86CompilationCallback\n"
+    TYPE_FUNCTION(X86CompilationCallback)
   ASMPREFIX "X86CompilationCallback:\n"
     CFI(".cfi_startproc\n")
     // Save RBP
@@ -160,6 +171,7 @@ extern "C" {
     CFI(".cfi_restore %rbp\n")
     "ret\n"
     CFI(".cfi_endproc\n")
+    SIZE(X86CompilationCallback)
   );
 # else
   // No inline assembler support on this platform. The routine is in external
@@ -173,7 +185,8 @@ extern "C" {
   asm(
     ".text\n"
     ".align 8\n"
-    ".globl " ASMPREFIX  "X86CompilationCallback\n"
+    ".globl " ASMPREFIX "X86CompilationCallback\n"
+    TYPE_FUNCTION(X86CompilationCallback)
   ASMPREFIX "X86CompilationCallback:\n"
     CFI(".cfi_startproc\n")
     "pushl   %ebp\n"
@@ -213,6 +226,7 @@ extern "C" {
     CFI(".cfi_restore %ebp\n")
     "ret\n"
     CFI(".cfi_endproc\n")
+    SIZE(X86CompilationCallback)
   );
 
   // Same as X86CompilationCallback but also saves XMM argument registers.
@@ -220,7 +234,8 @@ extern "C" {
   asm(
     ".text\n"
     ".align 8\n"
-    ".globl " ASMPREFIX  "X86CompilationCallback_SSE\n"
+    ".globl " ASMPREFIX "X86CompilationCallback_SSE\n"
+    TYPE_FUNCTION(X86CompilationCallback_SSE)
   ASMPREFIX "X86CompilationCallback_SSE:\n"
     CFI(".cfi_startproc\n")
     "pushl   %ebp\n"
@@ -276,6 +291,7 @@ extern "C" {
     CFI(".cfi_restore %ebp\n")
     "ret\n"
     CFI(".cfi_endproc\n")
+    SIZE(X86CompilationCallback_SSE)
   );
 # else
   void X86CompilationCallback2(intptr_t *StackPtr, intptr_t RetAddr);
@@ -312,7 +328,7 @@ extern "C" {
 #endif
 }
 
-/// X86CompilationCallback - This is the target-specific function invoked by the
+/// X86CompilationCallback2 - This is the target-specific function invoked by the
 /// function stub when we did not know the real target of a call.  This function
 /// must locate the start of the stub or call site and pass it into the JIT
 /// compiler function.
@@ -413,17 +429,17 @@ X86JITInfo::getLazyResolverFunction(JITCompilerFn F) {
   return X86CompilationCallback;
 }
 
-void *X86JITInfo::emitGlobalValueLazyPtr(const GlobalValue* GV, void *ptr,
-                                         MachineCodeEmitter &MCE) {
+void *X86JITInfo::emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr,
+                                             MachineCodeEmitter &MCE) {
 #if defined (X86_64_JIT)
-  MCE.startFunctionStub(GV, 8, 8);
+  MCE.startGVStub(GV, 8, 8);
   MCE.emitWordLE((unsigned)(intptr_t)ptr);
   MCE.emitWordLE((unsigned)(((intptr_t)ptr) >> 32));
 #else
-  MCE.startFunctionStub(GV, 4, 4);
+  MCE.startGVStub(GV, 4, 4);
   MCE.emitWordLE((intptr_t)ptr);
 #endif
-  return MCE.finishFunctionStub(GV);
+  return MCE.finishGVStub(GV);
 }
 
 void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn,
@@ -438,7 +454,7 @@ void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn,
 #endif
   if (NotCC) {
 #if defined (X86_64_JIT)
-    MCE.startFunctionStub(F, 13, 4);
+    MCE.startGVStub(F, 13, 4);
     MCE.emitByte(0x49);          // REX prefix
     MCE.emitByte(0xB8+2);        // movabsq r10
     MCE.emitWordLE((unsigned)(intptr_t)Fn);
@@ -447,15 +463,15 @@ void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn,
     MCE.emitByte(0xFF);          // jmpq *r10
     MCE.emitByte(2 | (4 << 3) | (3 << 6));
 #else
-    MCE.startFunctionStub(F, 5, 4);
+    MCE.startGVStub(F, 5, 4);
     MCE.emitByte(0xE9);
     MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4);
 #endif
-    return MCE.finishFunctionStub(F);
+    return MCE.finishGVStub(F);
   }
 
 #if defined (X86_64_JIT)
-  MCE.startFunctionStub(F, 14, 4);
+  MCE.startGVStub(F, 14, 4);
   MCE.emitByte(0x49);          // REX prefix
   MCE.emitByte(0xB8+2);        // movabsq r10
   MCE.emitWordLE((unsigned)(intptr_t)Fn);
@@ -464,19 +480,34 @@ void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn,
   MCE.emitByte(0xFF);          // callq *r10
   MCE.emitByte(2 | (2 << 3) | (3 << 6));
 #else
-  MCE.startFunctionStub(F, 6, 4);
+  MCE.startGVStub(F, 6, 4);
   MCE.emitByte(0xE8);   // Call with 32 bit pc-rel destination...
 
   MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4);
 #endif
 
   MCE.emitByte(0xCD);   // Interrupt - Just a marker identifying the stub!
-  return MCE.finishFunctionStub(F);
+  return MCE.finishGVStub(F);
+}
+
+void X86JITInfo::emitFunctionStubAtAddr(const Function* F, void *Fn, void *Stub,
+                                        MachineCodeEmitter &MCE) {
+  // Note, we cast to intptr_t here to silence a -pedantic warning that 
+  // complains about casting a function pointer to a normal pointer.
+  MCE.startGVStub(F, Stub, 5);
+  MCE.emitByte(0xE9);
+#if defined (X86_64_JIT)
+  assert(((((intptr_t)Fn-MCE.getCurrentPCValue()-5) << 32) >> 32) == 
+          ((intptr_t)Fn-MCE.getCurrentPCValue()-5) 
+         && "PIC displacement does not fit in displacement field!");
+#endif
+  MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4);
+  MCE.finishGVStub(F);
 }
 
 /// getPICJumpTableEntry - Returns the value of the jumptable entry for the
 /// specific basic block.
-intptr_t X86JITInfo::getPICJumpTableEntry(intptr_t BB, intptr_t Entry) {
+uintptr_t X86JITInfo::getPICJumpTableEntry(uintptr_t BB, uintptr_t Entry) {
 #if defined(X86_64_JIT)
   return BB - Entry;
 #else