← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Target/TargetData.cpp

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Target/TargetData.cpp
 
1
//===-- TargetData.cpp - Data size & alignment routines --------------------==//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file defines target properties related to datatype size/offset/alignment
 
11
// information.
 
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
 
 
19
#include "llvm/Target/TargetData.h"
 
20
#include "llvm/Constants.h"
 
21
#include "llvm/DerivedTypes.h"
 
22
#include "llvm/Module.h"
 
23
#include "llvm/Support/GetElementPtrTypeIterator.h"
 
24
#include "llvm/Support/MathExtras.h"
 
25
#include "llvm/Support/ManagedStatic.h"
 
26
#include "llvm/Support/ErrorHandling.h"
 
27
#include "llvm/Support/raw_ostream.h"
 
28
#include "llvm/System/Mutex.h"
 
29
#include "llvm/ADT/DenseMap.h"
 
30
#include <algorithm>
 
31
#include <cstdlib>
 
32
using namespace llvm;
 
33
 
 
34
// Handle the Pass registration stuff necessary to use TargetData's.
 
35
 
 
36
// Register the default SparcV9 implementation...
 
37
INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true);
 
38
char TargetData::ID = 0;
 
39
 
 
40
//===----------------------------------------------------------------------===//
 
41
// Support for StructLayout
 
42
//===----------------------------------------------------------------------===//
 
43
 
 
44
StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
 
45
  StructAlignment = 0;
 
46
  StructSize = 0;
 
47
  NumElements = ST->getNumElements();
 
48
 
 
49
  // Loop over each of the elements, placing them in memory.
 
50
  for (unsigned i = 0, e = NumElements; i != e; ++i) {
 
51
    const Type *Ty = ST->getElementType(i);
 
52
    unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
 
53
 
 
54
    // Add padding if necessary to align the data element properly.
 
55
    if ((StructSize & (TyAlign-1)) != 0)
 
56
      StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
 
57
 
 
58
    // Keep track of maximum alignment constraint.
 
59
    StructAlignment = std::max(TyAlign, StructAlignment);
 
60
 
 
61
    MemberOffsets[i] = StructSize;
 
62
    StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
 
63
  }
 
64
 
 
65
  // Empty structures have alignment of 1 byte.
 
66
  if (StructAlignment == 0) StructAlignment = 1;
 
67
 
 
68
  // Add padding to the end of the struct so that it could be put in an array
 
69
  // and all array elements would be aligned correctly.
 
70
  if ((StructSize & (StructAlignment-1)) != 0)
 
71
    StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
 
72
}
 
73
 
 
74
 
 
75
/// getElementContainingOffset - Given a valid offset into the structure,
 
76
/// return the structure index that contains it.
 
77
unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
 
78
  const uint64_t *SI =
 
79
    std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
 
80
  assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
 
81
  --SI;
 
82
  assert(*SI <= Offset && "upper_bound didn't work");
 
83
  assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
 
84
         (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
 
85
         "Upper bound didn't work!");
 
86
  
 
87
  // Multiple fields can have the same offset if any of them are zero sized.
 
88
  // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
 
89
  // at the i32 element, because it is the last element at that offset.  This is
 
90
  // the right one to return, because anything after it will have a higher
 
91
  // offset, implying that this element is non-empty.
 
92
  return SI-&MemberOffsets[0];
 
93
}
 
94
 
 
95
//===----------------------------------------------------------------------===//
 
96
// TargetAlignElem, TargetAlign support
 
97
//===----------------------------------------------------------------------===//
 
98
 
 
99
TargetAlignElem
 
100
TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
 
101
                     unsigned pref_align, uint32_t bit_width) {
 
102
  assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 
103
  TargetAlignElem retval;
 
104
  retval.AlignType = align_type;
 
105
  retval.ABIAlign = abi_align;
 
106
  retval.PrefAlign = pref_align;
 
107
  retval.TypeBitWidth = bit_width;
 
108
  return retval;
 
109
}
 
110
 
 
111
bool
 
112
TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
 
113
  return (AlignType == rhs.AlignType
 
114
          && ABIAlign == rhs.ABIAlign
 
115
          && PrefAlign == rhs.PrefAlign
 
116
          && TypeBitWidth == rhs.TypeBitWidth);
 
