Type.cpp revision 368eefa081d12f0a265ee90ee8ec61b54168d57d
1//===--- Type.cpp - Type representation and manipulation ------------------===// 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 implements type-related functionality. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/Type.h" 15#include "clang/AST/Decl.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/Expr.h" 18#include "clang/Basic/IdentifierTable.h" 19#include "clang/Basic/TargetInfo.h" 20#include "llvm/Support/Streams.h" 21#include "llvm/ADT/StringExtras.h" 22#include <sstream> 23using namespace clang; 24 25Type::~Type() {} 26 27/// isVoidType - Helper method to determine if this is the 'void' type. 28bool Type::isVoidType() const { 29 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 30 return BT->getKind() == BuiltinType::Void; 31 return false; 32} 33 34bool Type::isObjectType() const { 35 if (isa<FunctionType>(CanonicalType)) 36 return false; 37 else if (CanonicalType->isIncompleteType()) 38 return false; 39 else 40 return true; 41} 42 43bool Type::isDerivedType() const { 44 switch (CanonicalType->getTypeClass()) { 45 case Pointer: 46 case VariableArray: 47 case ConstantArray: 48 case IncompleteArray: 49 case FunctionProto: 50 case FunctionNoProto: 51 case Reference: 52 return true; 53 case Tagged: { 54 const TagType *TT = cast<TagType>(CanonicalType); 55 const Decl::Kind Kind = TT->getDecl()->getKind(); 56 return Kind == Decl::Struct || Kind == Decl::Union; 57 } 58 default: 59 return false; 60 } 61} 62 63bool Type::isStructureType() const { 64 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) 65 if (RT->getDecl()->getKind() == Decl::Struct) 66 return true; 67 return false; 68} 69bool Type::isUnionType() const { 70 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) 71 if (RT->getDecl()->getKind() == Decl::Union) 72 return true; 73 return false; 74} 75 76bool Type::isComplexType() const { 77 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 78 return CT->getElementType()->isFloatingType(); 79 return false; 80} 81 82bool Type::isComplexIntegerType() const { 83 // Check for GCC complex integer extension. 84 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 85 return CT->getElementType()->isIntegerType(); 86 return false; 87} 88 89const ComplexType *Type::getAsComplexIntegerType() const { 90 // Are we directly a complex type? 91 if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) { 92 if (CTy->getElementType()->isIntegerType()) 93 return CTy; 94 } 95 // If the canonical form of this type isn't the right kind, reject it. 96 const ComplexType *CTy = dyn_cast<ComplexType>(CanonicalType); 97 if (!CTy || !CTy->getElementType()->isIntegerType()) 98 return 0; 99 100 // If this is a typedef for a complex type, strip the typedef off without 101 // losing all typedef information. 102 return getDesugaredType()->getAsComplexIntegerType(); 103} 104 105/// getDesugaredType - Return the specified type with any "sugar" removed from 106/// type type. This takes off typedefs, typeof's etc. If the outer level of 107/// the type is already concrete, it returns it unmodified. This is similar 108/// to getting the canonical type, but it doesn't remove *all* typedefs. For 109/// example, it return "T*" as "T*", (not as "int*"), because the pointer is 110/// concrete. 111const Type *Type::getDesugaredType() const { 112 if (const TypedefType *TDT = dyn_cast<TypedefType>(this)) 113 return TDT->LookThroughTypedefs().getTypePtr(); 114 if (const TypeOfExpr *TOE = dyn_cast<TypeOfExpr>(this)) 115 return TOE->getUnderlyingExpr()->getType().getTypePtr(); 116 if (const TypeOfType *TOT = dyn_cast<TypeOfType>(this)) 117 return TOT->getUnderlyingType().getTypePtr(); 118 return this; 119} 120 121 122const BuiltinType *Type::getAsBuiltinType() const { 123 // If this is directly a builtin type, return it. 124 if (const BuiltinType *BTy = dyn_cast<BuiltinType>(this)) 125 return BTy; 126 127 // If the canonical form of this type isn't a builtin type, reject it. 128 if (!isa<BuiltinType>(CanonicalType)) { 129 // Look through type qualifiers 130 if (isa<BuiltinType>(CanonicalType.getUnqualifiedType())) 131 return CanonicalType.getUnqualifiedType()->getAsBuiltinType(); 132 return 0; 133 } 134 135 // If this is a typedef for a builtin type, strip the typedef off without 136 // losing all typedef information. 137 return getDesugaredType()->getAsBuiltinType(); 138} 139 140const FunctionType *Type::getAsFunctionType() const { 141 // If this is directly a function type, return it. 142 if (const FunctionType *FTy = dyn_cast<FunctionType>(this)) 143 return FTy; 144 145 // If the canonical form of this type isn't the right kind, reject it. 146 if (!isa<FunctionType>(CanonicalType)) { 147 // Look through type qualifiers 148 if (isa<FunctionType>(CanonicalType.getUnqualifiedType())) 149 return CanonicalType.getUnqualifiedType()->getAsFunctionType(); 150 return 0; 151 } 152 153 // If this is a typedef for a function type, strip the typedef off without 154 // losing all typedef information. 155 return getDesugaredType()->getAsFunctionType(); 156} 157 158const PointerLikeType *Type::getAsPointerLikeType() const { 159 // If this is directly a pointer-like type, return it. 160 if (const PointerLikeType *PTy = dyn_cast<PointerLikeType>(this)) 161 return PTy; 162 163 // If the canonical form of this type isn't the right kind, reject it. 164 if (!isa<PointerLikeType>(CanonicalType)) { 165 // Look through type qualifiers 166 if (isa<PointerLikeType>(CanonicalType.getUnqualifiedType())) 167 return CanonicalType.getUnqualifiedType()->getAsPointerLikeType(); 168 return 0; 169 } 170 171 // If this is a typedef for a pointer type, strip the typedef off without 172 // losing all typedef information. 173 return getDesugaredType()->getAsPointerLikeType(); 174} 175 176const PointerType *Type::getAsPointerType() const { 177 // If this is directly a pointer type, return it. 178 if (const PointerType *PTy = dyn_cast<PointerType>(this)) 179 return PTy; 180 181 // If the canonical form of this type isn't the right kind, reject it. 182 if (!isa<PointerType>(CanonicalType)) { 183 // Look through type qualifiers 184 if (isa<PointerType>(CanonicalType.getUnqualifiedType())) 185 return CanonicalType.getUnqualifiedType()->getAsPointerType(); 186 return 0; 187 } 188 189 // If this is a typedef for a pointer type, strip the typedef off without 190 // losing all typedef information. 191 return getDesugaredType()->getAsPointerType(); 192} 193 194const ReferenceType *Type::getAsReferenceType() const { 195 // If this is directly a reference type, return it. 196 if (const ReferenceType *RTy = dyn_cast<ReferenceType>(this)) 197 return RTy; 198 199 // If the canonical form of this type isn't the right kind, reject it. 200 if (!isa<ReferenceType>(CanonicalType)) { 201 // Look through type qualifiers 202 if (isa<ReferenceType>(CanonicalType.getUnqualifiedType())) 203 return CanonicalType.getUnqualifiedType()->getAsReferenceType(); 204 return 0; 205 } 206 207 // If this is a typedef for a reference type, strip the typedef off without 208 // losing all typedef information. 209 return getDesugaredType()->getAsReferenceType(); 210} 211 212const ArrayType *Type::getAsArrayType() const { 213 // If this is directly an array type, return it. 214 if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 215 return ATy; 216 217 // If the canonical form of this type isn't the right kind, reject it. 218 if (!isa<ArrayType>(CanonicalType)) { 219 // Look through type qualifiers 220 if (isa<ArrayType>(CanonicalType.getUnqualifiedType())) 221 return CanonicalType.getUnqualifiedType()->getAsArrayType(); 222 return 0; 223 } 224 225 // If this is a typedef for an array type, strip the typedef off without 226 // losing all typedef information. 227 return getDesugaredType()->getAsArrayType(); 228} 229 230const ConstantArrayType *Type::getAsConstantArrayType() const { 231 // If this is directly a constant array type, return it. 232 if (const ConstantArrayType *ATy = dyn_cast<ConstantArrayType>(this)) 233 return ATy; 234 235 // If the canonical form of this type isn't the right kind, reject it. 236 if (!isa<ConstantArrayType>(CanonicalType)) { 237 // Look through type qualifiers 238 if (isa<ConstantArrayType>(CanonicalType.getUnqualifiedType())) 239 return CanonicalType.getUnqualifiedType()->getAsConstantArrayType(); 240 return 0; 241 } 242 243 // If this is a typedef for a constant array type, strip the typedef off 244 // without losing all typedef information. 245 return getDesugaredType()->getAsConstantArrayType(); 246} 247 248const VariableArrayType *Type::getAsVariableArrayType() const { 249 // If this is directly a variable array type, return it. 250 if (const VariableArrayType *ATy = dyn_cast<VariableArrayType>(this)) 251 return ATy; 252 253 // If the canonical form of this type isn't the right kind, reject it. 254 if (!isa<VariableArrayType>(CanonicalType)) { 255 // Look through type qualifiers 256 if (isa<VariableArrayType>(CanonicalType.getUnqualifiedType())) 257 return CanonicalType.getUnqualifiedType()->getAsVariableArrayType(); 258 return 0; 259 } 260 261 // If this is a typedef for a variable array type, strip the typedef off 262 // without losing all typedef information. 263 return getDesugaredType()->getAsVariableArrayType(); 264} 265 266/// isVariablyModifiedType (C99 6.7.5p3) - Return true for variable length 267/// array types and types that contain variable array types in their 268/// declarator 269bool Type::isVariablyModifiedType() const { 270 // A VLA is a veriably modified type 271 if (getAsVariableArrayType()) 272 return true; 273 274 // An array can contain a variably modified type 275 if (const ArrayType* AT = getAsArrayType()) 276 return AT->getElementType()->isVariablyModifiedType(); 277 278 // A pointer can point to a variably modified type 279 if (const PointerType* PT = getAsPointerType()) 280 return PT->getPointeeType()->isVariablyModifiedType(); 281 282 // A function can return a variably modified type 283 // This one isn't completely obvious, but it follows from the 284 // definition in C99 6.7.5p3. Because of this rule, it's 285 // illegal to declare a function returning a variably modified type. 286 if (const FunctionType* FT = getAsFunctionType()) 287 return FT->getResultType()->isVariablyModifiedType(); 288 289 return false; 290} 291 292bool Type::isIncompleteArrayType() const { 293 return isa<IncompleteArrayType>(CanonicalType); 294} 295 296const IncompleteArrayType *Type::getAsIncompleteArrayType() const { 297 // If this is directly a variable array type, return it. 298 if (const IncompleteArrayType *ATy = dyn_cast<IncompleteArrayType>(this)) 299 return ATy; 300 301 // If the canonical form of this type isn't the right kind, reject it. 302 if (!isa<IncompleteArrayType>(CanonicalType)) { 303 // Look through type qualifiers 304 if (isa<IncompleteArrayType>(CanonicalType.getUnqualifiedType())) 305 return CanonicalType.getUnqualifiedType()->getAsIncompleteArrayType(); 306 return 0; 307 } 308 309 // If this is a typedef for a variable array type, strip the typedef off 310 // without losing all typedef information. 311 return getDesugaredType()->getAsIncompleteArrayType(); 312} 313 314const RecordType *Type::getAsRecordType() const { 315 // If this is directly a reference type, return it. 316 if (const RecordType *RTy = dyn_cast<RecordType>(this)) 317 return RTy; 318 319 // If the canonical form of this type isn't the right kind, reject it. 320 if (!isa<RecordType>(CanonicalType)) { 321 // Look through type qualifiers 322 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 323 return CanonicalType.getUnqualifiedType()->getAsRecordType(); 324 return 0; 325 } 326 327 // If this is a typedef for a record type, strip the typedef off without 328 // losing all typedef information. 329 return getDesugaredType()->getAsRecordType(); 330} 331 332const RecordType *Type::getAsStructureType() const { 333 // If this is directly a structure type, return it. 334 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 335 if (RT->getDecl()->getKind() == Decl::Struct) 336 return RT; 337 } 338 339 // If the canonical form of this type isn't the right kind, reject it. 340 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 341 if (RT->getDecl()->getKind() != Decl::Struct) 342 return 0; 343 344 // If this is a typedef for a structure type, strip the typedef off without 345 // losing all typedef information. 346 return getDesugaredType()->getAsStructureType(); 347 } 348 // Look through type qualifiers 349 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 350 return CanonicalType.getUnqualifiedType()->getAsStructureType(); 351 return 0; 352} 353 354const RecordType *Type::getAsUnionType() const { 355 // If this is directly a union type, return it. 356 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 357 if (RT->getDecl()->getKind() == Decl::Union) 358 return RT; 359 } 360 361 // If the canonical form of this type isn't the right kind, reject it. 362 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 363 if (RT->getDecl()->getKind() != Decl::Union) 364 return 0; 365 366 // If this is a typedef for a union type, strip the typedef off without 367 // losing all typedef information. 368 return getDesugaredType()->getAsUnionType(); 369 } 370 371 // Look through type qualifiers 372 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 373 return CanonicalType.getUnqualifiedType()->getAsUnionType(); 374 return 0; 375} 376 377const ComplexType *Type::getAsComplexType() const { 378 // Are we directly a complex type? 379 if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) 380 return CTy; 381 382 // If the canonical form of this type isn't the right kind, reject it. 383 if (!isa<ComplexType>(CanonicalType)) { 384 // Look through type qualifiers 385 if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 386 return CanonicalType.getUnqualifiedType()->getAsComplexType(); 387 return 0; 388 } 389 390 // If this is a typedef for a complex type, strip the typedef off without 391 // losing all typedef information. 392 return getDesugaredType()->getAsComplexType(); 393} 394 395const VectorType *Type::getAsVectorType() const { 396 // Are we directly a vector type? 397 if (const VectorType *VTy = dyn_cast<VectorType>(this)) 398 return VTy; 399 400 // If the canonical form of this type isn't the right kind, reject it. 401 if (!isa<VectorType>(CanonicalType)) { 402 // Look through type qualifiers 403 if (isa<VectorType>(CanonicalType.getUnqualifiedType())) 404 return CanonicalType.getUnqualifiedType()->getAsVectorType(); 405 return 0; 406 } 407 408 // If this is a typedef for a vector type, strip the typedef off without 409 // losing all typedef information. 410 return getDesugaredType()->getAsVectorType(); 411} 412 413const OCUVectorType *Type::getAsOCUVectorType() const { 414 // Are we directly an OpenCU vector type? 415 if (const OCUVectorType *VTy = dyn_cast<OCUVectorType>(this)) 416 return VTy; 417 418 // If the canonical form of this type isn't the right kind, reject it. 419 if (!isa<OCUVectorType>(CanonicalType)) { 420 // Look through type qualifiers 421 if (isa<OCUVectorType>(CanonicalType.getUnqualifiedType())) 422 return CanonicalType.getUnqualifiedType()->getAsOCUVectorType(); 423 return 0; 424 } 425 426 // If this is a typedef for an ocuvector type, strip the typedef off without 427 // losing all typedef information. 428 return getDesugaredType()->getAsOCUVectorType(); 429} 430 431const ObjCInterfaceType *Type::getAsObjCInterfaceType() const { 432 // Are we directly an ObjCInterface type? 433 if (const ObjCInterfaceType *VTy = dyn_cast<ObjCInterfaceType>(this)) 434 return VTy; 435 436 // If the canonical form of this type isn't the right kind, reject it. 437 if (!isa<ObjCInterfaceType>(CanonicalType)) { 438 // Look through type qualifiers 439 if (isa<ObjCInterfaceType>(CanonicalType.getUnqualifiedType())) 440 return CanonicalType.getUnqualifiedType()->getAsObjCInterfaceType(); 441 return 0; 442 } 443 444 // If this is a typedef for an objc interface type, strip the typedef off 445 // without losing all typedef information. 446 return getDesugaredType()->getAsObjCInterfaceType(); 447} 448 449const ObjCQualifiedInterfaceType * 450Type::getAsObjCQualifiedInterfaceType() const { 451 // Are we directly an ObjCQualifiedInterfaceType? 452 if (const ObjCQualifiedInterfaceType *VTy = 453 dyn_cast<ObjCQualifiedInterfaceType>(this)) 454 return VTy; 455 456 // If the canonical form of this type isn't the right kind, reject it. 457 if (!isa<ObjCQualifiedInterfaceType>(CanonicalType)) { 458 // Look through type qualifiers 459 if (isa<ObjCQualifiedInterfaceType>(CanonicalType.getUnqualifiedType())) 460 return CanonicalType.getUnqualifiedType()-> 461 getAsObjCQualifiedInterfaceType(); 462 return 0; 463 } 464 465 // If this is a typedef for an objc qual interface type, strip the typedef off 466 // without losing all typedef information. 467 return getDesugaredType()->getAsObjCQualifiedInterfaceType(); 468} 469 470 471bool Type::isIntegerType() const { 472 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 473 return BT->getKind() >= BuiltinType::Bool && 474 BT->getKind() <= BuiltinType::LongLong; 475 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 476 if (TT->getDecl()->getKind() == Decl::Enum) 477 return true; 478 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 479 return VT->getElementType()->isIntegerType(); 480 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 481 return ASQT->getBaseType()->isIntegerType(); 482 return false; 483} 484 485bool Type::isIntegralType() const { 486 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 487 return BT->getKind() >= BuiltinType::Bool && 488 BT->getKind() <= BuiltinType::LongLong; 489 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 490 if (TT->getDecl()->getKind() == Decl::Enum) 491 return true; 492 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 493 return ASQT->getBaseType()->isIntegralType(); 494 return false; 495} 496 497bool Type::isEnumeralType() const { 498 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 499 return TT->getDecl()->getKind() == Decl::Enum; 500 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 501 return ASQT->getBaseType()->isEnumeralType(); 502 return false; 503} 504 505bool Type::isBooleanType() const { 506 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 507 return BT->getKind() == BuiltinType::Bool; 508 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 509 return ASQT->getBaseType()->isBooleanType(); 510 return false; 511} 512 513bool Type::isCharType() const { 514 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 515 return BT->getKind() == BuiltinType::Char_U || 516 BT->getKind() == BuiltinType::UChar || 517 BT->getKind() == BuiltinType::Char_S || 518 BT->getKind() == BuiltinType::SChar; 519 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 520 return ASQT->getBaseType()->isCharType(); 521 return false; 522} 523 524/// isSignedIntegerType - Return true if this is an integer type that is 525/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 526/// an enum decl which has a signed representation, or a vector of signed 527/// integer element type. 528bool Type::isSignedIntegerType() const { 529 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 530 return BT->getKind() >= BuiltinType::Char_S && 531 BT->getKind() <= BuiltinType::LongLong; 532 } 533 534 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 535 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 536 537 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 538 return VT->getElementType()->isSignedIntegerType(); 539 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 540 return ASQT->getBaseType()->isSignedIntegerType(); 541 return false; 542} 543 544/// isUnsignedIntegerType - Return true if this is an integer type that is 545/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 546/// decl which has an unsigned representation, or a vector of unsigned integer 547/// element type. 548bool Type::isUnsignedIntegerType() const { 549 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 550 return BT->getKind() >= BuiltinType::Bool && 551 BT->getKind() <= BuiltinType::ULongLong; 552 } 553 554 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 555 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 556 557 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 558 return VT->getElementType()->isUnsignedIntegerType(); 559 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 560 return ASQT->getBaseType()->isUnsignedIntegerType(); 561 return false; 562} 563 564bool Type::isFloatingType() const { 565 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 566 return BT->getKind() >= BuiltinType::Float && 567 BT->getKind() <= BuiltinType::LongDouble; 568 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 569 return CT->getElementType()->isFloatingType(); 570 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 571 return VT->getElementType()->isFloatingType(); 572 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 573 return ASQT->getBaseType()->isFloatingType(); 574 return false; 575} 576 577bool Type::isRealFloatingType() const { 578 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 579 return BT->getKind() >= BuiltinType::Float && 580 BT->getKind() <= BuiltinType::LongDouble; 581 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 582 return VT->getElementType()->isRealFloatingType(); 583 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 584 return ASQT->getBaseType()->isRealFloatingType(); 585 return false; 586} 587 588bool Type::isRealType() const { 589 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 590 return BT->getKind() >= BuiltinType::Bool && 591 BT->getKind() <= BuiltinType::LongDouble; 592 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 593 return TT->getDecl()->getKind() == Decl::Enum; 594 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 595 return VT->getElementType()->isRealType(); 596 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 597 return ASQT->getBaseType()->isRealType(); 598 return false; 599} 600 601bool Type::isArithmeticType() const { 602 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 603 return BT->getKind() != BuiltinType::Void; 604 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 605 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 606 // If a body isn't seen by the time we get here, return false. 607 return ET->getDecl()->isDefinition(); 608 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 609 return ASQT->getBaseType()->isArithmeticType(); 610 return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType); 611} 612 613bool Type::isScalarType() const { 614 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 615 return BT->getKind() != BuiltinType::Void; 616 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 617 if (TT->getDecl()->getKind() == Decl::Enum) 618 return true; 619 return false; 620 } 621 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 622 return ASQT->getBaseType()->isScalarType(); 623 return isa<PointerType>(CanonicalType) || isa<ComplexType>(CanonicalType) || 624 isa<ObjCQualifiedIdType>(CanonicalType); 625} 626 627bool Type::isAggregateType() const { 628 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 629 if (TT->getDecl()->getKind() == Decl::Struct) 630 return true; 631 return false; 632 } 633 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 634 return ASQT->getBaseType()->isAggregateType(); 635 return isa<ArrayType>(CanonicalType); 636} 637 638/// isConstantSizeType - Return true if this is not a variable sized type, 639/// according to the rules of C99 6.7.5p3. It is not legal to call this on 640/// incomplete types. 641bool Type::isConstantSizeType() const { 642 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 643 return ASQT->getBaseType()->isConstantSizeType(); 644 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 645 // The VAT must have a size, as it is known to be complete. 646 return !isa<VariableArrayType>(CanonicalType); 647} 648 649/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 650/// - a type that can describe objects, but which lacks information needed to 651/// determine its size. 652bool Type::isIncompleteType() const { 653 switch (CanonicalType->getTypeClass()) { 654 default: return false; 655 case ASQual: 656 return cast<ASQualType>(CanonicalType)->getBaseType()->isIncompleteType(); 657 case Builtin: 658 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 659 // be completed. 660 return isVoidType(); 661 case Tagged: 662 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 663 // forward declaration, but not a full definition (C99 6.2.5p22). 664 return !cast<TagType>(CanonicalType)->getDecl()->isDefinition(); 665 case IncompleteArray: 666 // An array of unknown size is an incomplete type (C99 6.2.5p22). 667 return true; 668 } 669} 670 671bool Type::isPromotableIntegerType() const { 672 if (const ASQualType *ASQT = dyn_cast<ASQualType>(CanonicalType)) 673 return ASQT->getBaseType()->isPromotableIntegerType(); 674 const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType); 675 if (!BT) return false; 676 switch (BT->getKind()) { 677 case BuiltinType::Bool: 678 case BuiltinType::Char_S: 679 case BuiltinType::Char_U: 680 case BuiltinType::SChar: 681 case BuiltinType::UChar: 682 case BuiltinType::Short: 683 case BuiltinType::UShort: 684 return true; 685 default: 686 return false; 687 } 688} 689 690const char *BuiltinType::getName() const { 691 switch (getKind()) { 692 default: assert(0 && "Unknown builtin type!"); 693 case Void: return "void"; 694 case Bool: return "_Bool"; 695 case Char_S: return "char"; 696 case Char_U: return "char"; 697 case SChar: return "signed char"; 698 case Short: return "short"; 699 case Int: return "int"; 700 case Long: return "long"; 701 case LongLong: return "long long"; 702 case UChar: return "unsigned char"; 703 case UShort: return "unsigned short"; 704 case UInt: return "unsigned int"; 705 case ULong: return "unsigned long"; 706 case ULongLong: return "unsigned long long"; 707 case Float: return "float"; 708 case Double: return "double"; 709 case LongDouble: return "long double"; 710 } 711} 712 713void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 714 arg_type_iterator ArgTys, 715 unsigned NumArgs, bool isVariadic) { 716 ID.AddPointer(Result.getAsOpaquePtr()); 717 for (unsigned i = 0; i != NumArgs; ++i) 718 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 719 ID.AddInteger(isVariadic); 720} 721 722void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID) { 723 Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic()); 724} 725 726void ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID, 727 ObjCProtocolDecl **protocols, 728 unsigned NumProtocols) { 729 for (unsigned i = 0; i != NumProtocols; i++) 730 ID.AddPointer(protocols[i]); 731} 732 733void ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID) { 734 Profile(ID, &Protocols[0], getNumProtocols()); 735} 736 737void ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID, 738 ObjCProtocolDecl **protocols, 739 unsigned NumProtocols) { 740 for (unsigned i = 0; i != NumProtocols; i++) 741 ID.AddPointer(protocols[i]); 742} 743 744void ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID) { 745 Profile(ID, &Protocols[0], getNumProtocols()); 746} 747 748/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to 749/// potentially looking through *all* consequtive typedefs. This returns the 750/// sum of the type qualifiers, so if you have: 751/// typedef const int A; 752/// typedef volatile A B; 753/// looking through the typedefs for B will give you "const volatile A". 754/// 755QualType TypedefType::LookThroughTypedefs() const { 756 // Usually, there is only a single level of typedefs, be fast in that case. 757 QualType FirstType = getDecl()->getUnderlyingType(); 758 if (!isa<TypedefType>(FirstType)) 759 return FirstType; 760 761 // Otherwise, do the fully general loop. 762 unsigned TypeQuals = 0; 763 const TypedefType *TDT = this; 764 while (1) { 765 QualType CurType = TDT->getDecl()->getUnderlyingType(); 766 767 768 /// FIXME: 769 /// FIXME: This is incorrect for ASQuals! 770 /// FIXME: 771 TypeQuals |= CurType.getCVRQualifiers(); 772 773 TDT = dyn_cast<TypedefType>(CurType); 774 if (TDT == 0) 775 return QualType(CurType.getTypePtr(), TypeQuals); 776 } 777} 778 779bool RecordType::classof(const TagType *TT) { 780 return isa<RecordDecl>(TT->getDecl()); 781} 782 783bool EnumType::classof(const TagType *TT) { 784 return isa<EnumDecl>(TT->getDecl()); 785} 786 787 788//===----------------------------------------------------------------------===// 789// Type Printing 790//===----------------------------------------------------------------------===// 791 792void QualType::dump(const char *msg) const { 793 std::string R = "identifier"; 794 getAsStringInternal(R); 795 if (msg) 796 fprintf(stderr, "%s: %s\n", msg, R.c_str()); 797 else 798 fprintf(stderr, "%s\n", R.c_str()); 799} 800 801static void AppendTypeQualList(std::string &S, unsigned TypeQuals) { 802 // Note: funkiness to ensure we get a space only between quals. 803 bool NonePrinted = true; 804 if (TypeQuals & QualType::Const) 805 S += "const", NonePrinted = false; 806 if (TypeQuals & QualType::Volatile) 807 S += (NonePrinted+" volatile"), NonePrinted = false; 808 if (TypeQuals & QualType::Restrict) 809 S += (NonePrinted+" restrict"), NonePrinted = false; 810} 811 812void QualType::getAsStringInternal(std::string &S) const { 813 if (isNull()) { 814 S += "NULL TYPE\n"; 815 return; 816 } 817 818 // Print qualifiers as appropriate. 819 if (unsigned Tq = getCVRQualifiers()) { 820 std::string TQS; 821 AppendTypeQualList(TQS, Tq); 822 if (!S.empty()) 823 S = TQS + ' ' + S; 824 else 825 S = TQS; 826 } 827 828 getTypePtr()->getAsStringInternal(S); 829} 830 831void BuiltinType::getAsStringInternal(std::string &S) const { 832 if (S.empty()) { 833 S = getName(); 834 } else { 835 // Prefix the basic type, e.g. 'int X'. 836 S = ' ' + S; 837 S = getName() + S; 838 } 839} 840 841void ComplexType::getAsStringInternal(std::string &S) const { 842 ElementType->getAsStringInternal(S); 843 S = "_Complex " + S; 844} 845 846void ASQualType::getAsStringInternal(std::string &S) const { 847 S = "__attribute__((address_space("+llvm::utostr_32(AddressSpace)+")))" + S; 848 BaseType->getAsStringInternal(S); 849} 850 851void PointerType::getAsStringInternal(std::string &S) const { 852 S = '*' + S; 853 854 // Handle things like 'int (*A)[4];' correctly. 855 // FIXME: this should include vectors, but vectors use attributes I guess. 856 if (isa<ArrayType>(getPointeeType())) 857 S = '(' + S + ')'; 858 859 getPointeeType().getAsStringInternal(S); 860} 861 862void ReferenceType::getAsStringInternal(std::string &S) const { 863 S = '&' + S; 864 865 // Handle things like 'int (&A)[4];' correctly. 866 // FIXME: this should include vectors, but vectors use attributes I guess. 867 if (isa<ArrayType>(getPointeeType())) 868 S = '(' + S + ')'; 869 870 getPointeeType().getAsStringInternal(S); 871} 872 873void ConstantArrayType::getAsStringInternal(std::string &S) const { 874 S += '['; 875 S += llvm::utostr(getSize().getZExtValue()); 876 S += ']'; 877 878 getElementType().getAsStringInternal(S); 879} 880 881void IncompleteArrayType::getAsStringInternal(std::string &S) const { 882 S += "[]"; 883 884 getElementType().getAsStringInternal(S); 885} 886 887void VariableArrayType::getAsStringInternal(std::string &S) const { 888 S += '['; 889 890 if (getIndexTypeQualifier()) { 891 AppendTypeQualList(S, getIndexTypeQualifier()); 892 S += ' '; 893 } 894 895 if (getSizeModifier() == Static) 896 S += "static"; 897 else if (getSizeModifier() == Star) 898 S += '*'; 899 900 if (getSizeExpr()) { 901 std::ostringstream s; 902 getSizeExpr()->printPretty(s); 903 S += s.str(); 904 } 905 S += ']'; 906 907 getElementType().getAsStringInternal(S); 908} 909 910void VectorType::getAsStringInternal(std::string &S) const { 911 S += " __attribute__((__vector_size__("; 912 // FIXME: should multiply by element size somehow. 913 S += llvm::utostr_32(NumElements*4); // convert back to bytes. 914 S += ")))"; 915 ElementType.getAsStringInternal(S); 916} 917 918void OCUVectorType::getAsStringInternal(std::string &S) const { 919 S += " __attribute__((ocu_vector_type("; 920 S += llvm::utostr_32(NumElements); 921 S += ")))"; 922 ElementType.getAsStringInternal(S); 923} 924 925void TypeOfExpr::getAsStringInternal(std::string &InnerString) const { 926 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'. 927 InnerString = ' ' + InnerString; 928 std::ostringstream s; 929 getUnderlyingExpr()->printPretty(s); 930 InnerString = "typeof(" + s.str() + ")" + InnerString; 931} 932 933void TypeOfType::getAsStringInternal(std::string &InnerString) const { 934 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(t) X'. 935 InnerString = ' ' + InnerString; 936 std::string Tmp; 937 getUnderlyingType().getAsStringInternal(Tmp); 938 InnerString = "typeof(" + Tmp + ")" + InnerString; 939} 940 941void FunctionTypeNoProto::getAsStringInternal(std::string &S) const { 942 // If needed for precedence reasons, wrap the inner part in grouping parens. 943 if (!S.empty()) 944 S = "(" + S + ")"; 945 946 S += "()"; 947 getResultType().getAsStringInternal(S); 948} 949 950void FunctionTypeProto::getAsStringInternal(std::string &S) const { 951 // If needed for precedence reasons, wrap the inner part in grouping parens. 952 if (!S.empty()) 953 S = "(" + S + ")"; 954 955 S += "("; 956 std::string Tmp; 957 for (unsigned i = 0, e = getNumArgs(); i != e; ++i) { 958 if (i) S += ", "; 959 getArgType(i).getAsStringInternal(Tmp); 960 S += Tmp; 961 Tmp.clear(); 962 } 963 964 if (isVariadic()) { 965 if (getNumArgs()) 966 S += ", "; 967 S += "..."; 968 } else if (getNumArgs() == 0) { 969 // Do not emit int() if we have a proto, emit 'int(void)'. 970 S += "void"; 971 } 972 973 S += ")"; 974 getResultType().getAsStringInternal(S); 975} 976 977 978void TypedefType::getAsStringInternal(std::string &InnerString) const { 979 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 980 InnerString = ' ' + InnerString; 981 InnerString = getDecl()->getIdentifier()->getName() + InnerString; 982} 983 984void ObjCInterfaceType::getAsStringInternal(std::string &InnerString) const { 985 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 986 InnerString = ' ' + InnerString; 987 InnerString = getDecl()->getIdentifier()->getName() + InnerString; 988} 989 990void ObjCQualifiedInterfaceType::getAsStringInternal( 991 std::string &InnerString) const { 992 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 993 InnerString = ' ' + InnerString; 994 std::string ObjCQIString = getDecl()->getName(); 995 ObjCQIString += '<'; 996 int num = getNumProtocols(); 997 for (int i = 0; i < num; i++) { 998 ObjCQIString += getProtocols(i)->getName(); 999 if (i < num-1) 1000 ObjCQIString += ','; 1001 } 1002 ObjCQIString += '>'; 1003 InnerString = ObjCQIString + InnerString; 1004} 1005 1006void ObjCQualifiedIdType::getAsStringInternal( 1007 std::string &InnerString) const { 1008 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1009 InnerString = ' ' + InnerString; 1010 std::string ObjCQIString = "id"; 1011 ObjCQIString += '<'; 1012 int num = getNumProtocols(); 1013 for (int i = 0; i < num; i++) { 1014 ObjCQIString += getProtocols(i)->getName(); 1015 if (i < num-1) 1016 ObjCQIString += ','; 1017 } 1018 ObjCQIString += '>'; 1019 InnerString = ObjCQIString + InnerString; 1020} 1021 1022void TagType::getAsStringInternal(std::string &InnerString) const { 1023 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1024 InnerString = ' ' + InnerString; 1025 1026 const char *Kind = getDecl()->getKindName(); 1027 const char *ID; 1028 if (const IdentifierInfo *II = getDecl()->getIdentifier()) 1029 ID = II->getName(); 1030 else 1031 ID = "<anonymous>"; 1032 1033 InnerString = std::string(Kind) + " " + ID + InnerString; 1034} 1035