Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/IR/Type.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/Type.h - Classes for handling data types ------------*- C++ -*-===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This file contains the declaration of the Type class.  For more "Type"
10
// stuff, look in DerivedTypes.h.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_IR_TYPE_H
15
#define LLVM_IR_TYPE_H
16
17
#include "llvm/ADT/APFloat.h"
18
#include "llvm/ADT/ArrayRef.h"
19
#include "llvm/ADT/SmallPtrSet.h"
20
#include "llvm/Support/CBindingWrapping.h"
21
#include "llvm/Support/Casting.h"
22
#include "llvm/Support/Compiler.h"
23
#include "llvm/Support/ErrorHandling.h"
24
#include <cassert>
25
#include <cstdint>
26
#include <iterator>
27
28
namespace llvm {
29
30
template<class GraphType> struct GraphTraits;
31
class IntegerType;
32
class LLVMContext;
33
class PointerType;
34
class raw_ostream;
35
class StringRef;
36
37
/// The instances of the Type class are immutable: once they are created,
38
/// they are never changed.  Also note that only one instance of a particular
39
/// type is ever created.  Thus seeing if two types are equal is a matter of
40
/// doing a trivial pointer comparison. To enforce that no two equal instances
41
/// are created, Type instances can only be created via static factory methods
42
/// in class Type and in derived classes.  Once allocated, Types are never
43
/// free'd.
44
///
45
class Type {
46
public:
47
  //===--------------------------------------------------------------------===//
48
  /// Definitions of all of the base types for the Type system.  Based on this
49
  /// value, you can cast to a class defined in DerivedTypes.h.
50
  /// Note: If you add an element to this, you need to add an element to the
51
  /// Type::getPrimitiveType function, or else things will break!
52
  /// Also update LLVMTypeKind and LLVMGetTypeKind () in the C binding.
53
  ///
54
  enum TypeID {
55
    // PrimitiveTypes - make sure LastPrimitiveTyID stays up to date.
56
    VoidTyID = 0,    ///<  0: type with no size
57
    HalfTyID,        ///<  1: 16-bit floating point type
58
    FloatTyID,       ///<  2: 32-bit floating point type
59
    DoubleTyID,      ///<  3: 64-bit floating point type
60
    X86_FP80TyID,    ///<  4: 80-bit floating point type (X87)
61
    FP128TyID,       ///<  5: 128-bit floating point type (112-bit mantissa)
62
    PPC_FP128TyID,   ///<  6: 128-bit floating point type (two 64-bits, PowerPC)
63
    LabelTyID,       ///<  7: Labels
64
    MetadataTyID,    ///<  8: Metadata
65
    X86_MMXTyID,     ///<  9: MMX vectors (64 bits, X86 specific)
66
    TokenTyID,       ///< 10: Tokens
67
68
    // Derived types... see DerivedTypes.h file.
69
    // Make sure FirstDerivedTyID stays up to date!
70
    IntegerTyID,     ///< 11: Arbitrary bit width integers
71
    FunctionTyID,    ///< 12: Functions
72
    StructTyID,      ///< 13: Structures
73
    ArrayTyID,       ///< 14: Arrays
74
    PointerTyID,     ///< 15: Pointers
75
    VectorTyID       ///< 16: SIMD 'packed' format, or other vector type
76
  };
77
78
private:
79
  /// This refers to the LLVMContext in which this type was uniqued.
80
  LLVMContext &Context;
81
82
  TypeID   ID : 8;            // The current base type of this type.
83
  unsigned SubclassData : 24; // Space for subclasses to store data.
84
                              // Note that this should be synchronized with
85
                              // MAX_INT_BITS value in IntegerType class.
86
87
protected:
88
  friend class LLVMContextImpl;
89
90
  explicit Type(LLVMContext &C, TypeID tid)
91
5.53M
    : Context(C), ID(tid), SubclassData(0) {}
92
  ~Type() = default;
93
94
3.36G
  unsigned getSubclassData() const { return SubclassData; }
95
96
4.00M
  void setSubclassData(unsigned val) {
97
4.00M
    SubclassData = val;
98
4.00M
    // Ensure we don't have any accidental truncation.
99
4.00M
    assert(getSubclassData() == val && "Subclass data too large for field");
100
4.00M
  }
101
102
  /// Keeps track of how many Type*'s there are in the ContainedTys list.
103
  unsigned NumContainedTys = 0;
104
105
  /// A pointer to the array of Types contained by this Type. For example, this
106
  /// includes the arguments of a function type, the elements of a structure,
107
  /// the pointee of a pointer, the element type of an array, etc. This pointer
108
  /// may be 0 for types that don't contain other types (Integer, Double,
109
  /// Float).
110
  Type * const *ContainedTys = nullptr;
111
112
0
  static bool isSequentialType(TypeID TyID) {
113
0
    return TyID == ArrayTyID || TyID == VectorTyID;
114
0
  }
115
116
public:
117
  /// Print the current type.
118
  /// Omit the type details if \p NoDetails == true.
119
  /// E.g., let %st = type { i32, i16 }
120
  /// When \p NoDetails is true, we only print %st.
121
  /// Put differently, \p NoDetails prints the type as if
122
  /// inlined with the operands when printing an instruction.
123
  void print(raw_ostream &O, bool IsForDebug = false,
124
             bool NoDetails = false) const;
125
126
  void dump() const;
127
128
  /// Return the LLVMContext in which this type was uniqued.
129
2.42G
  LLVMContext &getContext() const { return Context; }
130
131
  //===--------------------------------------------------------------------===//
132
  // Accessors for working with types.
133
  //
134
135
  /// Return the type id for the type. This will return one of the TypeID enum
136
  /// elements defined above.
137
18.9G
  TypeID getTypeID() const { return ID; }
138
139
  /// Return true if this is 'void'.
140
215M
  bool isVoidTy() const { return getTypeID() == VoidTyID; }
141
142
  /// Return true if this is 'half', a 16-bit IEEE fp type.
143
25.8M
  bool isHalfTy() const { return getTypeID() == HalfTyID; }
144
145
  /// Return true if this is 'float', a 32-bit IEEE fp type.
146
26.0M
  bool isFloatTy() const { return getTypeID() == FloatTyID; }
147
148
  /// Return true if this is 'double', a 64-bit IEEE fp type.
149
25.4M
  bool isDoubleTy() const { return getTypeID() == DoubleTyID; }
150
151
  /// Return true if this is x86 long double.
152
3.02M
  bool isX86_FP80Ty() const { return getTypeID() == X86_FP80TyID; }
153
154
  /// Return true if this is 'fp128'.
155
51.9k
  bool isFP128Ty() const { return getTypeID() == FP128TyID; }
156
157
  /// Return true if this is powerpc long double.
158
3.15M
  bool isPPC_FP128Ty() const { return getTypeID() == PPC_FP128TyID; }
159
160
  /// Return true if this is one of the six floating-point types
161
471M
  bool isFloatingPointTy() const {
162
471M
    return getTypeID() == HalfTyID || 
getTypeID() == FloatTyID471M
||
163
471M
           
getTypeID() == DoubleTyID450M
||
164
471M
           
getTypeID() == X86_FP80TyID400M
||
getTypeID() == FP128TyID400M
||
165
471M
           
getTypeID() == PPC_FP128TyID400M
;
166
471M
  }
167
168
67.2k
  const fltSemantics &getFltSemantics() const {
169
67.2k
    switch (getTypeID()) {
170
67.2k
    
case HalfTyID: return APFloat::IEEEhalf()40
;
171
67.2k
    
case FloatTyID: return APFloat::IEEEsingle()12.7k
;
172
67.2k
    
case DoubleTyID: return APFloat::IEEEdouble()54.5k
;
173
67.2k
    
case X86_FP80TyID: return APFloat::x87DoubleExtended()33
;
174
67.2k
    
case FP128TyID: return APFloat::IEEEquad()16
;
175
67.2k
    
case PPC_FP128TyID: return APFloat::PPCDoubleDouble()7
;
176
67.2k
    
default: 0
llvm_unreachable0
("Invalid floating type");
177
67.2k
    }
178
67.2k
  }
179
180
  /// Return true if this is X86 MMX.
181
12.3M
  bool isX86_MMXTy() const { return getTypeID() == X86_MMXTyID; }
182
183
  /// Return true if this is a FP type or a vector of FP.
184
85.4M
  bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
185
186
  /// Return true if this is 'label'.
187
9.51M
  bool isLabelTy() const { return getTypeID() == LabelTyID; }
188
189
  /// Return true if this is 'metadata'.
190
50.1M
  bool isMetadataTy() const { return getTypeID() == MetadataTyID; }
191
192
  /// Return true if this is 'token'.
193
36.7M
  bool isTokenTy() const { return getTypeID() == TokenTyID; }
194
195
  /// True if this is an instance of IntegerType.
196
1.01G
  bool isIntegerTy() const { return getTypeID() == IntegerTyID; }
197
198
  /// Return true if this is an IntegerType of the given width.
199
  bool isIntegerTy(unsigned Bitwidth) const;
200
201
  /// Return true if this is an integer type or a vector of integer types.
202
558M
  bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
203
204
  /// Return true if this is an integer type or a vector of integer types of
205
  /// the given width.
206
138M
  bool isIntOrIntVectorTy(unsigned BitWidth) const {
207
138M
    return getScalarType()->isIntegerTy(BitWidth);
208
138M
  }
209
210
  /// Return true if this is an integer type or a pointer type.
211
43.2M
  bool isIntOrPtrTy() const { return isIntegerTy() || 
isPointerTy()28.0M
; }
212
213
  /// True if this is an instance of FunctionType.
214
8.64M
  bool isFunctionTy() const { return getTypeID() == FunctionTyID; }
215
216
  /// True if this is an instance of StructType.
217
69.6M
  bool isStructTy() const { return getTypeID() == StructTyID; }
218
219
  /// True if this is an instance of ArrayType.
220
5.08M
  bool isArrayTy() const { return getTypeID() == ArrayTyID; }
221
222
  /// True if this is an instance of PointerType.
223
3.00G
  bool isPointerTy() const { return getTypeID() == PointerTyID; }
224
225
  /// Return true if this is a pointer type or a vector of pointer types.
226
40.2M
  bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }
227
228
  /// True if this is an instance of VectorType.
229
4.24G
  bool isVectorTy() const { return getTypeID() == VectorTyID; }
230
231
  /// Return true if this type could be converted with a lossless BitCast to
232
  /// type 'Ty'. For example, i8* to i32*. BitCasts are valid for types of the
233
  /// same size only where no re-interpretation of the bits is done.
234
  /// Determine if this type could be losslessly bitcast to Ty
235
  bool canLosslesslyBitCastTo(Type *Ty) const;
236
237
  /// Return true if this type is empty, that is, it has no elements or all of
238
  /// its elements are empty.
239
  bool isEmptyTy() const;
240
241
  /// Return true if the type is "first class", meaning it is a valid type for a
242
  /// Value.
243
26.2M
  bool isFirstClassType() const {
244
26.2M
    return 
getTypeID() != FunctionTyID26.2M
&& getTypeID() != VoidTyID;
245
26.2M
  }
246
247
  /// Return true if the type is a valid type for a register in codegen. This
248
  /// includes all first-class types except struct and array types.
249
6.28M
  bool isSingleValueType() const {
250
6.28M
    return isFloatingPointTy() || 
isX86_MMXTy()5.95M
||
isIntegerTy()5.95M
||
251
6.28M
           
isPointerTy()2.69M
||
isVectorTy()223k
;
252
6.28M
  }
253
254
  /// Return true if the type is an aggregate type. This means it is valid as
255
  /// the first operand of an insertvalue or extractvalue instruction. This
256
  /// includes struct and array types, but does not include vector types.
257
37.4M
  bool isAggregateType() const {
258
37.4M
    return getTypeID() == StructTyID || 
getTypeID() == ArrayTyID37.4M
;
259
37.4M
  }
260
261
  /// Return true if it makes sense to take the size of this type. To get the
262
  /// actual size for a particular target, it is reasonable to use the
263
  /// DataLayout subsystem to do this.
264
516M
  bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
265
516M
    // If it's a primitive, it is always sized.
266
516M
    if (getTypeID() == IntegerTyID || 
isFloatingPointTy()371M
||
267
516M
        
getTypeID() == PointerTyID312M
||
268
516M
        
getTypeID() == X86_MMXTyID277M
)
269
238M
      return true;
270
277M
    // If it is not something that can have a size (e.g. a function or label),
271
277M
    // it doesn't have a size.
272
277M
    if (getTypeID() != StructTyID && 
getTypeID() != ArrayTyID105M
&&
273
277M
        
getTypeID() != VectorTyID30.2M
)
274
249k
      return false;
275
277M
    // Otherwise we have to try harder to decide.
276
277M
    return isSizedDerivedType(Visited);
277
277M
  }