117
}
 
118
 
 
119
const TargetAlignElem TargetData::InvalidAlignmentElem =
 
120
                TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
 
121
 
 
122
//===----------------------------------------------------------------------===//
 
123
//                       TargetData Class Implementation
 
124
//===----------------------------------------------------------------------===//
 
125
 
 
126
/// getInt - Get an integer ignoring errors.
 
127
static unsigned getInt(StringRef R) {
 
128
  unsigned Result = 0;
 
129
  R.getAsInteger(10, Result);
 
130
  return Result;
 
131
}
 
132
 
 
133
void TargetData::init(StringRef Desc) {
 
134
  LayoutMap = 0;
 
135
  LittleEndian = false;
 
136
  PointerMemSize = 8;
 
137
  PointerABIAlign = 8;
 
138
  PointerPrefAlign = PointerABIAlign;
 
139
 
 
140
  // Default alignments
 
141
  setAlignment(INTEGER_ALIGN,   1,  1, 1);   // i1
 
142
  setAlignment(INTEGER_ALIGN,   1,  1, 8);   // i8
 
143
  setAlignment(INTEGER_ALIGN,   2,  2, 16);  // i16
 
144
  setAlignment(INTEGER_ALIGN,   4,  4, 32);  // i32
 
145
  setAlignment(INTEGER_ALIGN,   4,  8, 64);  // i64
 
146
  setAlignment(FLOAT_ALIGN,     4,  4, 32);  // float
 
147
  setAlignment(FLOAT_ALIGN,     8,  8, 64);  // double
 
148
  setAlignment(VECTOR_ALIGN,    8,  8, 64);  // v2i32, v1i64, ...
 
149
  setAlignment(VECTOR_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 
150
  setAlignment(AGGREGATE_ALIGN, 0,  8,  0);  // struct
 
151
 
 
152
  while (!Desc.empty()) {
 
153
    std::pair<StringRef, StringRef> Split = Desc.split('-');
 
154
    StringRef Token = Split.first;
 
155
    Desc = Split.second;
 
156
    
 
157
    if (Token.empty())
 
158
      continue;
 
159
    
 
160
    Split = Token.split(':');
 
161
    StringRef Specifier = Split.first;
 
162
    Token = Split.second;
 
163
    
 
164
    assert(!Specifier.empty() && "Can't be empty here");
 
165
    
 
166
    switch (Specifier[0]) {
 
167
    case 'E':
 
168
      LittleEndian = false;
 
169
      break;
 
170
    case 'e':
 
171
      LittleEndian = true;
 
172
      break;
 
173
    case 'p':
 
174
      Split = Token.split(':');
 
175
      PointerMemSize = getInt(Split.first) / 8;
 
176
      Split = Split.second.split(':');
 
177
      PointerABIAlign = getInt(Split.first) / 8;
 
178
      Split = Split.second.split(':');
 
179
      PointerPrefAlign = getInt(Split.first) / 8;
 
180
      if (PointerPrefAlign == 0)
 
181
        PointerPrefAlign = PointerABIAlign;
 
182
      break;
 
183
    case 'i':
 
184
    case 'v':
 
185
    case 'f':
 
186
    case 'a':
 
187
    case 's': {
 
188
      AlignTypeEnum AlignType;
 
189
      switch (Specifier[0]) {
 
190
      default:
 
191
      case 'i': AlignType = INTEGER_ALIGN; break;
 
192
      case 'v': AlignType = VECTOR_ALIGN; break;
 
193
      case 'f': AlignType = FLOAT_ALIGN; break;
 
194
      case 'a': AlignType = AGGREGATE_ALIGN; break;
 
195
      case 's': AlignType = STACK_ALIGN; break;
 
196
      }
 
197
      unsigned Size = getInt(Specifier.substr(1));
 
198
      Split = Token.split(':');
 
199
      unsigned ABIAlign = getInt(Split.first) / 8;
 
200
      
 
201
      Split = Split.second.split(':');
 
202
      unsigned PrefAlign = getInt(Split.first) / 8;
 
203
      if (PrefAlign == 0)
 
204
        PrefAlign = ABIAlign;
 
205
      setAlignment(AlignType, ABIAlign, PrefAlign, Size);
 
206
      break;
 
207
    }
 
208
    case 'n':  // Native integer types.
 
209
      Specifier = Specifier.substr(1);
 
210
      do {
 
211
        if (unsigned Width = getInt(Specifier))
 
212
          LegalIntWidths.push_back(Width);
 
213
        Split = Token.split(':');
 
214
        Specifier = Split.first;
 
215
        Token = Split.second;
 
216
      } while (!Specifier.empty() || !Token.empty());
 
217
      break;
 
218
        
 
219
    default:
 
220
      break;
 
221
    }
 
222
  }
 
223
}
 
224
 
 
225
/// Default ctor.
 
226
///
 
227
/// @note This has to exist, because this is a pass, but it should never be
 
228
/// used.
 
229
TargetData::TargetData() : ImmutablePass(ID) {
 
230
  report_fatal_error("Bad TargetData ctor used.  "
 
231
                    "Tool did not specify a TargetData to use?");
 
232
}
 
233
 
 
234
TargetData::TargetData(const Module *M) 
 
235
  : ImmutablePass(ID) {
 
236
  init(M->getDataLayout());
 
237
}
 
238
 
 
239
void
 
240
TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
 
241
                         unsigned pref_align, uint32_t bit_width) {
 
242
  assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 
243
  for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 
244
    if (Alignments[i].AlignType == align_type &&
 
245
        Alignments[i].TypeBitWidth == bit_width) {
 
246
      // Update the abi, preferred alignments.
 
247
      Alignments[i].ABIAlign = abi_align;
 
248
      Alignments[i].PrefAlign = pref_align;
 
249
      return;
 
250
    }
 
251
  }
 
