Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 1 | //===-- TargetData.cpp - Data size & alignment routines --------------------==// |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | f976c85 | 2005-04-21 22:55:34 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 9 | // |
| 10 | // This file defines target properties related to datatype size/offset/alignment |
Chris Lattner | 0e7ac16 | 2004-02-26 08:02:17 +0000 | [diff] [blame] | 11 | // information. |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 12 | // |
| 13 | // This structure should be created once, filled in if the defaults are not |
| 14 | // correct and then passed around by const&. None of the members functions |
| 15 | // require modification to the object. |
| 16 | // |
| 17 | //===----------------------------------------------------------------------===// |
| 18 | |
Vikram S. Adve | 0799fc4 | 2001-09-18 12:58:33 +0000 | [diff] [blame] | 19 | #include "llvm/Target/TargetData.h" |
Chris Lattner | 31bcdb8 | 2002-04-28 19:55:58 +0000 | [diff] [blame] | 20 | #include "llvm/Constants.h" |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 21 | #include "llvm/DerivedTypes.h" |
| 22 | #include "llvm/Module.h" |
Chris Lattner | 28977af | 2004-04-05 01:30:19 +0000 | [diff] [blame] | 23 | #include "llvm/Support/GetElementPtrTypeIterator.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 24 | #include "llvm/Support/MathExtras.h" |
Chris Lattner | ec6478b | 2007-02-10 19:43:18 +0000 | [diff] [blame] | 25 | #include "llvm/Support/ManagedStatic.h" |
Torok Edwin | c25e758 | 2009-07-11 20:10:48 +0000 | [diff] [blame] | 26 | #include "llvm/Support/ErrorHandling.h" |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 27 | #include "llvm/Support/raw_ostream.h" |
Michael J. Spencer | 1f6efa3 | 2010-11-29 18:16:10 +0000 | [diff] [blame] | 28 | #include "llvm/Support/Mutex.h" |
Chris Lattner | f6ca09a | 2007-02-10 20:26:17 +0000 | [diff] [blame] | 29 | #include "llvm/ADT/DenseMap.h" |
Chris Lattner | e7ea48c | 2005-03-13 19:04:41 +0000 | [diff] [blame] | 30 | #include <algorithm> |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 31 | #include <cstdlib> |
Chris Lattner | f045328 | 2003-12-22 05:01:15 +0000 | [diff] [blame] | 32 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 33 | |
Misha Brukman | 5560c9d | 2003-08-18 14:43:39 +0000 | [diff] [blame] | 34 | // Handle the Pass registration stuff necessary to use TargetData's. |
Dan Gohman | 844731a | 2008-05-13 00:00:25 +0000 | [diff] [blame] | 35 | |
| 36 | // Register the default SparcV9 implementation... |
Owen Anderson | ce665bd | 2010-10-07 22:25:06 +0000 | [diff] [blame] | 37 | INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true) |
Devang Patel | 1997473 | 2007-05-03 01:11:54 +0000 | [diff] [blame] | 38 | char TargetData::ID = 0; |
Chris Lattner | aa31ad0 | 2002-09-25 23:46:55 +0000 | [diff] [blame] | 39 | |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 40 | //===----------------------------------------------------------------------===// |
Chris Lattner | 0e7ac16 | 2004-02-26 08:02:17 +0000 | [diff] [blame] | 41 | // Support for StructLayout |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 42 | //===----------------------------------------------------------------------===// |
| 43 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 44 | StructLayout::StructLayout(StructType *ST, const TargetData &TD) { |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 45 | assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 46 | StructAlignment = 0; |
| 47 | StructSize = 0; |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 48 | NumElements = ST->getNumElements(); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 49 | |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 50 | // Loop over each of the elements, placing them in memory. |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 51 | for (unsigned i = 0, e = NumElements; i != e; ++i) { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 52 | Type *Ty = ST->getElementType(i); |
Duncan Sands | a0fcc08 | 2008-06-04 08:21:45 +0000 | [diff] [blame] | 53 | unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 54 | |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 55 | // Add padding if necessary to align the data element properly. |
Duncan Sands | 677a7ec | 2008-12-09 09:58:11 +0000 | [diff] [blame] | 56 | if ((StructSize & (TyAlign-1)) != 0) |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 57 | StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 58 | |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 59 | // Keep track of maximum alignment constraint. |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 60 | StructAlignment = std::max(TyAlign, StructAlignment); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 61 | |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 62 | MemberOffsets[i] = StructSize; |
Duncan Sands | 777d230 | 2009-05-09 07:06:46 +0000 | [diff] [blame] | 63 | StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 64 | } |
| 65 | |
Chris Lattner | 4e840d4 | 2003-05-21 18:08:44 +0000 | [diff] [blame] | 66 | // Empty structures have alignment of 1 byte. |
| 67 | if (StructAlignment == 0) StructAlignment = 1; |
| 68 | |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 69 | // Add padding to the end of the struct so that it could be put in an array |
| 70 | // and all array elements would be aligned correctly. |
Chris Lattner | 59779c5 | 2008-12-08 07:21:39 +0000 | [diff] [blame] | 71 | if ((StructSize & (StructAlignment-1)) != 0) |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 72 | StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 73 | } |
| 74 | |
Chris Lattner | e7ea48c | 2005-03-13 19:04:41 +0000 | [diff] [blame] | 75 | |
| 76 | /// getElementContainingOffset - Given a valid offset into the structure, |
| 77 | /// return the structure index that contains it. |
| 78 | unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const { |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 79 | const uint64_t *SI = |
| 80 | std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset); |
| 81 | assert(SI != &MemberOffsets[0] && "Offset not in structure type!"); |
Chris Lattner | e7ea48c | 2005-03-13 19:04:41 +0000 | [diff] [blame] | 82 | --SI; |
| 83 | assert(*SI <= Offset && "upper_bound didn't work"); |
Chris Lattner | b361ec3 | 2007-10-29 02:40:02 +0000 | [diff] [blame] | 84 | assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) && |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 85 | (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) && |
Chris Lattner | e7ea48c | 2005-03-13 19:04:41 +0000 | [diff] [blame] | 86 | "Upper bound didn't work!"); |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 87 | |
Chris Lattner | b361ec3 | 2007-10-29 02:40:02 +0000 | [diff] [blame] | 88 | // Multiple fields can have the same offset if any of them are zero sized. |
| 89 | // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop |
| 90 | // at the i32 element, because it is the last element at that offset. This is |
| 91 | // the right one to return, because anything after it will have a higher |
| 92 | // offset, implying that this element is non-empty. |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 93 | return SI-&MemberOffsets[0]; |
Chris Lattner | e7ea48c | 2005-03-13 19:04:41 +0000 | [diff] [blame] | 94 | } |
| 95 | |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 96 | //===----------------------------------------------------------------------===// |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 97 | // TargetAlignElem, TargetAlign support |
| 98 | //===----------------------------------------------------------------------===// |
| 99 | |
| 100 | TargetAlignElem |
Dan Gohman | b68f274 | 2010-08-11 18:15:01 +0000 | [diff] [blame] | 101 | TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, |
| 102 | unsigned pref_align, uint32_t bit_width) { |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 103 | assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 104 | TargetAlignElem retval; |
| 105 | retval.AlignType = align_type; |
| 106 | retval.ABIAlign = abi_align; |
| 107 | retval.PrefAlign = pref_align; |
| 108 | retval.TypeBitWidth = bit_width; |
| 109 | return retval; |
| 110 | } |
| 111 | |
| 112 | bool |
Reid Spencer | b7d6110 | 2007-02-15 02:11:06 +0000 | [diff] [blame] | 113 | TargetAlignElem::operator==(const TargetAlignElem &rhs) const { |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 114 | return (AlignType == rhs.AlignType |
| 115 | && ABIAlign == rhs.ABIAlign |
| 116 | && PrefAlign == rhs.PrefAlign |
| 117 | && TypeBitWidth == rhs.TypeBitWidth); |
| 118 | } |
| 119 | |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 120 | const TargetAlignElem TargetData::InvalidAlignmentElem = |
| 121 | TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0); |
| 122 | |
| 123 | //===----------------------------------------------------------------------===// |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 124 | // TargetData Class Implementation |
| 125 | //===----------------------------------------------------------------------===// |
| 126 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 127 | /// getInt - Get an integer ignoring errors. |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 128 | static int getInt(StringRef R) { |
| 129 | int Result = 0; |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 130 | R.getAsInteger(10, Result); |
| 131 | return Result; |
| 132 | } |
| 133 | |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 134 | void TargetData::init() { |
Owen Anderson | 081c34b | 2010-10-19 17:21:58 +0000 | [diff] [blame] | 135 | initializeTargetDataPass(*PassRegistry::getPassRegistry()); |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 136 | |
Owen Anderson | 9085750 | 2009-08-21 19:59:12 +0000 | [diff] [blame] | 137 | LayoutMap = 0; |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 138 | LittleEndian = false; |
Chris Lattner | 58092e3 | 2007-01-20 22:35:55 +0000 | [diff] [blame] | 139 | PointerMemSize = 8; |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 140 | PointerABIAlign = 8; |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 141 | PointerPrefAlign = PointerABIAlign; |
Lang Hames | bb5b3f3 | 2011-10-10 23:42:08 +0000 | [diff] [blame] | 142 | StackNaturalAlign = 0; |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 143 | |
| 144 | // Default alignments |
Dan Gohman | 77c5b0d | 2009-04-01 18:10:16 +0000 | [diff] [blame] | 145 | setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1 |
| 146 | setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8 |
| 147 | setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16 |
| 148 | setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32 |
| 149 | setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64 |
Reid Spencer | b7d6110 | 2007-02-15 02:11:06 +0000 | [diff] [blame] | 150 | setAlignment(FLOAT_ALIGN, 4, 4, 32); // float |
| 151 | setAlignment(FLOAT_ALIGN, 8, 8, 64); // double |
Dan Gohman | d35626e | 2009-08-20 16:27:10 +0000 | [diff] [blame] | 152 | setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ... |
Reid Spencer | 1f43787 | 2007-02-15 22:07:05 +0000 | [diff] [blame] | 153 | setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ... |
Dan Gohman | d35626e | 2009-08-20 16:27:10 +0000 | [diff] [blame] | 154 | setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) { |
| 158 | |
| 159 | if (td) |
| 160 | td->init(); |
Rafael Espindola | 588af2f | 2007-09-07 14:52:14 +0000 | [diff] [blame] | 161 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 162 | while (!Desc.empty()) { |
| 163 | std::pair<StringRef, StringRef> Split = Desc.split('-'); |
| 164 | StringRef Token = Split.first; |
| 165 | Desc = Split.second; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 166 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 167 | if (Token.empty()) |
| 168 | continue; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 169 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 170 | Split = Token.split(':'); |
| 171 | StringRef Specifier = Split.first; |
| 172 | Token = Split.second; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 173 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 174 | assert(!Specifier.empty() && "Can't be empty here"); |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 175 | |
Chris Lattner | e82bdc4 | 2009-11-07 09:35:34 +0000 | [diff] [blame] | 176 | switch (Specifier[0]) { |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 177 | case 'E': |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 178 | if (td) |
| 179 | td->LittleEndian = false; |
Owen Anderson | 571a13f | 2006-05-12 06:06:55 +0000 | [diff] [blame] | 180 | break; |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 181 | case 'e': |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 182 | if (td) |
| 183 | td->LittleEndian = true; |
Owen Anderson | 571a13f | 2006-05-12 06:06:55 +0000 | [diff] [blame] | 184 | break; |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 185 | case 'p': { |
| 186 | // Pointer size. |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 187 | Split = Token.split(':'); |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 188 | int PointerMemSizeBits = getInt(Split.first); |
| 189 | if (PointerMemSizeBits < 0 || PointerMemSizeBits % 8 != 0) |
| 190 | return "invalid pointer size, must be a positive 8-bit multiple"; |
| 191 | if (td) |
| 192 | td->PointerMemSize = PointerMemSizeBits / 8; |
| 193 | |
| 194 | // Pointer ABI alignment. |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 195 | Split = Split.second.split(':'); |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 196 | int PointerABIAlignBits = getInt(Split.first); |
| 197 | if (PointerABIAlignBits < 0 || PointerABIAlignBits % 8 != 0) { |
| 198 | return "invalid pointer ABI alignment, " |
| 199 | "must be a positive 8-bit multiple"; |
| 200 | } |
| 201 | if (td) |
| 202 | td->PointerABIAlign = PointerABIAlignBits / 8; |
| 203 | |
| 204 | // Pointer preferred alignment. |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 205 | Split = Split.second.split(':'); |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 206 | int PointerPrefAlignBits = getInt(Split.first); |
| 207 | if (PointerPrefAlignBits < 0 || PointerPrefAlignBits % 8 != 0) { |
| 208 | return "invalid pointer preferred alignment, " |
| 209 | "must be a positive 8-bit multiple"; |
| 210 | } |
| 211 | if (td) { |
| 212 | td->PointerPrefAlign = PointerPrefAlignBits / 8; |
| 213 | if (td->PointerPrefAlign == 0) |
| 214 | td->PointerPrefAlign = td->PointerABIAlign; |
| 215 | } |
Owen Anderson | 571a13f | 2006-05-12 06:06:55 +0000 | [diff] [blame] | 216 | break; |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 217 | } |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 218 | case 'i': |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 219 | case 'v': |
| 220 | case 'f': |
Rafael Espindola | 588af2f | 2007-09-07 14:52:14 +0000 | [diff] [blame] | 221 | case 'a': |
| 222 | case 's': { |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 223 | AlignTypeEnum AlignType; |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 224 | char field = Specifier[0]; |
| 225 | switch (field) { |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 226 | default: |
| 227 | case 'i': AlignType = INTEGER_ALIGN; break; |
| 228 | case 'v': AlignType = VECTOR_ALIGN; break; |
| 229 | case 'f': AlignType = FLOAT_ALIGN; break; |
| 230 | case 'a': AlignType = AGGREGATE_ALIGN; break; |
| 231 | case 's': AlignType = STACK_ALIGN; break; |
Rafael Espindola | 588af2f | 2007-09-07 14:52:14 +0000 | [diff] [blame] | 232 | } |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 233 | int Size = getInt(Specifier.substr(1)); |
| 234 | if (Size < 0) { |
| 235 | return std::string("invalid ") + field + "-size field, " |
| 236 | "must be positive"; |
| 237 | } |
| 238 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 239 | Split = Token.split(':'); |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 240 | int ABIAlignBits = getInt(Split.first); |
| 241 | if (ABIAlignBits < 0 || ABIAlignBits % 8 != 0) { |
| 242 | return std::string("invalid ") + field +"-abi-alignment field, " |
| 243 | "must be a positive 8-bit multiple"; |
| 244 | } |
| 245 | unsigned ABIAlign = ABIAlignBits / 8; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 246 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 247 | Split = Split.second.split(':'); |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 248 | |
| 249 | int PrefAlignBits = getInt(Split.first); |
| 250 | if (PrefAlignBits < 0 || PrefAlignBits % 8 != 0) { |
| 251 | return std::string("invalid ") + field +"-preferred-alignment field, " |
| 252 | "must be a positive 8-bit multiple"; |
| 253 | } |
| 254 | unsigned PrefAlign = PrefAlignBits / 8; |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 255 | if (PrefAlign == 0) |
| 256 | PrefAlign = ABIAlign; |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 257 | |
| 258 | if (td) |
| 259 | td->setAlignment(AlignType, ABIAlign, PrefAlign, Size); |
Owen Anderson | 571a13f | 2006-05-12 06:06:55 +0000 | [diff] [blame] | 260 | break; |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 261 | } |
Chris Lattner | e82bdc4 | 2009-11-07 09:35:34 +0000 | [diff] [blame] | 262 | case 'n': // Native integer types. |
| 263 | Specifier = Specifier.substr(1); |
| 264 | do { |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 265 | int Width = getInt(Specifier); |
| 266 | if (Width <= 0) { |
| 267 | return std::string("invalid native integer size \'") + Specifier.str() + |
| 268 | "\', must be a positive integer."; |
| 269 | } |
| 270 | if (td && Width != 0) |
| 271 | td->LegalIntWidths.push_back(Width); |
Chris Lattner | e82bdc4 | 2009-11-07 09:35:34 +0000 | [diff] [blame] | 272 | Split = Token.split(':'); |
| 273 | Specifier = Split.first; |
| 274 | Token = Split.second; |
| 275 | } while (!Specifier.empty() || !Token.empty()); |
| 276 | break; |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 277 | case 'S': { // Stack natural alignment. |
| 278 | int StackNaturalAlignBits = getInt(Specifier.substr(1)); |
| 279 | if (StackNaturalAlignBits < 0 || StackNaturalAlignBits % 8 != 0) { |
| 280 | return "invalid natural stack alignment (S-field), " |
| 281 | "must be a positive 8-bit multiple"; |
| 282 | } |
| 283 | if (td) |
| 284 | td->StackNaturalAlign = StackNaturalAlignBits / 8; |
Lang Hames | bb5b3f3 | 2011-10-10 23:42:08 +0000 | [diff] [blame] | 285 | break; |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 286 | } |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 287 | default: |
Owen Anderson | 571a13f | 2006-05-12 06:06:55 +0000 | [diff] [blame] | 288 | break; |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 289 | } |
| 290 | } |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 291 | |
| 292 | return ""; |
Owen Anderson | 8f60c56 | 2006-05-12 05:49:47 +0000 | [diff] [blame] | 293 | } |
| 294 | |
Chris Lattner | 2e07494 | 2009-11-07 09:23:04 +0000 | [diff] [blame] | 295 | /// Default ctor. |
| 296 | /// |
| 297 | /// @note This has to exist, because this is a pass, but it should never be |
| 298 | /// used. |
Owen Anderson | 90c579d | 2010-08-06 18:33:48 +0000 | [diff] [blame] | 299 | TargetData::TargetData() : ImmutablePass(ID) { |
Chris Lattner | 75361b6 | 2010-04-07 22:58:41 +0000 | [diff] [blame] | 300 | report_fatal_error("Bad TargetData ctor used. " |
Chris Lattner | 2e07494 | 2009-11-07 09:23:04 +0000 | [diff] [blame] | 301 | "Tool did not specify a TargetData to use?"); |
| 302 | } |
| 303 | |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 304 | TargetData::TargetData(const Module *M) |
Owen Anderson | 90c579d | 2010-08-06 18:33:48 +0000 | [diff] [blame] | 305 | : ImmutablePass(ID) { |
Lang Hames | 1dda3d5 | 2011-10-20 19:24:44 +0000 | [diff] [blame] | 306 | std::string errMsg = parseSpecifier(M->getDataLayout(), this); |
| 307 | assert(errMsg == "" && "Module M has malformed target data layout string."); |
| 308 | (void)errMsg; |
Chris Lattner | 53a0c38 | 2003-04-24 19:09:05 +0000 | [diff] [blame] | 309 | } |
| 310 | |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 311 | void |
Dan Gohman | b68f274 | 2010-08-11 18:15:01 +0000 | [diff] [blame] | 312 | TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align, |
| 313 | unsigned pref_align, uint32_t bit_width) { |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 314 | assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 315 | for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { |
| 316 | if (Alignments[i].AlignType == align_type && |
| 317 | Alignments[i].TypeBitWidth == bit_width) { |
| 318 | // Update the abi, preferred alignments. |
| 319 | Alignments[i].ABIAlign = abi_align; |
| 320 | Alignments[i].PrefAlign = pref_align; |
| 321 | return; |
| 322 | } |
| 323 | } |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 324 | |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 325 | Alignments.push_back(TargetAlignElem::get(align_type, abi_align, |
| 326 | pref_align, bit_width)); |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 327 | } |
| 328 | |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 329 | /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 330 | /// preferred if ABIInfo = false) the target wants for the specified datatype. |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 331 | unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType, |
Chris Lattner | 9c4428b | 2008-01-10 00:30:57 +0000 | [diff] [blame] | 332 | uint32_t BitWidth, bool ABIInfo, |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 333 | Type *Ty) const { |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 334 | // Check to see if we have an exact match and remember the best match we see. |
| 335 | int BestMatchIdx = -1; |
Reid Spencer | f734ea2 | 2007-02-19 22:35:00 +0000 | [diff] [blame] | 336 | int LargestInt = -1; |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 337 | for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { |
| 338 | if (Alignments[i].AlignType == AlignType && |
| 339 | Alignments[i].TypeBitWidth == BitWidth) |
| 340 | return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 341 | |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 342 | // The best match so far depends on what we're looking for. |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 343 | if (AlignType == INTEGER_ALIGN && |
Dan Gohman | 6e8fd90 | 2010-04-23 19:41:15 +0000 | [diff] [blame] | 344 | Alignments[i].AlignType == INTEGER_ALIGN) { |
Reid Spencer | f734ea2 | 2007-02-19 22:35:00 +0000 | [diff] [blame] | 345 | // The "best match" for integers is the smallest size that is larger than |
| 346 | // the BitWidth requested. |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 347 | if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 || |
Reid Spencer | f734ea2 | 2007-02-19 22:35:00 +0000 | [diff] [blame] | 348 | Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth)) |
| 349 | BestMatchIdx = i; |
| 350 | // However, if there isn't one that's larger, then we must use the |
| 351 | // largest one we have (see below) |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 352 | if (LargestInt == -1 || |
Reid Spencer | f734ea2 | 2007-02-19 22:35:00 +0000 | [diff] [blame] | 353 | Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth) |
| 354 | LargestInt = i; |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 355 | } |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 356 | } |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 357 | |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 358 | // Okay, we didn't find an exact solution. Fall back here depending on what |
| 359 | // is being looked for. |
Chris Lattner | 9c4428b | 2008-01-10 00:30:57 +0000 | [diff] [blame] | 360 | if (BestMatchIdx == -1) { |
| 361 | // If we didn't find an integer alignment, fall back on most conservative. |
| 362 | if (AlignType == INTEGER_ALIGN) { |
| 363 | BestMatchIdx = LargestInt; |
| 364 | } else { |
| 365 | assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!"); |
Dan Gohman | 9fbb52d | 2009-02-16 23:14:14 +0000 | [diff] [blame] | 366 | |
Dan Gohman | 6e8fd90 | 2010-04-23 19:41:15 +0000 | [diff] [blame] | 367 | // By default, use natural alignment for vector types. This is consistent |
| 368 | // with what clang and llvm-gcc do. |
| 369 | unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType()); |
| 370 | Align *= cast<VectorType>(Ty)->getNumElements(); |
| 371 | // If the alignment is not a power of 2, round up to the next power of 2. |
| 372 | // This happens for non-power-of-2 length vectors. |
| 373 | if (Align & (Align-1)) |
| 374 | Align = llvm::NextPowerOf2(Align); |
| 375 | return Align; |
Dan Gohman | 9fbb52d | 2009-02-16 23:14:14 +0000 | [diff] [blame] | 376 | } |
Chris Lattner | 9c4428b | 2008-01-10 00:30:57 +0000 | [diff] [blame] | 377 | } |
Dan Gohman | 9fbb52d | 2009-02-16 23:14:14 +0000 | [diff] [blame] | 378 | |
Reid Spencer | f734ea2 | 2007-02-19 22:35:00 +0000 | [diff] [blame] | 379 | // Since we got a "best match" index, just return it. |
Chris Lattner | affeb56 | 2007-02-17 00:41:42 +0000 | [diff] [blame] | 380 | return ABIInfo ? Alignments[BestMatchIdx].ABIAlign |
| 381 | : Alignments[BestMatchIdx].PrefAlign; |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 382 | } |
| 383 | |
Bill Wendling | dd5eb02 | 2009-12-03 00:17:12 +0000 | [diff] [blame] | 384 | namespace { |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 385 | |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 386 | class StructLayoutMap { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 387 | typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy; |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 388 | LayoutInfoTy LayoutInfo; |
| 389 | |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 390 | public: |
| 391 | virtual ~StructLayoutMap() { |
| 392 | // Remove any layouts. |
Chris Lattner | 1afcace | 2011-07-09 17:41:24 +0000 | [diff] [blame] | 393 | for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end(); |
| 394 | I != E; ++I) { |
Bill Wendling | dd5eb02 | 2009-12-03 00:17:12 +0000 | [diff] [blame] | 395 | StructLayout *Value = I->second; |
Bill Wendling | 1500c4f | 2009-12-04 21:03:02 +0000 | [diff] [blame] | 396 | Value->~StructLayout(); |
| 397 | free(Value); |
Bill Wendling | dd5eb02 | 2009-12-03 00:17:12 +0000 | [diff] [blame] | 398 | } |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 399 | } |
| 400 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 401 | StructLayout *&operator[](StructType *STy) { |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 402 | return LayoutInfo[STy]; |
| 403 | } |
| 404 | |
| 405 | // for debugging... |
| 406 | virtual void dump() const {} |
| 407 | }; |
| 408 | |
Bill Wendling | 1500c4f | 2009-12-04 21:03:02 +0000 | [diff] [blame] | 409 | } // end anonymous namespace |
Owen Anderson | 2ea2015 | 2009-08-20 23:51:44 +0000 | [diff] [blame] | 410 | |
| 411 | TargetData::~TargetData() { |
Bill Wendling | dd5eb02 | 2009-12-03 00:17:12 +0000 | [diff] [blame] | 412 | delete static_cast<StructLayoutMap*>(LayoutMap); |
Chris Lattner | 0e7ac16 | 2004-02-26 08:02:17 +0000 | [diff] [blame] | 413 | } |
| 414 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 415 | const StructLayout *TargetData::getStructLayout(StructType *Ty) const { |
Owen Anderson | 9085750 | 2009-08-21 19:59:12 +0000 | [diff] [blame] | 416 | if (!LayoutMap) |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 417 | LayoutMap = new StructLayoutMap(); |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 418 | |
Bill Wendling | dd5eb02 | 2009-12-03 00:17:12 +0000 | [diff] [blame] | 419 | StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap); |
| 420 | StructLayout *&SL = (*STM)[Ty]; |
Chris Lattner | f6ca09a | 2007-02-10 20:26:17 +0000 | [diff] [blame] | 421 | if (SL) return SL; |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 422 | |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 423 | // Otherwise, create the struct layout. Because it is variable length, we |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 424 | // malloc it, then use placement new. |
Jeff Cohen | 44f5fb4 | 2007-04-09 19:26:30 +0000 | [diff] [blame] | 425 | int NumElts = Ty->getNumElements(); |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 426 | StructLayout *L = |
Bill Wendling | 5eea342 | 2009-11-18 01:03:56 +0000 | [diff] [blame] | 427 | (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t)); |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 428 | |
Chris Lattner | f6ca09a | 2007-02-10 20:26:17 +0000 | [diff] [blame] | 429 | // Set SL before calling StructLayout's ctor. The ctor could cause other |
| 430 | // entries to be added to TheMap, invalidating our reference. |
| 431 | SL = L; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 432 | |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 433 | new (L) StructLayout(Ty, *this); |
Bill Wendling | dd5eb02 | 2009-12-03 00:17:12 +0000 | [diff] [blame] | 434 | |
Chris Lattner | 9182e3f | 2007-02-10 20:15:41 +0000 | [diff] [blame] | 435 | return L; |
| 436 | } |
| 437 | |
Owen Anderson | 2577c22 | 2006-05-12 07:01:44 +0000 | [diff] [blame] | 438 | std::string TargetData::getStringRepresentation() const { |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 439 | std::string Result; |
| 440 | raw_string_ostream OS(Result); |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 441 | |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 442 | OS << (LittleEndian ? "e" : "E") |
| 443 | << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8 |
Lang Hames | bb5b3f3 | 2011-10-10 23:42:08 +0000 | [diff] [blame] | 444 | << ':' << PointerPrefAlign*8 |
| 445 | << "-S" << StackNaturalAlign*8; |
| 446 | |
Chris Lattner | 2e07494 | 2009-11-07 09:23:04 +0000 | [diff] [blame] | 447 | for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { |
| 448 | const TargetAlignElem &AI = Alignments[i]; |
| 449 | OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':' |
| 450 | << AI.ABIAlign*8 << ':' << AI.PrefAlign*8; |
| 451 | } |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 452 | |
Chris Lattner | 7e89738 | 2009-11-08 02:32:01 +0000 | [diff] [blame] | 453 | if (!LegalIntWidths.empty()) { |
| 454 | OS << "-n" << (unsigned)LegalIntWidths[0]; |
Michael J. Spencer | 87b8665 | 2010-10-19 07:32:42 +0000 | [diff] [blame] | 455 | |
Chris Lattner | 7e89738 | 2009-11-08 02:32:01 +0000 | [diff] [blame] | 456 | for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i) |
| 457 | OS << ':' << (unsigned)LegalIntWidths[i]; |
| 458 | } |
Chris Lattner | b7aadfa | 2009-11-07 09:13:23 +0000 | [diff] [blame] | 459 | return OS.str(); |
Owen Anderson | 2577c22 | 2006-05-12 07:01:44 +0000 | [diff] [blame] | 460 | } |
| 461 | |
Chris Lattner | 8dff24f | 2006-01-14 00:07:34 +0000 | [diff] [blame] | 462 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 463 | uint64_t TargetData::getTypeSizeInBits(Type *Ty) const { |
Chris Lattner | f59ce92 | 2001-12-13 00:46:11 +0000 | [diff] [blame] | 464 | assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); |
Chris Lattner | f70c22b | 2004-06-17 18:19:28 +0000 | [diff] [blame] | 465 | switch (Ty->getTypeID()) { |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 466 | case Type::LabelTyID: |
| 467 | case Type::PointerTyID: |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 468 | return getPointerSizeInBits(); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 469 | case Type::ArrayTyID: { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 470 | ArrayType *ATy = cast<ArrayType>(Ty); |
Dan Gohman | aa9d854 | 2010-02-25 15:20:39 +0000 | [diff] [blame] | 471 | return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements(); |
Chris Lattner | 527efc6 | 2004-12-01 17:14:28 +0000 | [diff] [blame] | 472 | } |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 473 | case Type::StructTyID: |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 474 | // Get the layout annotation... which is lazily created on demand. |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 475 | return getStructLayout(cast<StructType>(Ty))->getSizeInBits(); |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 476 | case Type::IntegerTyID: |
| 477 | return cast<IntegerType>(Ty)->getBitWidth(); |
Chris Lattner | 58092e3 | 2007-01-20 22:35:55 +0000 | [diff] [blame] | 478 | case Type::VoidTyID: |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 479 | return 8; |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 480 | case Type::FloatTyID: |
| 481 | return 32; |
| 482 | case Type::DoubleTyID: |
Dale Johannesen | bb811a2 | 2010-09-10 20:55:01 +0000 | [diff] [blame] | 483 | case Type::X86_MMXTyID: |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 484 | return 64; |
Dale Johannesen | 8c1e6a1 | 2007-08-03 20:20:50 +0000 | [diff] [blame] | 485 | case Type::PPC_FP128TyID: |
| 486 | case Type::FP128TyID: |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 487 | return 128; |
Dale Johannesen | 8c1e6a1 | 2007-08-03 20:20:50 +0000 | [diff] [blame] | 488 | // In memory objects this is always aligned to a higher boundary, but |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 489 | // only 80 bits contain information. |
Dale Johannesen | 8c1e6a1 | 2007-08-03 20:20:50 +0000 | [diff] [blame] | 490 | case Type::X86_FP80TyID: |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 491 | return 80; |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 492 | case Type::VectorTyID: |
| 493 | return cast<VectorType>(Ty)->getBitWidth(); |
Chris Lattner | 58092e3 | 2007-01-20 22:35:55 +0000 | [diff] [blame] | 494 | default: |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 495 | llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type"); |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 496 | break; |
Chris Lattner | 58092e3 | 2007-01-20 22:35:55 +0000 | [diff] [blame] | 497 | } |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 498 | return 0; |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 499 | } |
| 500 | |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 501 | /*! |
| 502 | \param abi_or_pref Flag that determines which alignment is returned. true |
| 503 | returns the ABI alignment, false returns the preferred alignment. |
| 504 | \param Ty The underlying type for which alignment is determined. |
| 505 | |
| 506 | Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref |
| 507 | == false) for the requested type \a Ty. |
| 508 | */ |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 509 | unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const { |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 510 | int AlignType = -1; |
| 511 | |
| 512 | assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); |
| 513 | switch (Ty->getTypeID()) { |
Chris Lattner | bedb8c1 | 2008-12-08 07:11:56 +0000 | [diff] [blame] | 514 | // Early escape for the non-numeric types. |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 515 | case Type::LabelTyID: |
| 516 | case Type::PointerTyID: |
| 517 | return (abi_or_pref |
| 518 | ? getPointerABIAlignment() |
| 519 | : getPointerPrefAlignment()); |
Chris Lattner | ae6f1fa | 2007-02-16 22:25:34 +0000 | [diff] [blame] | 520 | case Type::ArrayTyID: |
| 521 | return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref); |
Dan Gohman | 9fbb52d | 2009-02-16 23:14:14 +0000 | [diff] [blame] | 522 | |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 523 | case Type::StructTyID: { |
Chris Lattner | ae6f1fa | 2007-02-16 22:25:34 +0000 | [diff] [blame] | 524 | // Packed structure types always have an ABI alignment of one. |
Chris Lattner | 3ebb2e0 | 2007-02-16 23:11:51 +0000 | [diff] [blame] | 525 | if (cast<StructType>(Ty)->isPacked() && abi_or_pref) |
Chris Lattner | ae6f1fa | 2007-02-16 22:25:34 +0000 | [diff] [blame] | 526 | return 1; |
Dan Gohman | 9fbb52d | 2009-02-16 23:14:14 +0000 | [diff] [blame] | 527 | |
Chris Lattner | ae6f1fa | 2007-02-16 22:25:34 +0000 | [diff] [blame] | 528 | // Get the layout annotation... which is lazily created on demand. |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 529 | const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); |
Chris Lattner | 9c4428b | 2008-01-10 00:30:57 +0000 | [diff] [blame] | 530 | unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty); |
Dan Gohman | b68f274 | 2010-08-11 18:15:01 +0000 | [diff] [blame] | 531 | return std::max(Align, Layout->getAlignment()); |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 532 | } |
| 533 | case Type::IntegerTyID: |
| 534 | case Type::VoidTyID: |
| 535 | AlignType = INTEGER_ALIGN; |
| 536 | break; |
| 537 | case Type::FloatTyID: |
| 538 | case Type::DoubleTyID: |
Dale Johannesen | 8c1e6a1 | 2007-08-03 20:20:50 +0000 | [diff] [blame] | 539 | // PPC_FP128TyID and FP128TyID have different data contents, but the |
| 540 | // same size and alignment, so they look the same here. |
| 541 | case Type::PPC_FP128TyID: |
| 542 | case Type::FP128TyID: |
| 543 | case Type::X86_FP80TyID: |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 544 | AlignType = FLOAT_ALIGN; |
| 545 | break; |
Dale Johannesen | 29fc6f3 | 2010-09-15 00:52:23 +0000 | [diff] [blame] | 546 | case Type::X86_MMXTyID: |
Chris Lattner | 9c4428b | 2008-01-10 00:30:57 +0000 | [diff] [blame] | 547 | case Type::VectorTyID: |
| 548 | AlignType = VECTOR_ALIGN; |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 549 | break; |
| 550 | default: |
Torok Edwin | c23197a | 2009-07-14 16:55:14 +0000 | [diff] [blame] | 551 | llvm_unreachable("Bad type for getAlignment!!!"); |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 552 | break; |
| 553 | } |
| 554 | |
Duncan Sands | 514ab34 | 2007-11-01 20:53:16 +0000 | [diff] [blame] | 555 | return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty), |
Chris Lattner | 9c4428b | 2008-01-10 00:30:57 +0000 | [diff] [blame] | 556 | abi_or_pref, Ty); |
Chris Lattner | 58092e3 | 2007-01-20 22:35:55 +0000 | [diff] [blame] | 557 | } |
| 558 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 559 | unsigned TargetData::getABITypeAlignment(Type *Ty) const { |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 560 | return getAlignment(Ty, true); |
| 561 | } |
| 562 | |
Chris Lattner | da63b3a | 2010-01-25 23:18:11 +0000 | [diff] [blame] | 563 | /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for |
| 564 | /// an integer type of the specified bitwidth. |
Dan Gohman | b68f274 | 2010-08-11 18:15:01 +0000 | [diff] [blame] | 565 | unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const { |
Chris Lattner | da63b3a | 2010-01-25 23:18:11 +0000 | [diff] [blame] | 566 | return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0); |
| 567 | } |
| 568 | |
| 569 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 570 | unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const { |
Rafael Espindola | 588af2f | 2007-09-07 14:52:14 +0000 | [diff] [blame] | 571 | for (unsigned i = 0, e = Alignments.size(); i != e; ++i) |
| 572 | if (Alignments[i].AlignType == STACK_ALIGN) |
| 573 | return Alignments[i].ABIAlign; |
| 574 | |
| 575 | return getABITypeAlignment(Ty); |
| 576 | } |
| 577 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 578 | unsigned TargetData::getPrefTypeAlignment(Type *Ty) const { |
Chris Lattner | d2b7cec | 2007-02-14 05:52:17 +0000 | [diff] [blame] | 579 | return getAlignment(Ty, false); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 580 | } |
| 581 | |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 582 | unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const { |
Dan Gohman | b68f274 | 2010-08-11 18:15:01 +0000 | [diff] [blame] | 583 | unsigned Align = getPrefTypeAlignment(Ty); |
Chris Lattner | d2b0bb4 | 2004-08-17 19:13:00 +0000 | [diff] [blame] | 584 | assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); |
Chris Lattner | 0561b3f | 2005-08-02 19:26:06 +0000 | [diff] [blame] | 585 | return Log2_32(Align); |
Chris Lattner | d2b0bb4 | 2004-08-17 19:13:00 +0000 | [diff] [blame] | 586 | } |
| 587 | |
Chris Lattner | f045328 | 2003-12-22 05:01:15 +0000 | [diff] [blame] | 588 | /// getIntPtrType - Return an unsigned integer type that is the same size or |
| 589 | /// greater to the host pointer size. |
Tobias Grosser | e3f5ae7 | 2011-07-12 11:36:58 +0000 | [diff] [blame] | 590 | IntegerType *TargetData::getIntPtrType(LLVMContext &C) const { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 591 | return IntegerType::get(C, getPointerSizeInBits()); |
Chris Lattner | f045328 | 2003-12-22 05:01:15 +0000 | [diff] [blame] | 592 | } |
| 593 | |
| 594 | |
Jay Foad | 8fbbb39 | 2011-07-19 14:01:37 +0000 | [diff] [blame] | 595 | uint64_t TargetData::getIndexedOffset(Type *ptrTy, |
| 596 | ArrayRef<Value *> Indices) const { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 597 | Type *Ty = ptrTy; |
Duncan Sands | 1df9859 | 2010-02-16 11:11:14 +0000 | [diff] [blame] | 598 | assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); |
Vikram S. Adve | f66723f | 2002-05-19 15:28:02 +0000 | [diff] [blame] | 599 | uint64_t Result = 0; |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 600 | |
Chris Lattner | ddce8d2 | 2007-02-10 19:33:15 +0000 | [diff] [blame] | 601 | generic_gep_type_iterator<Value* const*> |
Jay Foad | ca12a21 | 2011-07-19 14:42:50 +0000 | [diff] [blame] | 602 | TI = gep_type_begin(ptrTy, Indices); |
Jay Foad | 8fbbb39 | 2011-07-19 14:01:37 +0000 | [diff] [blame] | 603 | for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX; |
| 604 | ++CurIDX, ++TI) { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 605 | if (StructType *STy = dyn_cast<StructType>(*TI)) { |
Owen Anderson | 1d0be15 | 2009-08-13 21:58:54 +0000 | [diff] [blame] | 606 | assert(Indices[CurIDX]->getType() == |
| 607 | Type::getInt32Ty(ptrTy->getContext()) && |
Reid Spencer | 1ede29c | 2007-03-01 19:48:16 +0000 | [diff] [blame] | 608 | "Illegal struct idx"); |
Chris Lattner | ddce8d2 | 2007-02-10 19:33:15 +0000 | [diff] [blame] | 609 | unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue(); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 610 | |
| 611 | // Get structure layout information... |
| 612 | const StructLayout *Layout = getStructLayout(STy); |
| 613 | |
| 614 | // Add in the offset, as calculated by the structure layout info... |
Chris Lattner | b1919e2 | 2007-02-10 19:55:17 +0000 | [diff] [blame] | 615 | Result += Layout->getElementOffset(FieldNo); |
Vikram S. Adve | ed0030e | 2002-08-04 20:52:39 +0000 | [diff] [blame] | 616 | |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 617 | // Update Ty to refer to current element |
Chris Lattner | d21cd80 | 2004-02-09 04:37:31 +0000 | [diff] [blame] | 618 | Ty = STy->getElementType(FieldNo); |
Chris Lattner | 28977af | 2004-04-05 01:30:19 +0000 | [diff] [blame] | 619 | } else { |
| 620 | // Update Ty to refer to current element |
| 621 | Ty = cast<SequentialType>(Ty)->getElementType(); |
| 622 | |
| 623 | // Get the array index and the size of each array element. |
Chris Lattner | 34e9d17 | 2010-04-17 19:02:33 +0000 | [diff] [blame] | 624 | if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue()) |
Dan Gohman | 67d0498 | 2010-07-28 17:11:36 +0000 | [diff] [blame] | 625 | Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty); |
Chris Lattner | e7fb360 | 2001-08-27 16:00:15 +0000 | [diff] [blame] | 626 | } |
| 627 | } |
| 628 | |
| 629 | return Result; |
| 630 | } |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 631 | |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 632 | /// getPreferredAlignment - Return the preferred alignment of the specified |
| 633 | /// global. This includes an explicitly requested alignment (if the global |
| 634 | /// has one). |
| 635 | unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const { |
Chris Lattner | db125cf | 2011-07-18 04:54:35 +0000 | [diff] [blame] | 636 | Type *ElemType = GV->getType()->getElementType(); |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 637 | unsigned Alignment = getPrefTypeAlignment(ElemType); |
Cameron Zwarich | d8b88d8 | 2011-04-13 06:03:16 +0000 | [diff] [blame] | 638 | unsigned GVAlignment = GV->getAlignment(); |
| 639 | if (GVAlignment >= Alignment) { |
| 640 | Alignment = GVAlignment; |
| 641 | } else if (GVAlignment != 0) { |
Cameron Zwarich | eb04a33 | 2011-04-13 09:02:43 +0000 | [diff] [blame] | 642 | Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType)); |
Cameron Zwarich | d8b88d8 | 2011-04-13 06:03:16 +0000 | [diff] [blame] | 643 | } |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 644 | |
Cameron Zwarich | 1335022 | 2011-04-13 20:36:04 +0000 | [diff] [blame] | 645 | if (GV->hasInitializer() && GVAlignment == 0) { |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 646 | if (Alignment < 16) { |
| 647 | // If the global is not external, see if it is large. If so, give it a |
| 648 | // larger alignment. |
Dan Gohman | f860db2 | 2010-04-02 03:04:37 +0000 | [diff] [blame] | 649 | if (getTypeSizeInBits(ElemType) > 128) |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 650 | Alignment = 16; // 16-byte alignment. |
| 651 | } |
| 652 | } |
| 653 | return Alignment; |
| 654 | } |
| 655 | |
Devang Patel | f9c197e | 2006-10-24 20:32:14 +0000 | [diff] [blame] | 656 | /// getPreferredAlignmentLog - Return the preferred alignment of the |
| 657 | /// specified global, returned in log form. This includes an explicitly |
| 658 | /// requested alignment (if the global has one). |
| 659 | unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const { |
Duncan Sands | d102593 | 2008-01-29 06:23:44 +0000 | [diff] [blame] | 660 | return Log2_32(getPreferredAlignment(GV)); |
Devang Patel | f9c197e | 2006-10-24 20:32:14 +0000 | [diff] [blame] | 661 | } |