[cfe-commits] r109768 - /cfe/trunk/lib/CodeGen/TargetInfo.cpp

[Chris Lattner]

Author: lattner
Date: Thu Jul 29 12:49:08 2010
New Revision: 109768

URL: http://llvm.org/viewvc/llvm-project?rev=109768&view=rev
Log:
start setting up infrastructure for passing multi-floats
as <2 x float> instead of as double.  The backend isn't ready
yet, but infrastructure in the frontend can come up.

Modified:
    cfe/trunk/lib/CodeGen/TargetInfo.cpp

Modified: cfe/trunk/lib/CodeGen/TargetInfo.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/TargetInfo.cpp?rev=109768&r1=109767&r2=109768&view=diff
==============================================================================
--- cfe/trunk/lib/CodeGen/TargetInfo.cpp (original)
+++ cfe/trunk/lib/CodeGen/TargetInfo.cpp Thu Jul 29 12:49:08 2010
@@ -718,7 +718,8 @@
   void classify(QualType T, uint64_t OffsetBase, Class &Lo, Class &Hi) const;
 
   const llvm::Type *Get16ByteVectorType(QualType Ty) const;
-
+  const llvm::Type *GetSSETypeAtOffset(const llvm::Type *IRType,
+                                       unsigned IROffset) const;
   const llvm::Type *GetINTEGERTypeAtOffset(const llvm::Type *IRType,
                                            unsigned IROffset, QualType SourceTy,
                                            unsigned SourceOffset) const;
@@ -1211,6 +1212,20 @@
 }
 
 
+/// GetSSETypeAtOffset - Return a type that will be passed by the backend in the
+/// low 8 bytes of an XMM register, corresponding to the SSE class.
+const llvm::Type *X86_64ABIInfo::GetSSETypeAtOffset(const llvm::Type *IRType,
+                                                    unsigned IROffset) const {
+  // The only two choices we have are either double or <2 x float>.
+  
+  // FIXME: <2 x float> doesn't pass as one XMM register yet.  Don't enable this
+  // code until it does.
+  
+  return llvm::Type::getDoubleTy(getVMContext());
+}
+
+
+
 /// BitsContainNoUserData - Return true if the specified [start,end) bit range
 /// is known to either be off the end of the specified type or being in
 /// alignment padding.  The user type specified is known to be at most 128 bits
@@ -1405,7 +1420,7 @@
     // AMD64-ABI 3.2.3p4: Rule 4. If the class is SSE, the next
     // available SSE register of the sequence %xmm0, %xmm1 is used.
   case SSE:
-    ResType = llvm::Type::getDoubleTy(getVMContext());
+    ResType = GetSSETypeAtOffset(CGT.ConvertTypeRecursive(RetTy), 0);
     break;
 
     // AMD64-ABI 3.2.3p4: Rule 6. If the class is X87, the value is
@@ -1443,11 +1458,12 @@
     ResType = llvm::StructType::get(getVMContext(), ResType, HiType, NULL);
     break;
   }
-  case SSE:
-    ResType = llvm::StructType::get(getVMContext(), ResType,
-                                    llvm::Type::getDoubleTy(getVMContext()),
-                                    NULL);
+  case SSE: {
+    const llvm::Type *HiType =
+      GetSSETypeAtOffset(CGT.ConvertTypeRecursive(RetTy), 8);
+    ResType = llvm::StructType::get(getVMContext(), ResType, HiType,NULL);
     break;
+  }
 
     // AMD64-ABI 3.2.3p4: Rule 5. If the class is SSEUP, the eightbyte
     // is passed in the upper half of the last used SSE register.
@@ -1465,10 +1481,11 @@
     // anything. However, in some cases with unions it may not be
     // preceeded by X87. In such situations we follow gcc and pass the
     // extra bits in an SSE reg.
-    if (Lo != X87)
-      ResType = llvm::StructType::get(getVMContext(), ResType,
-                                      llvm::Type::getDoubleTy(getVMContext()),
-                                      NULL);
+    if (Lo != X87) {
+      const llvm::Type *HiType =
+        GetSSETypeAtOffset(CGT.ConvertTypeRecursive(RetTy), 8);
+      ResType = llvm::StructType::get(getVMContext(), ResType, HiType, NULL);
+    }
     break;
   }
 
@@ -1522,7 +1539,7 @@
     // order from %xmm0 to %xmm7.
   case SSE:
     ++neededSSE;
-    ResType = llvm::Type::getDoubleTy(getVMContext());
+    ResType = GetSSETypeAtOffset(CGT.ConvertTypeRecursive(Ty), 0);
     break;
   }
 
@@ -1550,12 +1567,13 @@
     // X87Up generally doesn't occur here (long double is passed in
     // memory), except in situations involving unions.
   case X87Up:
-  case SSE:
-    ResType = llvm::StructType::get(getVMContext(), ResType,
-                                    llvm::Type::getDoubleTy(getVMContext()),
-                                    NULL);
+  case SSE: {
+    const llvm::Type *HiType =
+      GetSSETypeAtOffset(CGT.ConvertTypeRecursive(Ty), 8);
+    ResType = llvm::StructType::get(getVMContext(), ResType, HiType, NULL);
     ++neededSSE;
     break;
+  }
 
     // AMD64-ABI 3.2.3p3: Rule 4. If the class is SSEUP, the
     // eightbyte is passed in the upper half of the last used SSE