278
279
  /// Return the basic size of this type if it is a primitive type. These are
280
  /// fixed by LLVM and are not target-dependent.
281
  /// This will return zero if the type does not have a size or is not a
282
  /// primitive type.
283
  ///
284
  /// Note that this may not reflect the size of memory allocated for an
285
  /// instance of the type or the number of bytes that are written when an
286
  /// instance of the type is stored to memory. The DataLayout class provides
287
  /// additional query functions to provide this information.
288
  ///
289
  unsigned getPrimitiveSizeInBits() const LLVM_READONLY;
290
291
  /// If this is a vector type, return the getPrimitiveSizeInBits value for the
292
  /// element type. Otherwise return the getPrimitiveSizeInBits value for this
293
  /// type.
294
  unsigned getScalarSizeInBits() const LLVM_READONLY;
295
296
  /// Return the width of the mantissa of this type. This is only valid on
297
  /// floating-point types. If the FP type does not have a stable mantissa (e.g.
298
  /// ppc long double), this method returns -1.
299
  int getFPMantissaWidth() const;
300
301
  /// If this is a vector type, return the element type, otherwise return
302
  /// 'this'.
303
3.03G
  Type *getScalarType() const {
304
3.03G
    if (isVectorTy())
305
29.2M
      return getVectorElementType();
306
3.00G
    return const_cast<Type*>(this);
307
3.00G
  }
