include/llvm/Target/TargetData.h

   1 //===-- llvm/Target/TargetData.h - Data size & alignment info ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines target properties related to datatype size/offset/alignment
  11 // information.  It uses lazy annotations to cache information about how
  12 // structure types are laid out and used.
  13 //
  14 // This structure should be created once, filled in if the defaults are not
  15 // correct and then passed around by const&.  None of the members functions
  16 // require modification to the object.
  17 //
  18 //===----------------------------------------------------------------------===//
  19
  20 #ifndef LLVM_TARGET_TARGETDATA_H
  21 #define LLVM_TARGET_TARGETDATA_H
  22
  23 #include "llvm/Pass.h"
  24 #include "llvm/Support/DataTypes.h"
  25
  26 namespace llvm {
  27
  28 class Value;
  29 class Type;
  30 class StructType;
  31 class StructLayout;
  32 class GlobalVariable;
  33
  34 class TargetData : public ImmutablePass {
  35   bool          LittleEndian;          // Defaults to false
  36
  37   // ABI alignments
  38   unsigned char BoolABIAlignment;       // Defaults to 1 byte
  39   unsigned char ByteABIAlignment;       // Defaults to 1 byte
  40   unsigned char ShortABIAlignment;      // Defaults to 2 bytes
  41   unsigned char IntABIAlignment;        // Defaults to 4 bytes
  42   unsigned char LongABIAlignment;       // Defaults to 8 bytes
  43   unsigned char FloatABIAlignment;      // Defaults to 4 bytes
  44   unsigned char DoubleABIAlignment;     // Defaults to 8 bytes
  45   unsigned char PointerMemSize;        // Defaults to 8 bytes
  46   unsigned char PointerABIAlignment;    // Defaults to 8 bytes
  47
  48   // Preferred stack/global type alignments
  49   unsigned char BoolPrefAlignment;    // Defaults to BoolABIAlignment
  50   unsigned char BytePrefAlignment;    // Defaults to ByteABIAlignment
  51   unsigned char ShortPrefAlignment;   // Defaults to ShortABIAlignment
  52   unsigned char IntPrefAlignment;     // Defaults to IntABIAlignment
  53   unsigned char LongPrefAlignment;    // Defaults to LongABIAlignment
  54   unsigned char FloatPrefAlignment;   // Defaults to FloatABIAlignment
  55   unsigned char DoublePrefAlignment;  // Defaults to DoubleABIAlignment
  56   unsigned char PointerPrefAlignment; // Defaults to PointerABIAlignment
  57   unsigned char AggMinPrefAlignment;  // Defaults to 0 bytes
  58
  59 public:
  60   /// Default ctor - This has to exist, because this is a pass, but it should
  61   /// never be used.
  62   TargetData() {
  63     assert(0 && "ERROR: Bad TargetData ctor used.  "
  64            "Tool did not specify a TargetData to use?");
  65     abort();
  66   }
  67
  68   /// Constructs a TargetData from a string of the following format:
  69   /// "E-p:64:64-d:64-f:32-l:64-i:32-s:16-b:8-B:8"
  70   /// The above string is considered the default, and any values not specified
  71   /// in the string will be assumed to be as above, with the caveat that unspecified
  72   /// values are always assumed to be smaller than the size of a pointer.
  73   TargetData(const std::string &TargetDescription) {
  74     init(TargetDescription);
  75   }
  76
  77   /// Initialize target data from properties stored in the module.
  78   TargetData(const Module *M);
  79
  80   TargetData(const TargetData &TD) :
  81     ImmutablePass(),
  82     LittleEndian(TD.isLittleEndian()),
  83     BoolABIAlignment(TD.getBoolABIAlignment()),
  84     ByteABIAlignment(TD.getByteABIAlignment()),
  85     ShortABIAlignment(TD.getShortABIAlignment()),
  86     IntABIAlignment(TD.getIntABIAlignment()),
  87     LongABIAlignment(TD.getLongABIAlignment()),
  88     FloatABIAlignment(TD.getFloatABIAlignment()),
  89     DoubleABIAlignment(TD.getDoubleABIAlignment()),
  90     PointerMemSize(TD.getPointerSize()),
  91     PointerABIAlignment(TD.getPointerABIAlignment()),
  92     BoolPrefAlignment(TD.getBoolPrefAlignment()),
  93     BytePrefAlignment(TD.getBytePrefAlignment()),
  94     ShortPrefAlignment(TD.getShortPrefAlignment()),
  95     IntPrefAlignment(TD.getIntPrefAlignment()),
  96     LongPrefAlignment(TD.getLongPrefAlignment()),
  97     FloatPrefAlignment(TD.getFloatPrefAlignment()),
  98     DoublePrefAlignment(TD.getDoublePrefAlignment()),
  99     PointerPrefAlignment(TD.getPointerPrefAlignment()),
 100     AggMinPrefAlignment(TD.getAggMinPrefAlignment()) {
 101   }
 102
 103   ~TargetData();  // Not virtual, do not subclass this class
 104
 105   /// Parse a target data layout string and initialize TargetData members.
 106   ///
 107   /// Parse a target data layout string, initializing the various TargetData
 108   /// members along the way. A TargetData specification string looks like
 109   /// "E-p:64:64-d:64-f:32-l:64-i:32-s:16-b:8-B:8" and specifies the
 110   /// target's endianess, the ABI alignments of various data types and
 111   /// the size of pointers.
 112   ///
 113   /// "-" is used as a separator and ":" separates a token from its argument.
 114   ///
 115   /// Alignment is indicated in bits and internally converted to the
 116   /// appropriate number of bytes.
 117   ///
 118   /// The preferred stack/global alignment specifications (":[prefalign]") are
 119   /// optional and default to the ABI alignment.
 120   ///
 121   /// Valid tokens:
 122   /// <br>
 123   /// <em>E</em> specifies big endian architecture (1234) [default]<br>
 124   /// <em>e</em> specifies little endian architecture (4321) <br>
 125   /// <em>p:[ptr size]:[ptr align]</em> specifies pointer size and alignment
 126   /// [default = 64:64] <br>
 127   /// <em>d:[align]:[prefalign]</em> specifies double floating
 128   /// point alignment [default = 64] <br>
 129   /// <em>f:[align]:[prefalign]</em> specifies single floating
 130   /// point alignment [default = 32] <br>
 131   /// <em>l:[align]:[prefalign]:[globalign[</em> specifies long integer
 132   /// alignment [default = 64] <br>
 133   /// <em>i:[align]:[prefalign]</em> specifies integer alignment
 134   /// [default = 32] <br>
 135   /// <em>s:[align]:[prefalign]</em> specifies short integer
 136   /// alignment [default = 16] <br>
 137   /// <em>b:[align]:[prefalign]</em> specifies byte data type
 138   /// alignment [default = 8] <br>
 139   /// <em>B:[align]:[prefalign]</em> specifies boolean data type
 140   /// alignment [default = 8] <br>
 141   /// <em>A:[prefalign]</em> specifies an aggregates' minimum alignment
 142   /// on the stack and when emitted as a global. The default minimum aggregate
 143   /// alignment defaults to 0, which causes the aggregate's "natural" internal
 144   /// alignment calculated by llvm to be preferred.
 145   ///
 146   /// All other token types are silently ignored.
 147   void init(const std::string &TargetDescription);
 148
 149
 150   /// Target endianness...
 151   bool          isLittleEndian()       const { return     LittleEndian; }
 152   bool          isBigEndian()          const { return    !LittleEndian; }
 153
 154   /// Target boolean alignment
 155   unsigned char getBoolABIAlignment()    const { return    BoolABIAlignment; }
 156   /// Target byte alignment
 157   unsigned char getByteABIAlignment()    const { return    ByteABIAlignment; }
 158   /// Target short alignment
 159   unsigned char getShortABIAlignment()   const { return   ShortABIAlignment; }
 160   /// Target integer alignment
 161   unsigned char getIntABIAlignment()     const { return     IntABIAlignment; }
 162   /// Target long alignment
 163   unsigned char getLongABIAlignment()    const { return    LongABIAlignment; }
 164   /// Target single precision float alignment
 165   unsigned char getFloatABIAlignment()   const { return   FloatABIAlignment; }
 166   /// Target double precision float alignment
 167   unsigned char getDoubleABIAlignment()  const { return  DoubleABIAlignment; }
 168   /// Target pointer alignment
 169   unsigned char getPointerABIAlignment() const { return PointerABIAlignment; }
 170   /// Target pointer size
 171   unsigned char getPointerSize()         const { return      PointerMemSize; }
 172   /// Target pointer size, in bits
 173   unsigned char getPointerSizeInBits()   const { return    8*PointerMemSize; }
 174
 175   /// Return target's alignment for booleans on stack
 176   unsigned char getBoolPrefAlignment() const {
 177     return BoolPrefAlignment;
 178   }
 179   /// Return target's alignment for integers on stack
 180   unsigned char getBytePrefAlignment() const {
 181     return BytePrefAlignment;
 182   }
 183   /// Return target's alignment for shorts on stack
 184   unsigned char getShortPrefAlignment() const {
 185     return ShortPrefAlignment;
 186   }
 187   /// Return target's alignment for integers on stack
 188   unsigned char getIntPrefAlignment()     const {
 189     return IntPrefAlignment;
 190   }
 191   /// Return target's alignment for longs on stack
 192   unsigned char getLongPrefAlignment() const {
 193     return LongPrefAlignment;
 194   }
 195   /// Return target's alignment for single precision floats on stack
 196   unsigned char getFloatPrefAlignment() const {
 197     return FloatPrefAlignment;
 198   }
 199   /// Return target's alignment for double preceision floats on stack
 200   unsigned char getDoublePrefAlignment()  const {
 201     return DoublePrefAlignment;
 202   }
 203   /// Return target's alignment for stack-based pointers
 204   unsigned char getPointerPrefAlignment() const {
 205     return PointerPrefAlignment;
 206   }
 207   /// Return target's alignment for stack-based structures
 208   unsigned char getAggMinPrefAlignment() const {
 209     return AggMinPrefAlignment;
 210   }
 211
 212   /// getStringRepresentation - Return the string representation of the
 213   /// TargetData.  This representation is in the same format accepted by the
 214   /// string constructor above.
 215   std::string getStringRepresentation() const;
 216
 217   /// getTypeSize - Return the number of bytes necessary to hold the specified
 218   /// type.
 219   ///
 220   uint64_t getTypeSize(const Type *Ty) const;
 221
 222   /// getTypeSizeInBits - Return the number of bytes necessary to hold the
 223   /// specified type.
 224   uint64_t getTypeSizeInBits(const Type* Ty) const;
 225
 226   /// getTypeAlignmentABI - Return the minimum ABI-required alignment for the
 227   /// specified type.
 228   unsigned char getTypeAlignmentABI(const Type *Ty) const;
 229
 230   /// getTypeAlignmentPref - Return the preferred stack/global alignment for
 231   /// the specified type.
 232   unsigned char getTypeAlignmentPref(const Type *Ty) const;
 233
 234   /// getPreferredTypeAlignmentShift - Return the preferred alignment for the
 235   /// specified type, returned as log2 of the value (a shift amount).
 236   ///
 237   unsigned char getPreferredTypeAlignmentShift(const Type *Ty) const;
 238
 239   /// getIntPtrType - Return an unsigned integer type that is the same size or
 240   /// greater to the host pointer size.
 241   ///
 242   const Type *getIntPtrType() const;
 243
 244   /// getIndexOffset - return the offset from the beginning of the type for the
 245   /// specified indices.  This is used to implement getelementptr.
 246   ///
 247   uint64_t getIndexedOffset(const Type *Ty,
 248                             Value* const* Indices, unsigned NumIndices) const;
 249
 250   /// getStructLayout - Return a StructLayout object, indicating the alignment
 251   /// of the struct, its size, and the offsets of its fields.  Note that this
 252   /// information is lazily cached.
 253   const StructLayout *getStructLayout(const StructType *Ty) const;
 254
 255   /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 256   /// objects.  If a TargetData object is alive when types are being refined and
 257   /// removed, this method must be called whenever a StructType is removed to
 258   /// avoid a dangling pointer in this cache.
 259   void InvalidateStructLayoutInfo(const StructType *Ty) const;
 260
 261   /// getPreferredAlignmentLog - Return the preferred alignment of the
 262   /// specified global, returned in log form.  This includes an explicitly
 263   /// requested alignment (if the global has one).
 264   unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
 265 };
 266
 267 /// StructLayout - used to lazily calculate structure layout information for a
 268 /// target machine, based on the TargetData structure.
 269 ///
 270 class StructLayout {
 271   uint64_t StructSize;
 272   unsigned StructAlignment;
 273   unsigned NumElements;
 274   uint64_t MemberOffsets[1];  // variable sized array!
 275 public:
 276
 277   uint64_t getSizeInBytes() const {
 278     return StructSize;
 279   }
 280
 281   unsigned getAlignment() const {
 282     return StructAlignment;
 283   }
 284
 285   /// getElementContainingOffset - Given a valid offset into the structure,
 286   /// return the structure index that contains it.
 287   ///
 288   unsigned getElementContainingOffset(uint64_t Offset) const;
 289
 290   uint64_t getElementOffset(unsigned Idx) const {
 291     assert(Idx < NumElements && "Invalid element idx!");
 292     return MemberOffsets[Idx];
 293   }
 294
 295 private:
 296   friend class TargetData;   // Only TargetData can create this class
 297   StructLayout(const StructType *ST, const TargetData &TD);
 298 };
 299
 300 } // End llvm namespace
 301
 302 #endif