252
  
 
253
  Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
 
254
                                            pref_align, bit_width));
 
255
}
 
256
 
 
257
/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or 
 
258
/// preferred if ABIInfo = false) the target wants for the specified datatype.
 
259
unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType, 
 
260
                                      uint32_t BitWidth, bool ABIInfo,
 
261
                                      const Type *Ty) const {
 
262
  // Check to see if we have an exact match and remember the best match we see.
 
263
  int BestMatchIdx = -1;
 
264
  int LargestInt = -1;
 
265
  for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 
266
    if (Alignments[i].AlignType == AlignType &&
 
267
        Alignments[i].TypeBitWidth == BitWidth)
 
268
      return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
 
269
    
 
270
    // The best match so far depends on what we're looking for.
 
271
     if (AlignType == INTEGER_ALIGN && 
 
272
         Alignments[i].AlignType == INTEGER_ALIGN) {
 
273
      // The "best match" for integers is the smallest size that is larger than
 
274
      // the BitWidth requested.
 
275
      if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 || 
 
276
           Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 
277
        BestMatchIdx = i;
 
278
      // However, if there isn't one that's larger, then we must use the
 
279
      // largest one we have (see below)
 
280
      if (LargestInt == -1 || 
 
281
          Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 
282
        LargestInt = i;
 
283
    }
 
284
  }
 
285
 
 
286
  // Okay, we didn't find an exact solution.  Fall back here depending on what
 
287
  // is being looked for.
 
288
  if (BestMatchIdx == -1) {
 
289
    // If we didn't find an integer alignment, fall back on most conservative.
 
290
    if (AlignType == INTEGER_ALIGN) {
 
291
      BestMatchIdx = LargestInt;
 
292
    } else {
 
293
      assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
 
294
 
 
295
      // By default, use natural alignment for vector types. This is consistent
 
296
      // with what clang and llvm-gcc do.
 
297
      unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
 
298
      Align *= cast<VectorType>(Ty)->getNumElements();
 
299
      // If the alignment is not a power of 2, round up to the next power of 2.
 
300
      // This happens for non-power-of-2 length vectors.
 
301
      if (Align & (Align-1))
 
302
        Align = llvm::NextPowerOf2(Align);
 
303
      return Align;
 
304
    }
 
305
  }
 
306
 
 
307
  // Since we got a "best match" index, just return it.
 
308
  return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 
309
                 : Alignments[BestMatchIdx].PrefAlign;
 
310
}
 