308
309
  //===--------------------------------------------------------------------===//
310
  // Type Iteration support.
311
  //
312
  using subtype_iterator = Type * const *;
313
314
590k
  subtype_iterator subtype_begin() const { return ContainedTys; }
315
590k
  subtype_iterator subtype_end() const { return &ContainedTys[NumContainedTys];}
316
59.1k
  ArrayRef<Type*> subtypes() const {
317
59.1k
    return makeArrayRef(subtype_begin(), subtype_end());
318
59.1k
  }
319
320
  using subtype_reverse_iterator = std::reverse_iterator<subtype_iterator>;
321
322
531k
  subtype_reverse_iterator subtype_rbegin() const {
323
531k
    return subtype_reverse_iterator(subtype_end());
324
531k
  }
325
531k
  subtype_reverse_iterator subtype_rend() const {
326
531k
    return subtype_reverse_iterator(subtype_begin());
327
531k
  }
328
329
  /// This method is used to implement the type iterator (defined at the end of
330
  /// the file). For derived types, this returns the types 'contained' in the
331
  /// derived type.
332
9.77k
  Type *getContainedType(unsigned i) const {
333
9.77k
    assert(i < NumContainedTys && "Index out of range!");
334
9.77k
    return ContainedTys[i];
335
9.77k
  }
