Refactored JIT codegen for mingw32. Now we're using standart relocation

type for distinguish JIT & non-JIT instead of "dirty" hacks :)

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@32745 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp
index ae379cdc222380351aca4339c0d1bf37cb247dc8..d92c699012b82726a002a30e05d5faadeaaa929d 100644 (file)
--- a/lib/Target/X86/X86ISelLowering.cpp
+++ b/lib/Target/X86/X86ISelLowering.cpp
@@ -664,8 +664,10 @@ SDOperand X86TargetLowering::LowerCCCCallTo(SDOperand Op, SelectionDAG &DAG) {
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {

-    // We should use extra load for direct calls to dllimported functions
-    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(), true))
+    // We should use extra load for direct calls to dllimported functions in
+    // non-JIT mode.
+    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(),
+                                        getTargetMachine(), true))

       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());


@@ -1201,8 +1203,10 @@ X86TargetLowering::LowerX86_64CCCCallTo(SDOperand Op, SelectionDAG &DAG) {
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {

-    // We should use extra load for direct calls to dllimported functions
-    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(), true))
+    // We should use extra load for direct calls to dllimported functions in
+    // non-JIT mode.
+    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(),
+                                        getTargetMachine(), true))

       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());


@@ -1698,8 +1702,10 @@ SDOperand X86TargetLowering::LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG,
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {

-    // We should use extra load for direct calls to dllimported functions
-    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(), true))
+    // We should use extra load for direct calls to dllimported functions in
+    // non-JIT mode.
+    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(),
+                                        getTargetMachine(), true))

       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());


@@ -1996,8 +2002,10 @@ SDOperand X86TargetLowering::LowerStdCallCCCallTo(SDOperand Op,
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {
   // If the callee is a GlobalAddress node (quite common, every direct call is)
   // turn it into a TargetGlobalAddress node so that legalize doesn't hack it.
   if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee)) {

-    // We should use extra load for direct calls to dllimported functions
-    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(), true))
+    // We should use extra load for direct calls to dllimported functions in
+    // non-JIT mode.
+    if (!Subtarget->GVRequiresExtraLoad(G->getGlobal(),
+                                        getTargetMachine(), true))

       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());
       Callee = DAG.getTargetGlobalAddress(G->getGlobal(), getPointerTy());
   } else if (ExternalSymbolSDNode *S = dyn_cast<ExternalSymbolSDNode>(Callee))
     Callee = DAG.getTargetExternalSymbol(S->getSymbol(), getPointerTy());


@@ -3868,17 +3876,14 @@ X86TargetLowering::LowerGlobalAddress(SDOperand Op, SelectionDAG &DAG) {
       Result = DAG.getNode(ISD::ADD, getPointerTy(),
                            DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
                            Result);
       Result = DAG.getNode(ISD::ADD, getPointerTy(),
                            DAG.getNode(X86ISD::GlobalBaseReg, getPointerTy()),
                            Result);

-
-    // For Darwin, external and weak symbols are indirect, so we want to load
-    // the value at address GV, not the value of GV itself. This means that
-    // the GlobalAddress must be in the base or index register of the address,
-    // not the GV offset field.
-    if (getTargetMachine().getRelocationModel() != Reloc::Static &&
-        Subtarget->GVRequiresExtraLoad(GV, false))
-      Result = DAG.getLoad(getPointerTy(), DAG.getEntryNode(), Result, NULL, 0);
-  } else if (Subtarget->GVRequiresExtraLoad(GV, false)) {
-    Result = DAG.getLoad(getPointerTy(), DAG.getEntryNode(), Result, NULL, 0);

   }
   }

+  
+  // For Darwin & Mingw32, external and weak symbols are indirect, so we want to
+  // load the value at address GV, not the value of GV itself. This means that
+  // the GlobalAddress must be in the base or index register of the address, not
+  // the GV offset field. Platform check is inside GVRequiresExtraLoad() call
+  if (Subtarget->GVRequiresExtraLoad(GV, getTargetMachine(), false))
+    Result = DAG.getLoad(getPointerTy(), DAG.getEntryNode(), Result, NULL, 0);

 
   return Result;
 }
 
   return Result;
 }