311
 
 
312
namespace {
 
313
 
 
314
class StructLayoutMap : public AbstractTypeUser {
 
315
  typedef DenseMap<const StructType*, StructLayout*> LayoutInfoTy;
 
316
  LayoutInfoTy LayoutInfo;
 
317
 
 
318
  void RemoveEntry(LayoutInfoTy::iterator I, bool WasAbstract) {
 
319
    I->second->~StructLayout();
 
320
    free(I->second);
 
321
    if (WasAbstract)
 
322
      I->first->removeAbstractTypeUser(this);
 
323
    LayoutInfo.erase(I);
 
324
  }
 
325
  
 
326
  
 
327
  /// refineAbstractType - The callback method invoked when an abstract type is
 
328
  /// resolved to another type.  An object must override this method to update
 
329
  /// its internal state to reference NewType instead of OldType.
 
330
  ///
 
331
  virtual void refineAbstractType(const DerivedType *OldTy,
 
332
                                  const Type *) {
 
333
    LayoutInfoTy::iterator I = LayoutInfo.find(cast<const StructType>(OldTy));
 
334
    assert(I != LayoutInfo.end() && "Using type but not in map?");
 
335
    RemoveEntry(I, true);
 
336
  }
 
337
 
 
338
  /// typeBecameConcrete - The other case which AbstractTypeUsers must be aware
 
339
  /// of is when a type makes the transition from being abstract (where it has
 
340
  /// clients on its AbstractTypeUsers list) to concrete (where it does not).
 
341
  /// This method notifies ATU's when this occurs for a type.
 
342
  ///
 
343
  virtual void typeBecameConcrete(const DerivedType *AbsTy) {
 
344
    LayoutInfoTy::iterator I = LayoutInfo.find(cast<const StructType>(AbsTy));
 
345
    assert(I != LayoutInfo.end() && "Using type but not in map?");
 
346
    RemoveEntry(I, true);
 
347
  }
 
348
 
 
349
public:
 
350
  virtual ~StructLayoutMap() {
 
351
    // Remove any layouts.
 
352
    for (LayoutInfoTy::iterator
 
353
           I = LayoutInfo.begin(), E = LayoutInfo.end(); I != E; ++I) {
 
354
      const Type *Key = I->first;
 
355
      StructLayout *Value = I->second;
 
356
 
 
357
      if (Key->isAbstract())
 
358
        Key->removeAbstractTypeUser(this);
 
359
 
 
360
      Value->~StructLayout();
 
361
      free(Value);
 
362
    }
 
363
  }
 
364
 
 
365
  void InvalidateEntry(const StructType *Ty) {
 
366
    LayoutInfoTy::iterator I = LayoutInfo.find(Ty);
 
367
    if (I == LayoutInfo.end()) return;
 
368
    RemoveEntry(I, Ty->isAbstract());
 
369
  }
 
370
 
 
371
  StructLayout *&operator[](const StructType *STy) {
 
372
    return LayoutInfo[STy];
 
373
  }
 
374
 
 
375
  // for debugging...
 
376
  virtual void dump() const {}
 
377
};
 
378
 
 
379
} // end anonymous namespace
 
380
 
 
381
TargetData::~TargetData() {
 
382
  delete static_cast<StructLayoutMap*>(LayoutMap);
 
383
}
 
384
 
 
385
const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 
386
  if (!LayoutMap)
 
387
    LayoutMap = new StructLayoutMap();
 
388
  
 
389
  StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
 
390
  StructLayout *&SL = (*STM)[Ty];
 
391
  if (SL) return SL;
 
392
 
 
393
  // Otherwise, create the struct layout.  Because it is variable length, we 
 
394
  // malloc it, then use placement new.
 
395
  int NumElts = Ty->getNumElements();
 
396
  StructLayout *L =
 
397
    (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
 
398
  
 
399
  // Set SL before calling StructLayout's ctor.  The ctor could cause other
 
400
  // entries to be added to TheMap, invalidating our reference.
 
401
  SL = L;
 
402
  
 
403
  new (L) StructLayout(Ty, *this);
 
404
 
 
405
  if (Ty->isAbstract())
 
406
    Ty->addAbstractTypeUser(STM);
 
407
 
 
408
  return L;
 
409
}
 