336
337
  /// Return the number of types in the derived type.
338
6.12M
  unsigned getNumContainedTypes() const { return NumContainedTys; }
339
340
  //===--------------------------------------------------------------------===//
341
  // Helper methods corresponding to subclass methods.  This forces a cast to
342
  // the specified subclass and calls its accessor.  "getVectorNumElements" (for
343
  // example) is shorthand for cast<VectorType>(Ty)->getNumElements().  This is
344
  // only intended to cover the core methods that are frequently used, helper
345
  // methods should not be added here.
346
347
  inline unsigned getIntegerBitWidth() const;
348
349
  inline Type *getFunctionParamType(unsigned i) const;
350
  inline unsigned getFunctionNumParams() const;
351
  inline bool isFunctionVarArg() const;
352
353
  inline StringRef getStructName() const;
354
  inline unsigned getStructNumElements() const;
355
  inline Type *getStructElementType(unsigned N) const;
356
357
2.28M
  inline Type *getSequentialElementType() const {
358
2.28M
    assert(isSequentialType(getTypeID()) && "Not a sequential type!");
359
2.28M
    return ContainedTys[0];
360
2.28M
  }
361
362
  inline uint64_t getArrayNumElements() const;
363
364
21.8k
  Type *getArrayElementType() const {
365
21.8k
    assert(getTypeID() == ArrayTyID);
366
21.8k
    return ContainedTys[0];
367
21.8k
  }
