Unbreak SPARC backend: addPassesToJITCompile and

[oota-llvm.git] / lib / Target / TargetData.cpp

diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp
index 1207a6eed149d7ffbf144a3c8bd28147e5ac6efa..e86e51f54285d68a12f3bf434eaec7db41a04652 100644 (file)
--- a/lib/Target/TargetData.cpp
+++ b/lib/Target/TargetData.cpp
@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/TargetData.h"
+#include "llvm/Module.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Constants.h"
 
@@ -55,25 +56,23 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD)
     StructSize += TySize;                 // Consume space for this data item
   }
 
+  // Empty structures have alignment of 1 byte.
+  if (StructAlignment == 0) StructAlignment = 1;
+
   // Add padding to the end of the struct so that it could be put in an array
   // and all array elements would be aligned correctly.
   if (StructSize % StructAlignment != 0)
     StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
-
-  if (StructSize == 0) {
-    StructSize = 1;           // Empty struct is 1 byte
-    StructAlignment = 1;
-  }
 }
 
 Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T,
                                      void *D) {
   const TargetData &TD = *(const TargetData*)D;
   assert(AID == TD.AID && "Target data annotation ID mismatch!");
-  const Type *Ty = cast<const Type>((const Value *)T);
+  const Type *Ty = cast<Type>((const Value *)T);
   assert(isa<StructType>(Ty) && 
         "Can only create StructLayout annotation on structs!");
-  return new StructLayout((const StructType *)Ty, TD);
+  return new StructLayout(cast<StructType>(Ty), TD);
 }
 
 //===----------------------------------------------------------------------===//
@@ -81,8 +80,7 @@ Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T,
 //===----------------------------------------------------------------------===//
 
 TargetData::TargetData(const std::string &TargetName,
-                       bool isLittleEndian,
-                       unsigned char IntRegSize, unsigned char PtrSize,
+                       bool isLittleEndian, unsigned char PtrSize,
                        unsigned char PtrAl, unsigned char DoubleAl,
                        unsigned char FloatAl, unsigned char LongAl, 
                        unsigned char IntAl, unsigned char ShortAl,
@@ -90,11 +88,19 @@ TargetData::TargetData(const std::string &TargetName,
   : AID(AnnotationManager::getID("TargetData::" + TargetName)) {
   AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
 
+  // If this assert triggers, a pass "required" TargetData information, but the
+  // top level tool did not provide once for it.  We do not want to default
+  // construct, or else we might end up using a bad endianness or pointer size!
+  //
+  assert(!TargetName.empty() &&
+         "ERROR: Tool did not specify a target data to use!");
+
   LittleEndian     = isLittleEndian;
-  IntegerRegSize   = IntRegSize;
   PointerSize      = PtrSize;
   PointerAlignment = PtrAl;
   DoubleAlignment  = DoubleAl;
+  assert(DoubleAlignment == PtrAl &&
+         "Double alignment and pointer alignment agree for now!");
   FloatAlignment   = FloatAl;
   LongAlignment    = LongAl;
   IntAlignment     = IntAl;
@@ -102,6 +108,21 @@ TargetData::TargetData(const std::string &TargetName,
   ByteAlignment    = ByteAl;
 }
 
+TargetData::TargetData(const std::string &ToolName, const Module *M)
+  : AID(AnnotationManager::getID("TargetData::" + ToolName)) {
+  AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
+
+  LittleEndian     = M->isLittleEndian();
+  PointerSize      = M->has32BitPointers() ? 4 : 8;
+  PointerAlignment = PointerSize;
+  DoubleAlignment  = PointerSize;
+  FloatAlignment   = 4;
+  LongAlignment    = 8;
+  IntAlignment     = 4;
+  ShortAlignment   = 2;
+  ByteAlignment    = 1;
+}
+
 TargetData::~TargetData() {
   AnnotationManager::registerAnnotationFactory(AID, 0);   // Deregister factory
 }
@@ -172,12 +193,10 @@ uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
       Ty = cast<SequentialType>(Ty)->getElementType();
 
       // Get the array index and the size of each array element.
-      // Both must be known constants, or the index shd be 0; else this fails.
       int64_t arrayIdx = cast<ConstantSInt>(Idx[CurIDX])->getValue();
-      Result += arrayIdx == 0? 0
-                : (uint64_t) (arrayIdx * (int64_t) getTypeSize(Ty)); 
-
-    } else if (const StructType *STy = dyn_cast<const StructType>(Ty)) {
+      Result += arrayIdx * (int64_t)getTypeSize(Ty);
+    } else {
+      const StructType *STy = cast<StructType>(Ty);
       assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx");
       unsigned FieldNo = cast<ConstantUInt>(Idx[CurIDX])->getValue();
 
@@ -190,12 +209,6 @@ uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
 
       // Update Ty to refer to current element
       Ty = STy->getElementTypes()[FieldNo];
-
-    } else if (isa<const ArrayType>(Ty)) {
-      assert(0 && "Loading from arrays not implemented yet!");
-    } else {
-      assert(0 && "Indexing type that is not struct or array?");
-      return 0;                         // Load directly through ptr
     }
   }