410
 
 
411
/// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 
412
/// objects.  If a TargetData object is alive when types are being refined and
 
413
/// removed, this method must be called whenever a StructType is removed to
 
414
/// avoid a dangling pointer in this cache.
 
415
void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 
416
  if (!LayoutMap) return;  // No cache.
 
417
  
 
418
  static_cast<StructLayoutMap*>(LayoutMap)->InvalidateEntry(Ty);
 
419
}
 
420
 
 
421
std::string TargetData::getStringRepresentation() const {
 
422
  std::string Result;
 
423
  raw_string_ostream OS(Result);
 
424
  
 
425
  OS << (LittleEndian ? "e" : "E")
 
426
     << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
 
427
     << ':' << PointerPrefAlign*8;
 
428
  for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 
429
    const TargetAlignElem &AI = Alignments[i];
 
430
    OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
 
431
       << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
 
432
  }
 
433
  
 
434
  if (!LegalIntWidths.empty()) {
 
435
    OS << "-n" << (unsigned)LegalIntWidths[0];
 
436
    
 
437
    for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
 
438
      OS << ':' << (unsigned)LegalIntWidths[i];
 
439
  }
 
440
  return OS.str();
 
441
}
 
442
 
 
443
 
 
444
uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 
445
  assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 
446
  switch (Ty->getTypeID()) {
 
447
  case Type::LabelTyID:
 
448
  case Type::PointerTyID:
 
449
    return getPointerSizeInBits();
 
450
  case Type::ArrayTyID: {
 
451
    const ArrayType *ATy = cast<ArrayType>(Ty);
 
452
    return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
 
453
  }
 
454
  case Type::StructTyID:
 
455
    // Get the layout annotation... which is lazily created on demand.
 
456
    return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
 
457
  case Type::IntegerTyID:
 
458
    return cast<IntegerType>(Ty)->getBitWidth();
 
459
  case Type::VoidTyID:
 
460
    return 8;
 
461
  case Type::FloatTyID:
 
462
    return 32;
 
463
  case Type::DoubleTyID:
 
464
    return 64;
 
465
  case Type::PPC_FP128TyID:
 
466
  case Type::FP128TyID:
 
467
    return 128;
 
468
  // In memory objects this is always aligned to a higher boundary, but
 
469
  // only 80 bits contain information.
 
470
  case Type::X86_FP80TyID:
 
471
    return 80;
 
472
  case Type::VectorTyID:
 
473
    return cast<VectorType>(Ty)->getBitWidth();
 
474
  default:
 
475
    llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
 
476
    break;
 
477
  }
 
478
  return 0;
 
479
}
 
480
 
 
481
/*!
 
482
  \param abi_or_pref Flag that determines which alignment is returned. true
 
483
  returns the ABI alignment, false returns the preferred alignment.
 
484
  \param Ty The underlying type for which alignment is determined.
 
485
 
 
486
  Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 
487
  == false) for the requested type \a Ty.
 
488
 */
 
489
unsigned TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 
490
  int AlignType = -1;
 
491
 
 
492
  assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 
493
  switch (Ty->getTypeID()) {
 
494
  // Early escape for the non-numeric types.
 
495
  case Type::LabelTyID:
 
496
  case Type::PointerTyID:
 
497
    return (abi_or_pref
 
498
            ? getPointerABIAlignment()
 
499
            : getPointerPrefAlignment());
 
500
  case Type::ArrayTyID:
 
501
    return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 
502
 
 
503
  case Type::StructTyID: {
 
504
    // Packed structure types always have an ABI alignment of one.
 
505
    if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 
506
      return 1;
 
507
 
 
508
    // Get the layout annotation... which is lazily created on demand.
 
509
    const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 
510
    unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
 
511
    return std::max(Align, Layout->getAlignment());
 
512
  }
 
513
  case Type::IntegerTyID:
 
514
  case Type::VoidTyID:
 
515
    AlignType = INTEGER_ALIGN;
 
516
    break;
 
517
  case Type::FloatTyID:
 
518
  case Type::DoubleTyID:
 
519
  // PPC_FP128TyID and FP128TyID have different data contents, but the
 
520
  // same size and alignment, so they look the same here.
 
521
  case Type::PPC_FP128TyID:
 
522
  case Type::FP128TyID:
 
523
  case Type::X86_FP80TyID:
 
524
    AlignType = FLOAT_ALIGN;
 
525
    break;
 
526
  case Type::VectorTyID:
 
527
    AlignType = VECTOR_ALIGN;
 
528
    break;
 
529
  default:
 
530
    llvm_unreachable("Bad type for getAlignment!!!");
 
531
    break;
 
532
  }
 