368
369
  inline bool getVectorIsScalable() const;
370
  inline unsigned getVectorNumElements() const;
371
31.0M
  Type *getVectorElementType() const {
372
31.0M
    assert(getTypeID() == VectorTyID);
373
31.0M
    return ContainedTys[0];
374
31.0M
  }
375
376
20.1M
  Type *getPointerElementType() const {
377
20.1M
    assert(getTypeID() == PointerTyID);
378
20.1M
    return ContainedTys[0];
379
20.1M
  }
380
381
  /// Get the address space of this pointer or pointer vector type.
382
  inline unsigned getPointerAddressSpace() const;
383
384
  //===--------------------------------------------------------------------===//
385
  // Static members exported by the Type class itself.  Useful for getting
386
  // instances of Type.
387
  //
388
389
  /// Return a type based on an identifier.
390
  static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
391
392
  //===--------------------------------------------------------------------===//
393
  // These are the builtin types that are always available.
394
  //
395
  static Type *getVoidTy(LLVMContext &C);
396
  static Type *getLabelTy(LLVMContext &C);
397
  static Type *getHalfTy(LLVMContext &C);
398
  static Type *getFloatTy(LLVMContext &C);
399
  static Type *getDoubleTy(LLVMContext &C);
400
  static Type *getMetadataTy(LLVMContext &C);
401
  static Type *getX86_FP80Ty(LLVMContext &C);
402
  static Type *getFP128Ty(LLVMContext &C);
403
  static Type *getPPC_FP128Ty(LLVMContext &C);
404
  static Type *getX86_MMXTy(LLVMContext &C);
405
  static Type *getTokenTy(LLVMContext &C);
406
  static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
407
  static IntegerType *getInt1Ty(LLVMContext &C);
408
  static IntegerType *getInt8Ty(LLVMContext &C);
409
  static IntegerType *getInt16Ty(LLVMContext &C);
410
  static IntegerType *getInt32Ty(LLVMContext &C);
411
  static IntegerType *getInt64Ty(LLVMContext &C);
412
  static IntegerType *getInt128Ty(LLVMContext &C);
413
468k
  template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
414
468k
    int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
415
468k
    if (std::is_integral<ScalarTy>::value) {
416
468k
      return (Type*) Type::getIntNTy(C, noOfBits);
417
468k
    } else 
if (0
std::is_floating_point<ScalarTy>::value0
) {
418
0
      switch (noOfBits) {
419
0
      case 32:
420
0
        return Type::getFloatTy(C);
421
0
      case 64:
422
0
        return Type::getDoubleTy(C);
423
0
      }
424
0
    }
425
0
    llvm_unreachable("Unsupported type in Type::getScalarTy");
426
0
  }
llvm::Type* llvm::Type::getScalarTy<unsigned char>(llvm::LLVMContext&)
Line
Count
Source
413
437k
  template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
414
437k
    int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
415
437k
    if (std::is_integral<ScalarTy>::value) {
416
437k
      return (Type*) Type::getIntNTy(C, noOfBits);
417
437k
    } else 
if (0
std::is_floating_point<ScalarTy>::value0
) {
418
0
      switch (noOfBits) {
419
0
      case 32:
420
0
        return Type::getFloatTy(C);
421
0
      case 64:
422
0
        return Type::getDoubleTy(C);
423
0
      }
424
0
    }
425
0
    llvm_unreachable("Unsupported type in Type::getScalarTy");
426
0
  }
