lib/Target/TargetData.cpp

   1 //===-- TargetData.cpp - Data size & alignment routines --------------------==//
   2 //
   3 // This file defines target properties related to datatype size/offset/alignment
   4 // information.  It uses lazy annotations to cache information about how
   5 // structure types are laid out and used.
   6 //
   7 // This structure should be created once, filled in if the defaults are not
   8 // correct and then passed around by const&.  None of the members functions
   9 // require modification to the object.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Target/TargetData.h"
  14 #include "llvm/DerivedTypes.h"
  15 #include "llvm/Constants.h"
  16
  17 // Handle the Pass registration stuff neccesary to use TargetData's.
  18 namespace {
  19   // Register the default SparcV9 implementation...
  20   RegisterPass<TargetData> X("targetdata", "Target Data Layout");
  21 }
  22
  23
  24 static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
  25                                uint64_t &Size, unsigned char &Alignment);
  26
  27 //===----------------------------------------------------------------------===//
  28 // Support for StructLayout Annotation
  29 //===----------------------------------------------------------------------===//
  30
  31 StructLayout::StructLayout(const StructType *ST, const TargetData &TD)
  32   : Annotation(TD.getStructLayoutAID()) {
  33   StructAlignment = 0;
  34   StructSize = 0;
  35
  36   // Loop over each of the elements, placing them in memory...
  37   for (StructType::ElementTypes::const_iterator
  38          TI = ST->getElementTypes().begin(),
  39          TE = ST->getElementTypes().end(); TI != TE; ++TI) {
  40     const Type *Ty = *TI;
  41     unsigned char A;
  42     unsigned TyAlign;
  43     uint64_t TySize;
  44     getTypeInfo(Ty, &TD, TySize, A);
  45     TyAlign = A;
  46
  47     // Add padding if neccesary to make the data element aligned properly...
  48     if (StructSize % TyAlign != 0)
  49       StructSize = (StructSize/TyAlign + 1) * TyAlign;   // Add padding...
  50
  51     // Keep track of maximum alignment constraint
  52     StructAlignment = std::max(TyAlign, StructAlignment);
  53
  54     MemberOffsets.push_back(StructSize);
  55     StructSize += TySize;                 // Consume space for this data item
  56   }
  57
  58   // Add padding to the end of the struct so that it could be put in an array
  59   // and all array elements would be aligned correctly.
  60   if (StructSize % StructAlignment != 0)
  61     StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
  62
  63   if (StructSize == 0) {
  64     StructSize = 1;           // Empty struct is 1 byte
  65     StructAlignment = 1;
  66   }
  67 }
  68
  69 Annotation *TargetData::TypeAnFactory(AnnotationID AID, const Annotable *T,
  70                                       void *D) {
  71   const TargetData &TD = *(const TargetData*)D;
  72   assert(AID == TD.AID && "Target data annotation ID mismatch!");
  73   const Type *Ty = cast<const Type>((const Value *)T);
  74   assert(isa<StructType>(Ty) &&
  75          "Can only create StructLayout annotation on structs!");
  76   return new StructLayout((const StructType *)Ty, TD);
  77 }
  78
  79 //===----------------------------------------------------------------------===//
  80 //                       TargetData Class Implementation
  81 //===----------------------------------------------------------------------===//
  82
  83 TargetData::TargetData(const std::string &TargetName,
  84                        bool isLittleEndian, unsigned char SubWordSize,
  85                        unsigned char IntRegSize, unsigned char PtrSize,
  86                        unsigned char PtrAl, unsigned char DoubleAl,
  87                        unsigned char FloatAl, unsigned char LongAl,
  88                        unsigned char IntAl, unsigned char ShortAl,
  89                        unsigned char ByteAl)
  90   : AID(AnnotationManager::getID("TargetData::" + TargetName)) {
  91   AnnotationManager::registerAnnotationFactory(AID, TypeAnFactory, this);
  92
  93   LittleEndian     = isLittleEndian;
  94   SubWordDataSize  = SubWordSize;
  95   IntegerRegSize   = IntRegSize;
  96   PointerSize      = PtrSize;
  97   PointerAlignment = PtrAl;
  98   DoubleAlignment  = DoubleAl;
  99   FloatAlignment   = FloatAl;
 100   LongAlignment    = LongAl;
 101   IntAlignment     = IntAl;
 102   ShortAlignment   = ShortAl;
 103   ByteAlignment    = ByteAl;
 104 }
 105
 106 TargetData::~TargetData() {
 107   AnnotationManager::registerAnnotationFactory(AID, 0);   // Deregister factory
 108 }
 109
 110 static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
 111                                uint64_t &Size, unsigned char &Alignment) {
 112   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 113   switch (Ty->getPrimitiveID()) {
 114   case Type::VoidTyID:
 115   case Type::BoolTyID:
 116   case Type::UByteTyID:
 117   case Type::SByteTyID:  Size = 1; Alignment = TD->getByteAlignment(); return;
 118   case Type::UShortTyID:
 119   case Type::ShortTyID:  Size = 2; Alignment = TD->getShortAlignment(); return;
 120   case Type::UIntTyID:
 121   case Type::IntTyID:    Size = 4; Alignment = TD->getIntAlignment(); return;
 122   case Type::ULongTyID:
 123   case Type::LongTyID:   Size = 8; Alignment = TD->getLongAlignment(); return;
 124   case Type::FloatTyID:  Size = 4; Alignment = TD->getFloatAlignment(); return;
 125   case Type::DoubleTyID: Size = 8; Alignment = TD->getDoubleAlignment(); return;
 126   case Type::LabelTyID:
 127   case Type::PointerTyID:
 128     Size = TD->getPointerSize(); Alignment = TD->getPointerAlignment();
 129     return;
 130   case Type::ArrayTyID: {
 131     const ArrayType *ATy = (const ArrayType *)Ty;
 132     getTypeInfo(ATy->getElementType(), TD, Size, Alignment);
 133     Size *= ATy->getNumElements();
 134     return;
 135   }
 136   case Type::StructTyID: {
 137     // Get the layout annotation... which is lazily created on demand.
 138     const StructLayout *Layout = TD->getStructLayout((const StructType*)Ty);
 139     Size = Layout->StructSize; Alignment = Layout->StructAlignment;
 140     return;
 141   }
 142
 143   case Type::TypeTyID:
 144   default:
 145     assert(0 && "Bad type for getTypeInfo!!!");
 146     return;
 147   }
 148 }
 149
 150 uint64_t TargetData::getTypeSize(const Type *Ty) const {
 151   uint64_t Size;
 152   unsigned char Align;
 153   getTypeInfo(Ty, this, Size, Align);
 154   return Size;
 155 }
 156
 157 unsigned char TargetData::getTypeAlignment(const Type *Ty) const {
 158   uint64_t Size;
 159   unsigned char Align;
 160   getTypeInfo(Ty, this, Size, Align);
 161   return Align;
 162 }
 163
 164 uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
 165                                       const std::vector<Value*> &Idx) const {
 166   const Type *Ty = ptrTy;
 167   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
 168   uint64_t Result = 0;
 169
 170   for (unsigned CurIDX = 0; CurIDX != Idx.size(); ++CurIDX) {
 171     if (Idx[CurIDX]->getType() == Type::LongTy) {
 172       // Update Ty to refer to current element
 173       Ty = cast<SequentialType>(Ty)->getElementType();
 174
 175       // Get the array index and the size of each array element.
 176       // Both must be known constants, or the index shd be 0; else this fails.
 177       int64_t arrayIdx = cast<ConstantSInt>(Idx[CurIDX])->getValue();
 178       Result += arrayIdx == 0? 0
 179                 : (uint64_t) (arrayIdx * (int64_t) getTypeSize(Ty));
 180
 181     } else if (const StructType *STy = dyn_cast<const StructType>(Ty)) {
 182       assert(Idx[CurIDX]->getType() == Type::UByteTy && "Illegal struct idx");
 183       unsigned FieldNo = cast<ConstantUInt>(Idx[CurIDX])->getValue();
 184
 185       // Get structure layout information...
 186       const StructLayout *Layout = getStructLayout(STy);
 187
 188       // Add in the offset, as calculated by the structure layout info...
 189       assert(FieldNo < Layout->MemberOffsets.size() &&"FieldNo out of range!");
 190       Result += Layout->MemberOffsets[FieldNo];
 191
 192       // Update Ty to refer to current element
 193       Ty = STy->getElementTypes()[FieldNo];
 194     } else {
 195       assert(0 && "Indexing type that is not struct or array?");
 196       return 0;                         // Load directly through ptr
 197     }
 198   }
 199
 200   return Result;
 201 }