@@ -5010,9 +5015,8 @@ bool X86TargetLowering::isLegalAddressImmediate(GlobalValue *GV) const {
   if (Subtarget->is64Bit() &&
       getTargetMachine().getCodeModel() != CodeModel::Small)
     return false;
   if (Subtarget->is64Bit() &&
       getTargetMachine().getCodeModel() != CodeModel::Small)
     return false;

-  Reloc::Model RModel = getTargetMachine().getRelocationModel();
-  return (RModel == Reloc::Static) ||
-    !Subtarget->GVRequiresExtraLoad(GV, false);
+  
+  return (!Subtarget->GVRequiresExtraLoad(GV, getTargetMachine(), false));

 }
 
 /// isShuffleMaskLegal - Targets can use this to indicate that they only
 }
 
 /// isShuffleMaskLegal - Targets can use this to indicate that they only

diff --git a/lib/Target/X86/X86Subtarget.cpp b/lib/Target/X86/X86Subtarget.cpp
index 4ab87134274ddce125bcc013a65cbcd53f544be1..05965c24cddc100610770494034f916fcb894e67 100644 (file)
--- a/lib/Target/X86/X86Subtarget.cpp
+++ b/lib/Target/X86/X86Subtarget.cpp
@@ -15,6 +15,7 @@
 #include "X86GenSubtarget.inc"
 #include "llvm/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "X86GenSubtarget.inc"
 #include "llvm/Module.h"
 #include "llvm/Support/CommandLine.h"

+#include "llvm/Target/TargetMachine.h"

 using namespace llvm;
 
 cl::opt<X86Subtarget::AsmWriterFlavorTy>
 using namespace llvm;
 
 cl::opt<X86Subtarget::AsmWriterFlavorTy>