llvm::Type* llvm::Type::getScalarTy<unsigned short>(llvm::LLVMContext&)
Line
Count
Source
413
2.80k
  template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
414
2.80k
    int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
415
2.80k
    if (std::is_integral<ScalarTy>::value) {
416
2.80k
      return (Type*) Type::getIntNTy(C, noOfBits);
417
2.80k
    } else 
if (0
std::is_floating_point<ScalarTy>::value0
) {
418
0
      switch (noOfBits) {
419
0
      case 32:
420
0
        return Type::getFloatTy(C);
421
0
      case 64:
422
0
        return Type::getDoubleTy(C);
423
0
      }
424
0
    }
425
0
    llvm_unreachable("Unsupported type in Type::getScalarTy");
426
0
  }
llvm::Type* llvm::Type::getScalarTy<unsigned int>(llvm::LLVMContext&)
Line
Count
Source
413
18.3k
  template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
414
18.3k
    int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
415
18.3k
    if (std::is_integral<ScalarTy>::value) {
416
18.3k
      return (Type*) Type::getIntNTy(C, noOfBits);
417
18.3k
    } else 
if (0
std::is_floating_point<ScalarTy>::value0
) {
418
0
      switch (noOfBits) {
419
0
      case 32:
420
0
        return Type::getFloatTy(C);
421
0
      case 64:
422
0
        return Type::getDoubleTy(C);
423
0
      }
424
0
    }
425
0
    llvm_unreachable("Unsupported type in Type::getScalarTy");
426
0
  }
llvm::Type* llvm::Type::getScalarTy<unsigned long long>(llvm::LLVMContext&)
Line
Count
Source
413
9.69k
  template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
414
9.69k
    int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
415
9.69k
    if (std::is_integral<ScalarTy>::value) {
416
9.69k
      return (Type*) Type::getIntNTy(C, noOfBits);
417
9.69k
    } else 
if (0
std::is_floating_point<ScalarTy>::value0
) {
418
0
      switch (noOfBits) {
419
0
      case 32:
420
0
        return Type::getFloatTy(C);
421
0
      case 64:
422
0
        return Type::getDoubleTy(C);
423
0
      }
424
0
    }
425
0
    llvm_unreachable("Unsupported type in Type::getScalarTy");
426
0
  }
427
428
  //===--------------------------------------------------------------------===//
429
  // Convenience methods for getting pointer types with one of the above builtin
430
  // types as pointee.
431
  //
432
  static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
433
  static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
434
  static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
435
  static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
436
  static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
437
  static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
438
  static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
439
  static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
440
  static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
441
  static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
442
  static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
443
  static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
444
  static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
445
446
  /// Return a pointer to the current type. This is equivalent to
447
  /// PointerType::get(Foo, AddrSpace).
448
  PointerType *getPointerTo(unsigned AddrSpace = 0) const;
449
450
private:
451
  /// Derived types like structures and arrays are sized iff all of the members
452
  /// of the type are sized as well. Since asking for their size is relatively
453
  /// uncommon, move this operation out-of-line.
454
  bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
455
};
456
457
// Printing of types.
458
19.4k
inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
459
19.4k
  T.print(OS);
460
19.4k
  return OS;
461
19.4k
}
462
463
// allow isa<PointerType>(x) to work without DerivedTypes.h included.
464
template <> struct isa_impl<PointerType, Type> {
465
172M
  static inline bool doit(const Type &Ty) {
466
172M
    return Ty.getTypeID() == Type::PointerTyID;
467
172M
  }
468
};
469
470
// Create wrappers for C Binding types (see CBindingWrapping.h).
471
DEFINE_ISA_CONVERSION_FUNCTIONS(Type, LLVMTypeRef)
472
473
/* Specialized opaque type conversions.
474
 */
475
60
inline Type **unwrap(LLVMTypeRef* Tys) {
476
60
  return reinterpret_cast<Type**>(Tys);
477
60
}
478
479
0
inline LLVMTypeRef *wrap(Type **Tys) {
480
0
  return reinterpret_cast<LLVMTypeRef*>(const_cast<Type**>(Tys));
481
0
}
482
483
} // end namespace llvm
484
485
#endif // LLVM_IR_TYPE_H