Change codegen for setcc to read the bit directly out of the condition

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

diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp
index a6379afee475ce1052dc7783c29355a3208733c1..395f25ed671ea2cb27ba0972d3ae54a8569ee419 100644 (file)
--- a/lib/Target/TargetData.cpp
+++ b/lib/Target/TargetData.cpp
@@ -21,6 +21,8 @@
 #include "llvm/DerivedTypes.h"
 #include "llvm/Constants.h"
 #include "llvm/Support/GetElementPtrTypeIterator.h"
+#include "llvm/Support/MathExtras.h"
+#include <algorithm>
 using namespace llvm;
 
 // Handle the Pass registration stuff necessary to use TargetData's.
@@ -30,7 +32,7 @@ namespace {
 }
 
 static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
-                              uint64_t &Size, unsigned char &Alignment);
+                               uint64_t &Size, unsigned char &Alignment);
 
 //===----------------------------------------------------------------------===//
 // Support for StructLayout
@@ -42,7 +44,7 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
 
   // Loop over each of the elements, placing them in memory...
   for (StructType::element_iterator TI = ST->element_begin(), 
-        TE = ST->element_end(); TI != TE; ++TI) {
+         TE = ST->element_end(); TI != TE; ++TI) {
     const Type *Ty = *TI;
     unsigned char A;
     unsigned TyAlign;
@@ -70,6 +72,22 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
     StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
 }
 
+
+/// getElementContainingOffset - Given a valid offset into the structure,
+/// return the structure index that contains it.
+unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
+  std::vector<uint64_t>::const_iterator SI =
+    std::upper_bound(MemberOffsets.begin(), MemberOffsets.end(),
+                     Offset);
+  assert(SI != MemberOffsets.begin() && "Offset not in structure type!");
+  --SI;
+  assert(*SI <= Offset && "upper_bound didn't work");
+  assert((SI == MemberOffsets.begin() || *(SI-1) < Offset) &&
+         (SI+1 == MemberOffsets.end() || *(SI+1) > Offset) &&
+         "Upper bound didn't work!");
+  return SI-MemberOffsets.begin();
+}
+
 //===----------------------------------------------------------------------===//
 //                       TargetData Class Implementation
 //===----------------------------------------------------------------------===//
@@ -79,7 +97,7 @@ TargetData::TargetData(const std::string &TargetName,
                        unsigned char PtrAl, unsigned char DoubleAl,
                        unsigned char FloatAl, unsigned char LongAl, 
                        unsigned char IntAl, unsigned char ShortAl,
-                       unsigned char ByteAl) {
+                       unsigned char ByteAl, unsigned char BoolAl) {
 
   // If this assert triggers, a pass "required" TargetData information, but the
   // top level tool did not provide one for it.  We do not want to default
@@ -92,13 +110,12 @@ TargetData::TargetData(const std::string &TargetName,
   PointerSize      = PtrSize;
   PointerAlignment = PtrAl;
   DoubleAlignment  = DoubleAl;
-  assert(DoubleAlignment == PtrAl &&
-         "Double alignment and pointer alignment agree for now!");
   FloatAlignment   = FloatAl;
   LongAlignment    = LongAl;
   IntAlignment     = IntAl;
   ShortAlignment   = ShortAl;
   ByteAlignment    = ByteAl;
+  BoolAlignment    = BoolAl;
 }
 
 TargetData::TargetData(const std::string &ToolName, const Module *M) {
@@ -107,10 +124,11 @@ TargetData::TargetData(const std::string &ToolName, const Module *M) {
   PointerAlignment = PointerSize;
   DoubleAlignment  = PointerSize;
   FloatAlignment   = 4;
-  LongAlignment    = 8;
+  LongAlignment    = PointerSize;
   IntAlignment     = 4;
   ShortAlignment   = 2;
   ByteAlignment    = 1;
+  BoolAlignment    = 1;
 }
 
 static std::map<std::pair<const TargetData*,const StructType*>,
@@ -148,11 +166,11 @@ const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 }
 
 static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
-                              uint64_t &Size, unsigned char &Alignment) {
+                               uint64_t &Size, unsigned char &Alignment) {
   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
   switch (Ty->getTypeID()) {
+  case Type::BoolTyID:   Size = 1; Alignment = TD->getBoolAlignment(); return;
   case Type::VoidTyID:
-  case Type::BoolTyID:
   case Type::UByteTyID:
   case Type::SByteTyID:  Size = 1; Alignment = TD->getByteAlignment(); return;
   case Type::UShortTyID:
@@ -174,6 +192,13 @@ static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
     Size = AlignedSize*ATy->getNumElements();
     return;
   }
+  case Type::PackedTyID: {
+    const PackedType *PTy = cast<PackedType>(Ty);
+    getTypeInfo(PTy->getElementType(), TD, Size, Alignment);
+    unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
+    Size = AlignedSize*PTy->getNumElements();
+    return;
+  }
   case Type::StructTyID: {
     // Get the layout annotation... which is lazily created on demand.
     const StructLayout *Layout = TD->getStructLayout(cast<StructType>(Ty));
@@ -201,6 +226,12 @@ unsigned char TargetData::getTypeAlignment(const Type *Ty) const {
   return Align;
 }
 
+unsigned char TargetData::getTypeAlignmentShift(const Type *Ty) const {
+  unsigned Align = getTypeAlignment(Ty);
+  assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
+  return log2(Align);
+}
+
 /// getIntPtrType - Return an unsigned integer type that is the same size or
 /// greater to the host pointer size.
 const Type *TargetData::getIntPtrType() const {
@@ -214,7 +245,7 @@ const Type *TargetData::getIntPtrType() const {
 
 
 uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
-                                     const std::vector<Value*> &Idx) const {
+                                      const std::vector<Value*> &Idx) const {
   const Type *Ty = ptrTy;
   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
   uint64_t Result = 0;