X86-Windows: Emit an undefined global __fltused symbol when targeting Windows

if any floating point arguments are passed to an external function.

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

5 files changed, 60 insertions, 2 deletions

diff --git a/include/llvm/CodeGen/MachineModuleInfo.h b/include/llvm/CodeGen/MachineModuleInfo.h
index c0890f469b..4376478ec2 100644
--- a/include/llvm/CodeGen/MachineModuleInfo.h
+++ b/include/llvm/CodeGen/MachineModuleInfo.h
@@ -157,6 +157,11 @@ class MachineModuleInfo : public ImmutablePass {
   /// in this module.
   bool DbgInfoAvailable;
 
+  /// True if this module calls an external function with floating point
+  /// arguments. This is used to emit an undefined reference to fltused on
+  /// Windows targets.
+  bool CallsExternalFunctionWithFloatingPointArguments;
+
 public:
   static char ID; // Pass identification, replacement for typeid
 
@@ -211,7 +216,15 @@ public:
 
   bool callsUnwindInit() const { return CallsUnwindInit; }
   void setCallsUnwindInit(bool b) { CallsUnwindInit = b; }
-  
+
+  bool callsExternalFunctionWithFloatingPointArguments() const {
+    return CallsExternalFunctionWithFloatingPointArguments;
+  }
+
+  void setCallsExternalFunctionWithFloatingPointArguments(bool b) {
+    CallsExternalFunctionWithFloatingPointArguments = b;
+  }
+
   /// getFrameMoves - Returns a reference to a list of moves done in the current
   /// function's prologue.  Used to construct frame maps for debug and exception
   /// handling comsumers.
diff --git a/lib/CodeGen/MachineModuleInfo.cpp b/lib/CodeGen/MachineModuleInfo.cpp
index 347d8c7b2a..25dda0a4c3 100644
--- a/lib/CodeGen/MachineModuleInfo.cpp
+++ b/lib/CodeGen/MachineModuleInfo.cpp
@@ -256,7 +256,8 @@ void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
 MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI)
 : ImmutablePass(ID), Context(MAI),
   ObjFileMMI(0),
-  CurCallSite(0), CallsEHReturn(0), CallsUnwindInit(0), DbgInfoAvailable(false){
+  CurCallSite(0), CallsEHReturn(0), CallsUnwindInit(0), DbgInfoAvailable(false),
+  CallsExternalFunctionWithFloatingPointArguments(false) {
   // Always emit some info, by default "no personality" info.
   Personalities.push_back(NULL);
   AddrLabelSymbols = 0;
diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
index ebc6d3837e..04c424f672 100644
--- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -15,6 +15,7 @@
 #include "SDNodeDbgValue.h"
 #include "SelectionDAGBuilder.h"
 #include "llvm/ADT/BitVector.h"
+#include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/ConstantFolding.h"
@@ -5019,6 +5020,25 @@ void SelectionDAGBuilder::visitCall(const CallInst &I) {
       }
     }
 
+    // See if any floating point values are being passed to this external
+    // function. This is used to emit an undefined reference to fltused on
+    // Windows.
+    if (!F->hasLocalLinkage() && F->hasName()) {
+      MachineModuleInfo &MMI = DAG.getMachineFunction().getMMI();
+      for (unsigned i = 0, e = I.getNumArgOperands(); i != e &&
+                  !MMI.callsExternalFunctionWithFloatingPointArguments(); ++i) {
+        const Type* T = I.getArgOperand(i)->getType();
+        for (po_iterator<const Type*> i = po_begin(T),
+                                      e = po_end(T);
+                                      i != e; ++i) {
+          if (i->isFloatingPointTy()) {
+            MMI.setCallsExternalFunctionWithFloatingPointArguments(true);
+            break;
+          }
+        }
+      }
+    }
+
     // Check for well-known libc/libm calls.  If the function is internal, it
     // can't be a library call.
     if (!F->hasLocalLinkage() && F->hasName()) {
diff --git a/lib/Target/X86/X86AsmPrinter.cpp b/lib/Target/X86/X86AsmPrinter.cpp
index 85441b187e..c4fd7298b5 100644
--- a/lib/Target/X86/X86AsmPrinter.cpp
+++ b/lib/Target/X86/X86AsmPrinter.cpp
@@ -580,6 +580,13 @@ void X86AsmPrinter::EmitEndOfAsmFile(Module &M) {
     OutStreamer.EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
   }
 
+  if (Subtarget->isTargetWindows()
+   && !Subtarget->isTargetCygMing()
+   && MMI->callsExternalFunctionWithFloatingPointArguments()) {
+    MCSymbol *S = MMI->getContext().GetOrCreateSymbol(StringRef("__fltused"));
+    OutStreamer.EmitSymbolAttribute(S, MCSA_Global);
+  }
+
   if (Subtarget->isTargetCOFF()) {
     X86COFFMachineModuleInfo &COFFMMI =
       MMI->getObjFileInfo<X86COFFMachineModuleInfo>();
diff --git a/test/CodeGen/X86/fltused.ll b/test/CodeGen/X86/fltused.ll
new file mode 100644
index 0000000000..a896021290
--- /dev/null
+++ b/test/CodeGen/X86/fltused.ll
@@ -0,0 +1,17 @@
+; The purpose of this test to to verify that the fltused symbol is emitted when
+; any function is called with floating point arguments on Windows. And that it
+; is not emitted otherwise.
+
+; RUN: llc < %s -mtriple i686-pc-win32 | FileCheck %s
+
+@.str = private constant [4 x i8] c"%f\0A\00"
+
+define i32 @main() nounwind {
+entry:
+  %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([4 x i8]* @.str, i32 0, i32 0), double 1.000000e+000) nounwind
+  ret i32 0
+}
+
+declare i32 @printf(i8* nocapture, ...) nounwind
+
+; CHECK: .globl __fltused