@@ -31,9 +32,10 @@ AsmWriterFlavor("x86-asm-syntax", cl::init(X86Subtarget::unset),
 /// value of GV itself. This means that the GlobalAddress must be in the base
 /// or index register of the address, not the GV offset field.
 bool X86Subtarget::GVRequiresExtraLoad(const GlobalValue* GV,
 /// value of GV itself. This means that the GlobalAddress must be in the base
 /// or index register of the address, not the GV offset field.
 bool X86Subtarget::GVRequiresExtraLoad(const GlobalValue* GV,

+                                       const TargetMachine& TM,

                                        bool isDirectCall) const
 {
                                        bool isDirectCall) const
 {

-  if (GenerateExtraLoadsForGVs)
+  if (TM.getRelocationModel() != Reloc::Static)

     if (isTargetDarwin()) {
       return (!isDirectCall &&
               (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||
     if (isTargetDarwin()) {
       return (!isDirectCall &&
               (GV->hasWeakLinkage() || GV->hasLinkOnceLinkage() ||


@@ -208,16 +210,6 @@ static const char *GetCurrentX86CPU() {
   }
 }
 
   }
 }
 

-/// SetJITMode - This is called to inform the subtarget info that we are
-/// producing code for the JIT.
-void X86Subtarget::SetJITMode()
-{
-  // JIT mode doesn't want extra loads for dllimported symbols, it knows exactly
-  // where everything is.
-  if (isTargetCygwin())
-    GenerateExtraLoadsForGVs = false;
-}
-

 X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit)
   : AsmFlavor(AsmWriterFlavor)
   , X86SSELevel(NoMMXSSE)
 X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit)
   : AsmFlavor(AsmWriterFlavor)
   , X86SSELevel(NoMMXSSE)


@@ -226,7 +218,6 @@ X86Subtarget::X86Subtarget(const Module &M, const std::string &FS, bool is64Bit)
   // FIXME: this is a known good value for Yonah. How about others?
   , MinRepStrSizeThreshold(128)
   , Is64Bit(is64Bit)
   // FIXME: this is a known good value for Yonah. How about others?
   , MinRepStrSizeThreshold(128)
   , Is64Bit(is64Bit)

-  , GenerateExtraLoadsForGVs(true)

   , TargetType(isELF) { // Default to ELF unless otherwise specified.
 
   // Determine default and user specified characteristics
   , TargetType(isELF) { // Default to ELF unless otherwise specified.
 
   // Determine default and user specified characteristics

diff --git a/lib/Target/X86/X86Subtarget.h b/lib/Target/X86/X86Subtarget.h
index 4a3bc342ee263ea69a9280874703f2443816417c..ba43e385dae9ab9c2653d411a9dc20fd00767a29 100644 (file)
--- a/lib/Target/X86/X86Subtarget.h
+++ b/lib/Target/X86/X86Subtarget.h
@@ -21,6 +21,7 @@
 namespace llvm {
 class Module;
 class GlobalValue;
 namespace llvm {
 class Module;
 class GlobalValue;

+class TargetMachine;

 
 class X86Subtarget : public TargetSubtarget {
 public:
 
 class X86Subtarget : public TargetSubtarget {
 public:


@@ -61,9 +62,6 @@ private:
   /// pointer size is 64 bit.
   bool Is64Bit;
 
   /// pointer size is 64 bit.
   bool Is64Bit;
 

-  /// GenerateExtraLoadsForGVs - True if we should generate extra loads for
-  /// indirect symbols (e.g. dllimported symbols on windows).
-  bool GenerateExtraLoadsForGVs;

 public:
   enum {
     isELF, isCygwin, isDarwin, isWindows
 public:
   enum {
     isELF, isCygwin, isDarwin, isWindows


@@ -114,11 +112,9 @@ public:
   /// symbols are indirect, loading the value at address GV rather then the
   /// value of GV itself. This means that the GlobalAddress must be in the base
   /// or index register of the address, not the GV offset field.
   /// symbols are indirect, loading the value at address GV rather then the
   /// value of GV itself. This means that the GlobalAddress must be in the base
   /// or index register of the address, not the GV offset field.

-  bool GVRequiresExtraLoad(const GlobalValue* GV, bool isDirectCall) const;
+  bool GVRequiresExtraLoad(const GlobalValue* GV, const TargetMachine& TM,
+                           bool isDirectCall) const;

 
 

-  /// SetJITMode - This is called to inform the subtarget info that we are
-  /// producing code for the JIT.
-  void SetJITMode();

 };
 
 namespace X86 {
 };
 
 namespace X86 {

diff --git a/lib/Target/X86/X86TargetMachine.cpp b/lib/Target/X86/X86TargetMachine.cpp
index ad0bf5510c1cf4e1df724f88fb0e63182c8bc3f8..9dee7c897d0948833488e6ccdd0c4daff5be5ba6 100644 (file)
--- a/lib/Target/X86/X86TargetMachine.cpp
+++ b/lib/Target/X86/X86TargetMachine.cpp
@@ -115,7 +115,7 @@ X86TargetMachine::X86TargetMachine(const Module &M, const std::string &FS, bool
               Subtarget.getStackAlignment(), Subtarget.is64Bit() ? -8 : -4),
     InstrInfo(*this), JITInfo(*this), TLInfo(*this) {
   if (getRelocationModel() == Reloc::Default)
               Subtarget.getStackAlignment(), Subtarget.is64Bit() ? -8 : -4),
     InstrInfo(*this), JITInfo(*this), TLInfo(*this) {
   if (getRelocationModel() == Reloc::Default)

-    if (Subtarget.isTargetDarwin())
+    if (Subtarget.isTargetDarwin() || Subtarget.isTargetCygwin())

       setRelocationModel(Reloc::DynamicNoPIC);
     else
       setRelocationModel(Reloc::Static);
       setRelocationModel(Reloc::DynamicNoPIC);
     else
       setRelocationModel(Reloc::Static);


@@ -167,9 +167,6 @@ bool X86TargetMachine::addCodeEmitter(FunctionPassManager &PM, bool Fast,
   if (Subtarget.is64Bit())
     setCodeModel(CodeModel::Large);
 
   if (Subtarget.is64Bit())
     setCodeModel(CodeModel::Large);
 

-  // Inform the subtarget that we are in JIT mode.
-  Subtarget.SetJITMode(); 
-  

   PM.add(createX86CodeEmitterPass(*this, MCE));
   return false;
 }
   PM.add(createX86CodeEmitterPass(*this, MCE));
   return false;
 }