533
 
 
534
  return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
 
535
                          abi_or_pref, Ty);
 
536
}
 
537
 
 
538
unsigned TargetData::getABITypeAlignment(const Type *Ty) const {
 
539
  return getAlignment(Ty, true);
 
540
}
 
541
 
 
542
/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
 
543
/// an integer type of the specified bitwidth.
 
544
unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
 
545
  return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
 
546
}
 
547
 
 
548
 
 
549
unsigned TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
 
550
  for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
 
551
    if (Alignments[i].AlignType == STACK_ALIGN)
 
552
      return Alignments[i].ABIAlign;
 
553
 
 
554
  return getABITypeAlignment(Ty);
 
555
}
 
556
 
 
557
unsigned TargetData::getPrefTypeAlignment(const Type *Ty) const {
 
558
  return getAlignment(Ty, false);
 
559
}
 
560
 
 
561
unsigned TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 
562
  unsigned Align = getPrefTypeAlignment(Ty);
 
563
  assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 
564
  return Log2_32(Align);
 
565
}
 
566
 
 
567
/// getIntPtrType - Return an unsigned integer type that is the same size or
 
568
/// greater to the host pointer size.
 
569
const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
 
570
  return IntegerType::get(C, getPointerSizeInBits());
 
571
}
 
572
 
 
573
 
 
574
uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 
575
                                      unsigned NumIndices) const {
 
576
  const Type *Ty = ptrTy;
 
577
  assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
 
578
  uint64_t Result = 0;
 
579
 
 
580
  generic_gep_type_iterator<Value* const*>
 
581
    TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 
582
  for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 
583
    if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 
584
      assert(Indices[CurIDX]->getType() ==
 
585
             Type::getInt32Ty(ptrTy->getContext()) &&
 
586
             "Illegal struct idx");
 
587
      unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 
588
 
 
589
      // Get structure layout information...
 
590
      const StructLayout *Layout = getStructLayout(STy);
 
591
 
 
592
      // Add in the offset, as calculated by the structure layout info...
 
593
      Result += Layout->getElementOffset(FieldNo);
 
594
 
 
595
      // Update Ty to refer to current element
 
596
      Ty = STy->getElementType(FieldNo);
 
597
    } else {
 
598
      // Update Ty to refer to current element
 
599
      Ty = cast<SequentialType>(Ty)->getElementType();
 
600
 
 
601
      // Get the array index and the size of each array element.
 
602
      if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
 
603
        Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
 
604
    }
 
605
  }
 
606
 
 
607
  return Result;
 
608
}
 
609
 
 
610
/// getPreferredAlignment - Return the preferred alignment of the specified
 
611
/// global.  This includes an explicitly requested alignment (if the global
 
612
/// has one).
 
613
unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
 
614
  const Type *ElemType = GV->getType()->getElementType();
 
615
  unsigned Alignment = getPrefTypeAlignment(ElemType);
 
616
  if (GV->getAlignment() > Alignment)
 
617
    Alignment = GV->getAlignment();
 
618
 
 
619
  if (GV->hasInitializer()) {
 
620
    if (Alignment < 16) {
 
621
      // If the global is not external, see if it is large.  If so, give it a
 
622
      // larger alignment.
 
623
      if (getTypeSizeInBits(ElemType) > 128)
 
624
        Alignment = 16;    // 16-byte alignment.
 
625
    }
 
626
  }
 
627
  return Alignment;
 
628
}
 
629
 
 
630
/// getPreferredAlignmentLog - Return the preferred alignment of the
 
631
/// specified global, returned in log form.  This includes an explicitly
 
632
/// requested alignment (if the global has one).
 
633
unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 
634
  return Log2_32(getPreferredAlignment(GV));
 
635
}