Type.cpp revision 6946baf3542dcb1ed0d98d0fdda451d1c39a49c2
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/ASTContext.h" 15#include "clang/AST/Type.h" 16#include "clang/AST/DeclCXX.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/AST/Expr.h" 20#include "clang/AST/PrettyPrinter.h" 21#include "llvm/ADT/StringExtras.h" 22#include "llvm/Support/raw_ostream.h" 23using namespace clang; 24 25bool QualType::isConstant(ASTContext &Ctx) const { 26 if (isConstQualified()) 27 return true; 28 29 if (getTypePtr()->isArrayType()) 30 return Ctx.getAsArrayType(*this)->getElementType().isConstant(Ctx); 31 32 return false; 33} 34 35void Type::Destroy(ASTContext& C) { 36 this->~Type(); 37 C.Deallocate(this); 38} 39 40void ConstantArrayWithExprType::Destroy(ASTContext& C) { 41 // FIXME: destruction of SizeExpr commented out due to resource contention. 42 // SizeExpr->Destroy(C); 43 // See FIXME in SemaDecl.cpp:1536: if we were able to either steal 44 // or clone the SizeExpr there, then here we could freely delete it. 45 // Since we do not know how to steal or clone, we keep a pointer to 46 // a shared resource, but we cannot free it. 47 // (There probably is a trivial solution ... for people knowing clang!). 48 this->~ConstantArrayWithExprType(); 49 C.Deallocate(this); 50} 51 52void VariableArrayType::Destroy(ASTContext& C) { 53 if (SizeExpr) 54 SizeExpr->Destroy(C); 55 this->~VariableArrayType(); 56 C.Deallocate(this); 57} 58 59void DependentSizedArrayType::Destroy(ASTContext& C) { 60 // FIXME: Resource contention like in ConstantArrayWithExprType ? 61 // May crash, depending on platform or a particular build. 62 // SizeExpr->Destroy(C); 63 this->~DependentSizedArrayType(); 64 C.Deallocate(this); 65} 66 67void DependentSizedArrayType::Profile(llvm::FoldingSetNodeID &ID, 68 ASTContext &Context, 69 QualType ET, 70 ArraySizeModifier SizeMod, 71 unsigned TypeQuals, 72 Expr *E) { 73 ID.AddPointer(ET.getAsOpaquePtr()); 74 ID.AddInteger(SizeMod); 75 ID.AddInteger(TypeQuals); 76 E->Profile(ID, Context, true); 77} 78 79void 80DependentSizedExtVectorType::Profile(llvm::FoldingSetNodeID &ID, 81 ASTContext &Context, 82 QualType ElementType, Expr *SizeExpr) { 83 ID.AddPointer(ElementType.getAsOpaquePtr()); 84 SizeExpr->Profile(ID, Context, true); 85} 86 87void DependentSizedExtVectorType::Destroy(ASTContext& C) { 88 // FIXME: Deallocate size expression, once we're cloning properly. 89// if (SizeExpr) 90// SizeExpr->Destroy(C); 91 this->~DependentSizedExtVectorType(); 92 C.Deallocate(this); 93} 94 95/// getArrayElementTypeNoTypeQual - If this is an array type, return the 96/// element type of the array, potentially with type qualifiers missing. 97/// This method should never be used when type qualifiers are meaningful. 98const Type *Type::getArrayElementTypeNoTypeQual() const { 99 // If this is directly an array type, return it. 100 if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 101 return ATy->getElementType().getTypePtr(); 102 103 // If the canonical form of this type isn't the right kind, reject it. 104 if (!isa<ArrayType>(CanonicalType)) { 105 // Look through type qualifiers 106 if (ArrayType *AT = dyn_cast<ArrayType>(CanonicalType.getUnqualifiedType())) 107 return AT->getElementType().getTypePtr(); 108 return 0; 109 } 110 111 // If this is a typedef for an array type, strip the typedef off without 112 // losing all typedef information. 113 return cast<ArrayType>(getDesugaredType())->getElementType().getTypePtr(); 114} 115 116/// getDesugaredType - Return the specified type with any "sugar" removed from 117/// the type. This takes off typedefs, typeof's etc. If the outer level of 118/// the type is already concrete, it returns it unmodified. This is similar 119/// to getting the canonical type, but it doesn't remove *all* typedefs. For 120/// example, it returns "T*" as "T*", (not as "int*"), because the pointer is 121/// concrete. 122/// 123/// \param ForDisplay When true, the desugaring is provided for 124/// display purposes only. In this case, we apply more heuristics to 125/// decide whether it is worth providing a desugared form of the type 126/// or not. 127QualType QualType::getDesugaredType(bool ForDisplay) const { 128 return getTypePtr()->getDesugaredType(ForDisplay) 129 .getWithAdditionalQualifiers(getCVRQualifiers()); 130} 131 132/// getDesugaredType - Return the specified type with any "sugar" removed from 133/// type type. This takes off typedefs, typeof's etc. If the outer level of 134/// the type is already concrete, it returns it unmodified. This is similar 135/// to getting the canonical type, but it doesn't remove *all* typedefs. For 136/// example, it return "T*" as "T*", (not as "int*"), because the pointer is 137/// concrete. 138/// 139/// \param ForDisplay When true, the desugaring is provided for 140/// display purposes only. In this case, we apply more heuristics to 141/// decide whether it is worth providing a desugared form of the type 142/// or not. 143QualType Type::getDesugaredType(bool ForDisplay) const { 144 if (const TypedefType *TDT = dyn_cast<TypedefType>(this)) 145 return TDT->LookThroughTypedefs().getDesugaredType(); 146 if (const TypeOfExprType *TOE = dyn_cast<TypeOfExprType>(this)) 147 return TOE->getUnderlyingExpr()->getType().getDesugaredType(); 148 if (const TypeOfType *TOT = dyn_cast<TypeOfType>(this)) 149 return TOT->getUnderlyingType().getDesugaredType(); 150 if (const DecltypeType *DTT = dyn_cast<DecltypeType>(this)) { 151 if (!DTT->getUnderlyingType()->isDependentType()) 152 return DTT->getUnderlyingType().getDesugaredType(); 153 } 154 if (const TemplateSpecializationType *Spec 155 = dyn_cast<TemplateSpecializationType>(this)) { 156 if (ForDisplay) 157 return QualType(this, 0); 158 159 QualType Canon = Spec->getCanonicalTypeInternal(); 160 if (Canon->getAsTemplateSpecializationType()) 161 return QualType(this, 0); 162 return Canon->getDesugaredType(); 163 } 164 if (const QualifiedNameType *QualName = dyn_cast<QualifiedNameType>(this)) { 165 if (ForDisplay) { 166 // If desugaring the type that the qualified name is referring to 167 // produces something interesting, that's our desugared type. 168 QualType NamedType = QualName->getNamedType().getDesugaredType(); 169 if (NamedType != QualName->getNamedType()) 170 return NamedType; 171 } else 172 return QualName->getNamedType().getDesugaredType(); 173 } 174 175 return QualType(this, 0); 176} 177 178/// isVoidType - Helper method to determine if this is the 'void' type. 179bool Type::isVoidType() const { 180 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 181 return BT->getKind() == BuiltinType::Void; 182 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 183 return AS->getBaseType()->isVoidType(); 184 return false; 185} 186 187bool Type::isObjectType() const { 188 if (isa<FunctionType>(CanonicalType) || isa<ReferenceType>(CanonicalType) || 189 isa<IncompleteArrayType>(CanonicalType) || isVoidType()) 190 return false; 191 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 192 return AS->getBaseType()->isObjectType(); 193 return true; 194} 195 196bool Type::isDerivedType() const { 197 switch (CanonicalType->getTypeClass()) { 198 case ExtQual: 199 return cast<ExtQualType>(CanonicalType)->getBaseType()->isDerivedType(); 200 case Pointer: 201 case VariableArray: 202 case ConstantArray: 203 case ConstantArrayWithExpr: 204 case ConstantArrayWithoutExpr: 205 case IncompleteArray: 206 case FunctionProto: 207 case FunctionNoProto: 208 case LValueReference: 209 case RValueReference: 210 case Record: 211 return true; 212 default: 213 return false; 214 } 215} 216 217bool Type::isClassType() const { 218 if (const RecordType *RT = getAs<RecordType>()) 219 return RT->getDecl()->isClass(); 220 return false; 221} 222bool Type::isStructureType() const { 223 if (const RecordType *RT = getAs<RecordType>()) 224 return RT->getDecl()->isStruct(); 225 return false; 226} 227bool Type::isVoidPointerType() const { 228 if (const PointerType *PT = getAs<PointerType>()) 229 return PT->getPointeeType()->isVoidType(); 230 return false; 231} 232 233bool Type::isUnionType() const { 234 if (const RecordType *RT = getAs<RecordType>()) 235 return RT->getDecl()->isUnion(); 236 return false; 237} 238 239bool Type::isComplexType() const { 240 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 241 return CT->getElementType()->isFloatingType(); 242 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 243 return AS->getBaseType()->isComplexType(); 244 return false; 245} 246 247bool Type::isComplexIntegerType() const { 248 // Check for GCC complex integer extension. 249 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 250 return CT->getElementType()->isIntegerType(); 251 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 252 return AS->getBaseType()->isComplexIntegerType(); 253 return false; 254} 255 256const ComplexType *Type::getAsComplexIntegerType() const { 257 // Are we directly a complex type? 258 if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) { 259 if (CTy->getElementType()->isIntegerType()) 260 return CTy; 261 return 0; 262 } 263 264 // If the canonical form of this type isn't what we want, reject it. 265 if (!isa<ComplexType>(CanonicalType)) { 266 // Look through type qualifiers (e.g. ExtQualType's). 267 if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 268 return CanonicalType.getUnqualifiedType()->getAsComplexIntegerType(); 269 return 0; 270 } 271 272 // If this is a typedef for a complex type, strip the typedef off without 273 // losing all typedef information. 274 return cast<ComplexType>(getDesugaredType()); 275} 276 277const BuiltinType *Type::getAsBuiltinType() const { 278 // If this is directly a builtin type, return it. 279 if (const BuiltinType *BTy = dyn_cast<BuiltinType>(this)) 280 return BTy; 281 282 // If the canonical form of this type isn't a builtin type, reject it. 283 if (!isa<BuiltinType>(CanonicalType)) { 284 // Look through type qualifiers (e.g. ExtQualType's). 285 if (isa<BuiltinType>(CanonicalType.getUnqualifiedType())) 286 return CanonicalType.getUnqualifiedType()->getAsBuiltinType(); 287 return 0; 288 } 289 290 // If this is a typedef for a builtin type, strip the typedef off without 291 // losing all typedef information. 292 return cast<BuiltinType>(getDesugaredType()); 293} 294 295const FunctionType *Type::getAsFunctionType() const { 296 // If this is directly a function type, return it. 297 if (const FunctionType *FTy = dyn_cast<FunctionType>(this)) 298 return FTy; 299 300 // If the canonical form of this type isn't the right kind, reject it. 301 if (!isa<FunctionType>(CanonicalType)) { 302 // Look through type qualifiers 303 if (isa<FunctionType>(CanonicalType.getUnqualifiedType())) 304 return CanonicalType.getUnqualifiedType()->getAsFunctionType(); 305 return 0; 306 } 307 308 // If this is a typedef for a function type, strip the typedef off without 309 // losing all typedef information. 310 return cast<FunctionType>(getDesugaredType()); 311} 312 313const FunctionNoProtoType *Type::getAsFunctionNoProtoType() const { 314 return dyn_cast_or_null<FunctionNoProtoType>(getAsFunctionType()); 315} 316 317const FunctionProtoType *Type::getAsFunctionProtoType() const { 318 return dyn_cast_or_null<FunctionProtoType>(getAsFunctionType()); 319} 320 321QualType Type::getPointeeType() const { 322 if (const PointerType *PT = getAs<PointerType>()) 323 return PT->getPointeeType(); 324 if (const ObjCObjectPointerType *OPT = getAsObjCObjectPointerType()) 325 return OPT->getPointeeType(); 326 if (const BlockPointerType *BPT = getAs<BlockPointerType>()) 327 return BPT->getPointeeType(); 328 return QualType(); 329} 330 331/// isVariablyModifiedType (C99 6.7.5p3) - Return true for variable length 332/// array types and types that contain variable array types in their 333/// declarator 334bool Type::isVariablyModifiedType() const { 335 // A VLA is a variably modified type. 336 if (isVariableArrayType()) 337 return true; 338 339 // An array can contain a variably modified type 340 if (const Type *T = getArrayElementTypeNoTypeQual()) 341 return T->isVariablyModifiedType(); 342 343 // A pointer can point to a variably modified type. 344 // Also, C++ references and member pointers can point to a variably modified 345 // type, where VLAs appear as an extension to C++, and should be treated 346 // correctly. 347 if (const PointerType *PT = getAs<PointerType>()) 348 return PT->getPointeeType()->isVariablyModifiedType(); 349 if (const ReferenceType *RT = getAs<ReferenceType>()) 350 return RT->getPointeeType()->isVariablyModifiedType(); 351 if (const MemberPointerType *PT = getAs<MemberPointerType>()) 352 return PT->getPointeeType()->isVariablyModifiedType(); 353 354 // A function can return a variably modified type 355 // This one isn't completely obvious, but it follows from the 356 // definition in C99 6.7.5p3. Because of this rule, it's 357 // illegal to declare a function returning a variably modified type. 358 if (const FunctionType *FT = getAsFunctionType()) 359 return FT->getResultType()->isVariablyModifiedType(); 360 361 return false; 362} 363 364const RecordType *Type::getAsStructureType() const { 365 // If this is directly a structure type, return it. 366 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 367 if (RT->getDecl()->isStruct()) 368 return RT; 369 } 370 371 // If the canonical form of this type isn't the right kind, reject it. 372 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 373 if (!RT->getDecl()->isStruct()) 374 return 0; 375 376 // If this is a typedef for a structure type, strip the typedef off without 377 // losing all typedef information. 378 return cast<RecordType>(getDesugaredType()); 379 } 380 // Look through type qualifiers 381 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 382 return CanonicalType.getUnqualifiedType()->getAsStructureType(); 383 return 0; 384} 385 386const RecordType *Type::getAsUnionType() const { 387 // If this is directly a union type, return it. 388 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 389 if (RT->getDecl()->isUnion()) 390 return RT; 391 } 392 393 // If the canonical form of this type isn't the right kind, reject it. 394 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 395 if (!RT->getDecl()->isUnion()) 396 return 0; 397 398 // If this is a typedef for a union type, strip the typedef off without 399 // losing all typedef information. 400 return cast<RecordType>(getDesugaredType()); 401 } 402 403 // Look through type qualifiers 404 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 405 return CanonicalType.getUnqualifiedType()->getAsUnionType(); 406 return 0; 407} 408 409const EnumType *Type::getAsEnumType() const { 410 // Check the canonicalized unqualified type directly; the more complex 411 // version is unnecessary because there isn't any typedef information 412 // to preserve. 413 return dyn_cast<EnumType>(CanonicalType.getUnqualifiedType()); 414} 415 416const ComplexType *Type::getAsComplexType() const { 417 // Are we directly a complex type? 418 if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) 419 return CTy; 420 421 // If the canonical form of this type isn't the right kind, reject it. 422 if (!isa<ComplexType>(CanonicalType)) { 423 // Look through type qualifiers 424 if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 425 return CanonicalType.getUnqualifiedType()->getAsComplexType(); 426 return 0; 427 } 428 429 // If this is a typedef for a complex type, strip the typedef off without 430 // losing all typedef information. 431 return cast<ComplexType>(getDesugaredType()); 432} 433 434const VectorType *Type::getAsVectorType() const { 435 // Are we directly a vector type? 436 if (const VectorType *VTy = dyn_cast<VectorType>(this)) 437 return VTy; 438 439 // If the canonical form of this type isn't the right kind, reject it. 440 if (!isa<VectorType>(CanonicalType)) { 441 // Look through type qualifiers 442 if (isa<VectorType>(CanonicalType.getUnqualifiedType())) 443 return CanonicalType.getUnqualifiedType()->getAsVectorType(); 444 return 0; 445 } 446 447 // If this is a typedef for a vector type, strip the typedef off without 448 // losing all typedef information. 449 return cast<VectorType>(getDesugaredType()); 450} 451 452const ExtVectorType *Type::getAsExtVectorType() const { 453 // Are we directly an OpenCU vector type? 454 if (const ExtVectorType *VTy = dyn_cast<ExtVectorType>(this)) 455 return VTy; 456 457 // If the canonical form of this type isn't the right kind, reject it. 458 if (!isa<ExtVectorType>(CanonicalType)) { 459 // Look through type qualifiers 460 if (isa<ExtVectorType>(CanonicalType.getUnqualifiedType())) 461 return CanonicalType.getUnqualifiedType()->getAsExtVectorType(); 462 return 0; 463 } 464 465 // If this is a typedef for an extended vector type, strip the typedef off 466 // without losing all typedef information. 467 return cast<ExtVectorType>(getDesugaredType()); 468} 469 470const ObjCInterfaceType *Type::getAsObjCInterfaceType() const { 471 // There is no sugar for ObjCInterfaceType's, just return the canonical 472 // type pointer if it is the right class. There is no typedef information to 473 // return and these cannot be Address-space qualified. 474 return dyn_cast<ObjCInterfaceType>(CanonicalType.getUnqualifiedType()); 475} 476 477const ObjCInterfaceType *Type::getAsObjCQualifiedInterfaceType() const { 478 // There is no sugar for ObjCInterfaceType's, just return the canonical 479 // type pointer if it is the right class. There is no typedef information to 480 // return and these cannot be Address-space qualified. 481 if (const ObjCInterfaceType *OIT = getAsObjCInterfaceType()) 482 if (OIT->getNumProtocols()) 483 return OIT; 484 return 0; 485} 486 487bool Type::isObjCQualifiedInterfaceType() const { 488 return getAsObjCQualifiedInterfaceType() != 0; 489} 490 491const ObjCObjectPointerType *Type::getAsObjCObjectPointerType() const { 492 // There is no sugar for ObjCObjectPointerType's, just return the 493 // canonical type pointer if it is the right class. 494 return dyn_cast<ObjCObjectPointerType>(CanonicalType.getUnqualifiedType()); 495} 496 497const ObjCObjectPointerType *Type::getAsObjCQualifiedIdType() const { 498 // There is no sugar for ObjCQualifiedIdType's, just return the canonical 499 // type pointer if it is the right class. 500 if (const ObjCObjectPointerType *OPT = getAsObjCObjectPointerType()) { 501 if (OPT->isObjCQualifiedIdType()) 502 return OPT; 503 } 504 return 0; 505} 506 507const ObjCObjectPointerType *Type::getAsObjCInterfacePointerType() const { 508 if (const ObjCObjectPointerType *OPT = getAsObjCObjectPointerType()) { 509 if (OPT->getInterfaceType()) 510 return OPT; 511 } 512 return 0; 513} 514 515const TemplateTypeParmType *Type::getAsTemplateTypeParmType() const { 516 // There is no sugar for template type parameters, so just return 517 // the canonical type pointer if it is the right class. 518 // FIXME: can these be address-space qualified? 519 return dyn_cast<TemplateTypeParmType>(CanonicalType); 520} 521 522const CXXRecordDecl *Type::getCXXRecordDeclForPointerType() const { 523 if (const PointerType *PT = getAs<PointerType>()) 524 if (const RecordType *RT = PT->getPointeeType()->getAs<RecordType>()) 525 return dyn_cast<CXXRecordDecl>(RT->getDecl()); 526 return 0; 527} 528 529const TemplateSpecializationType * 530Type::getAsTemplateSpecializationType() const { 531 // There is no sugar for class template specialization types, so 532 // just return the canonical type pointer if it is the right class. 533 return this->getAs<TemplateSpecializationType>(); 534} 535 536bool Type::isIntegerType() const { 537 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 538 return BT->getKind() >= BuiltinType::Bool && 539 BT->getKind() <= BuiltinType::Int128; 540 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 541 // Incomplete enum types are not treated as integer types. 542 // FIXME: In C++, enum types are never integer types. 543 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 544 return true; 545 if (isa<FixedWidthIntType>(CanonicalType)) 546 return true; 547 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 548 return VT->getElementType()->isIntegerType(); 549 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 550 return EXTQT->getBaseType()->isIntegerType(); 551 return false; 552} 553 554bool Type::isIntegralType() const { 555 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 556 return BT->getKind() >= BuiltinType::Bool && 557 BT->getKind() <= BuiltinType::LongLong; 558 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 559 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 560 return true; // Complete enum types are integral. 561 // FIXME: In C++, enum types are never integral. 562 if (isa<FixedWidthIntType>(CanonicalType)) 563 return true; 564 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 565 return EXTQT->getBaseType()->isIntegralType(); 566 return false; 567} 568 569bool Type::isEnumeralType() const { 570 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 571 return TT->getDecl()->isEnum(); 572 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 573 return EXTQT->getBaseType()->isEnumeralType(); 574 return false; 575} 576 577bool Type::isBooleanType() const { 578 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 579 return BT->getKind() == BuiltinType::Bool; 580 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 581 return EXTQT->getBaseType()->isBooleanType(); 582 return false; 583} 584 585bool Type::isCharType() const { 586 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 587 return BT->getKind() == BuiltinType::Char_U || 588 BT->getKind() == BuiltinType::UChar || 589 BT->getKind() == BuiltinType::Char_S || 590 BT->getKind() == BuiltinType::SChar; 591 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 592 return EXTQT->getBaseType()->isCharType(); 593 return false; 594} 595 596bool Type::isWideCharType() const { 597 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 598 return BT->getKind() == BuiltinType::WChar; 599 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 600 return EXTQT->getBaseType()->isWideCharType(); 601 return false; 602} 603 604/// isSignedIntegerType - Return true if this is an integer type that is 605/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 606/// an enum decl which has a signed representation, or a vector of signed 607/// integer element type. 608bool Type::isSignedIntegerType() const { 609 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 610 return BT->getKind() >= BuiltinType::Char_S && 611 BT->getKind() <= BuiltinType::LongLong; 612 } 613 614 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 615 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 616 617 if (const FixedWidthIntType *FWIT = 618 dyn_cast<FixedWidthIntType>(CanonicalType)) 619 return FWIT->isSigned(); 620 621 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 622 return VT->getElementType()->isSignedIntegerType(); 623 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 624 return EXTQT->getBaseType()->isSignedIntegerType(); 625 return false; 626} 627 628/// isUnsignedIntegerType - Return true if this is an integer type that is 629/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 630/// decl which has an unsigned representation, or a vector of unsigned integer 631/// element type. 632bool Type::isUnsignedIntegerType() const { 633 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 634 return BT->getKind() >= BuiltinType::Bool && 635 BT->getKind() <= BuiltinType::ULongLong; 636 } 637 638 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 639 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 640 641 if (const FixedWidthIntType *FWIT = 642 dyn_cast<FixedWidthIntType>(CanonicalType)) 643 return !FWIT->isSigned(); 644 645 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 646 return VT->getElementType()->isUnsignedIntegerType(); 647 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 648 return EXTQT->getBaseType()->isUnsignedIntegerType(); 649 return false; 650} 651 652bool Type::isFloatingType() const { 653 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 654 return BT->getKind() >= BuiltinType::Float && 655 BT->getKind() <= BuiltinType::LongDouble; 656 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 657 return CT->getElementType()->isFloatingType(); 658 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 659 return VT->getElementType()->isFloatingType(); 660 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 661 return EXTQT->getBaseType()->isFloatingType(); 662 return false; 663} 664 665bool Type::isRealFloatingType() const { 666 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 667 return BT->getKind() >= BuiltinType::Float && 668 BT->getKind() <= BuiltinType::LongDouble; 669 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 670 return VT->getElementType()->isRealFloatingType(); 671 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 672 return EXTQT->getBaseType()->isRealFloatingType(); 673 return false; 674} 675 676bool Type::isRealType() const { 677 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 678 return BT->getKind() >= BuiltinType::Bool && 679 BT->getKind() <= BuiltinType::LongDouble; 680 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 681 return TT->getDecl()->isEnum() && TT->getDecl()->isDefinition(); 682 if (isa<FixedWidthIntType>(CanonicalType)) 683 return true; 684 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 685 return VT->getElementType()->isRealType(); 686 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 687 return EXTQT->getBaseType()->isRealType(); 688 return false; 689} 690 691bool Type::isArithmeticType() const { 692 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 693 return BT->getKind() >= BuiltinType::Bool && 694 BT->getKind() <= BuiltinType::LongDouble; 695 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 696 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 697 // If a body isn't seen by the time we get here, return false. 698 return ET->getDecl()->isDefinition(); 699 if (isa<FixedWidthIntType>(CanonicalType)) 700 return true; 701 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 702 return EXTQT->getBaseType()->isArithmeticType(); 703 return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType); 704} 705 706bool Type::isScalarType() const { 707 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 708 return BT->getKind() != BuiltinType::Void; 709 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 710 // Enums are scalar types, but only if they are defined. Incomplete enums 711 // are not treated as scalar types. 712 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 713 return true; 714 return false; 715 } 716 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 717 return EXTQT->getBaseType()->isScalarType(); 718 if (isa<FixedWidthIntType>(CanonicalType)) 719 return true; 720 return isa<PointerType>(CanonicalType) || 721 isa<BlockPointerType>(CanonicalType) || 722 isa<MemberPointerType>(CanonicalType) || 723 isa<ComplexType>(CanonicalType) || 724 isa<ObjCObjectPointerType>(CanonicalType); 725} 726 727/// \brief Determines whether the type is a C++ aggregate type or C 728/// aggregate or union type. 729/// 730/// An aggregate type is an array or a class type (struct, union, or 731/// class) that has no user-declared constructors, no private or 732/// protected non-static data members, no base classes, and no virtual 733/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 734/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 735/// includes union types. 736bool Type::isAggregateType() const { 737 if (const RecordType *Record = dyn_cast<RecordType>(CanonicalType)) { 738 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(Record->getDecl())) 739 return ClassDecl->isAggregate(); 740 741 return true; 742 } 743 744 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 745 return EXTQT->getBaseType()->isAggregateType(); 746 return isa<ArrayType>(CanonicalType); 747} 748 749/// isConstantSizeType - Return true if this is not a variable sized type, 750/// according to the rules of C99 6.7.5p3. It is not legal to call this on 751/// incomplete types or dependent types. 752bool Type::isConstantSizeType() const { 753 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 754 return EXTQT->getBaseType()->isConstantSizeType(); 755 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 756 assert(!isDependentType() && "This doesn't make sense for dependent types"); 757 // The VAT must have a size, as it is known to be complete. 758 return !isa<VariableArrayType>(CanonicalType); 759} 760 761/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 762/// - a type that can describe objects, but which lacks information needed to 763/// determine its size. 764bool Type::isIncompleteType() const { 765 switch (CanonicalType->getTypeClass()) { 766 default: return false; 767 case ExtQual: 768 return cast<ExtQualType>(CanonicalType)->getBaseType()->isIncompleteType(); 769 case Builtin: 770 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 771 // be completed. 772 return isVoidType(); 773 case Record: 774 case Enum: 775 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 776 // forward declaration, but not a full definition (C99 6.2.5p22). 777 return !cast<TagType>(CanonicalType)->getDecl()->isDefinition(); 778 case IncompleteArray: 779 // An array of unknown size is an incomplete type (C99 6.2.5p22). 780 return true; 781 case ObjCInterface: 782 // ObjC interfaces are incomplete if they are @class, not @interface. 783 return cast<ObjCInterfaceType>(this)->getDecl()->isForwardDecl(); 784 } 785} 786 787/// isPODType - Return true if this is a plain-old-data type (C++ 3.9p10) 788bool Type::isPODType() const { 789 // The compiler shouldn't query this for incomplete types, but the user might. 790 // We return false for that case. 791 if (isIncompleteType()) 792 return false; 793 794 switch (CanonicalType->getTypeClass()) { 795 // Everything not explicitly mentioned is not POD. 796 default: return false; 797 case ExtQual: 798 return cast<ExtQualType>(CanonicalType)->getBaseType()->isPODType(); 799 case VariableArray: 800 case ConstantArray: 801 // IncompleteArray is caught by isIncompleteType() above. 802 return cast<ArrayType>(CanonicalType)->getElementType()->isPODType(); 803 804 case Builtin: 805 case Complex: 806 case Pointer: 807 case MemberPointer: 808 case Vector: 809 case ExtVector: 810 case ObjCObjectPointer: 811 return true; 812 813 case Enum: 814 return true; 815 816 case Record: 817 if (CXXRecordDecl *ClassDecl 818 = dyn_cast<CXXRecordDecl>(cast<RecordType>(CanonicalType)->getDecl())) 819 return ClassDecl->isPOD(); 820 821 // C struct/union is POD. 822 return true; 823 } 824} 825 826bool Type::isPromotableIntegerType() const { 827 if (const BuiltinType *BT = getAsBuiltinType()) 828 switch (BT->getKind()) { 829 case BuiltinType::Bool: 830 case BuiltinType::Char_S: 831 case BuiltinType::Char_U: 832 case BuiltinType::SChar: 833 case BuiltinType::UChar: 834 case BuiltinType::Short: 835 case BuiltinType::UShort: 836 return true; 837 default: 838 return false; 839 } 840 return false; 841} 842 843bool Type::isNullPtrType() const { 844 if (const BuiltinType *BT = getAsBuiltinType()) 845 return BT->getKind() == BuiltinType::NullPtr; 846 return false; 847} 848 849bool Type::isSpecifierType() const { 850 // Note that this intentionally does not use the canonical type. 851 switch (getTypeClass()) { 852 case Builtin: 853 case Record: 854 case Enum: 855 case Typedef: 856 case Complex: 857 case TypeOfExpr: 858 case TypeOf: 859 case TemplateTypeParm: 860 case TemplateSpecialization: 861 case QualifiedName: 862 case Typename: 863 case ObjCInterface: 864 case ObjCObjectPointer: 865 return true; 866 default: 867 return false; 868 } 869} 870 871const char *BuiltinType::getName(const LangOptions &LO) const { 872 switch (getKind()) { 873 default: assert(0 && "Unknown builtin type!"); 874 case Void: return "void"; 875 case Bool: return LO.Bool ? "bool" : "_Bool"; 876 case Char_S: return "char"; 877 case Char_U: return "char"; 878 case SChar: return "signed char"; 879 case Short: return "short"; 880 case Int: return "int"; 881 case Long: return "long"; 882 case LongLong: return "long long"; 883 case Int128: return "__int128_t"; 884 case UChar: return "unsigned char"; 885 case UShort: return "unsigned short"; 886 case UInt: return "unsigned int"; 887 case ULong: return "unsigned long"; 888 case ULongLong: return "unsigned long long"; 889 case UInt128: return "__uint128_t"; 890 case Float: return "float"; 891 case Double: return "double"; 892 case LongDouble: return "long double"; 893 case WChar: return "wchar_t"; 894 case Char16: return "char16_t"; 895 case Char32: return "char32_t"; 896 case NullPtr: return "nullptr_t"; 897 case Overload: return "<overloaded function type>"; 898 case Dependent: return "<dependent type>"; 899 case UndeducedAuto: return "auto"; 900 case ObjCId: return "id"; 901 case ObjCClass: return "Class"; 902 } 903} 904 905void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 906 arg_type_iterator ArgTys, 907 unsigned NumArgs, bool isVariadic, 908 unsigned TypeQuals, bool hasExceptionSpec, 909 bool anyExceptionSpec, unsigned NumExceptions, 910 exception_iterator Exs, bool NoReturn) { 911 ID.AddPointer(Result.getAsOpaquePtr()); 912 for (unsigned i = 0; i != NumArgs; ++i) 913 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 914 ID.AddInteger(isVariadic); 915 ID.AddInteger(TypeQuals); 916 ID.AddInteger(hasExceptionSpec); 917 if (hasExceptionSpec) { 918 ID.AddInteger(anyExceptionSpec); 919 for(unsigned i = 0; i != NumExceptions; ++i) 920 ID.AddPointer(Exs[i].getAsOpaquePtr()); 921 } 922 ID.AddInteger(NoReturn); 923} 924 925void FunctionProtoType::Profile(llvm::FoldingSetNodeID &ID) { 926 Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(), 927 getTypeQuals(), hasExceptionSpec(), hasAnyExceptionSpec(), 928 getNumExceptions(), exception_begin(), getNoReturnAttr()); 929} 930 931void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID, 932 QualType OIT, ObjCProtocolDecl **protocols, 933 unsigned NumProtocols) { 934 ID.AddPointer(OIT.getAsOpaquePtr()); 935 for (unsigned i = 0; i != NumProtocols; i++) 936 ID.AddPointer(protocols[i]); 937} 938 939void ObjCObjectPointerType::Profile(llvm::FoldingSetNodeID &ID) { 940 if (getNumProtocols()) 941 Profile(ID, getPointeeType(), &Protocols[0], getNumProtocols()); 942 else 943 Profile(ID, getPointeeType(), 0, 0); 944} 945 946/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to 947/// potentially looking through *all* consequtive typedefs. This returns the 948/// sum of the type qualifiers, so if you have: 949/// typedef const int A; 950/// typedef volatile A B; 951/// looking through the typedefs for B will give you "const volatile A". 952/// 953QualType TypedefType::LookThroughTypedefs() const { 954 // Usually, there is only a single level of typedefs, be fast in that case. 955 QualType FirstType = getDecl()->getUnderlyingType(); 956 if (!isa<TypedefType>(FirstType)) 957 return FirstType; 958 959 // Otherwise, do the fully general loop. 960 unsigned TypeQuals = 0; 961 const TypedefType *TDT = this; 962 while (1) { 963 QualType CurType = TDT->getDecl()->getUnderlyingType(); 964 965 966 /// FIXME: 967 /// FIXME: This is incorrect for ExtQuals! 968 /// FIXME: 969 TypeQuals |= CurType.getCVRQualifiers(); 970 971 TDT = dyn_cast<TypedefType>(CurType); 972 if (TDT == 0) 973 return QualType(CurType.getTypePtr(), TypeQuals); 974 } 975} 976 977TypeOfExprType::TypeOfExprType(Expr *E, QualType can) 978 : Type(TypeOfExpr, can, E->isTypeDependent()), TOExpr(E) { 979} 980 981void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID, 982 ASTContext &Context, Expr *E) { 983 E->Profile(ID, Context, true); 984} 985 986DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can) 987 : Type(Decltype, can, E->isTypeDependent()), E(E), 988 UnderlyingType(underlyingType) { 989} 990 991DependentDecltypeType::DependentDecltypeType(ASTContext &Context, Expr *E) 992 : DecltypeType(E, Context.DependentTy), Context(Context) { } 993 994void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID, 995 ASTContext &Context, Expr *E) { 996 E->Profile(ID, Context, true); 997} 998 999TagType::TagType(TypeClass TC, TagDecl *D, QualType can) 1000 : Type(TC, can, D->isDependentType()), decl(D, 0) {} 1001 1002bool RecordType::classof(const TagType *TT) { 1003 return isa<RecordDecl>(TT->getDecl()); 1004} 1005 1006bool EnumType::classof(const TagType *TT) { 1007 return isa<EnumDecl>(TT->getDecl()); 1008} 1009 1010bool 1011TemplateSpecializationType:: 1012anyDependentTemplateArguments(const TemplateArgument *Args, unsigned NumArgs) { 1013 for (unsigned Idx = 0; Idx < NumArgs; ++Idx) { 1014 switch (Args[Idx].getKind()) { 1015 case TemplateArgument::Null: 1016 assert(false && "Should not have a NULL template argument"); 1017 break; 1018 1019 case TemplateArgument::Type: 1020 if (Args[Idx].getAsType()->isDependentType()) 1021 return true; 1022 break; 1023 1024 case TemplateArgument::Declaration: 1025 case TemplateArgument::Integral: 1026 // Never dependent 1027 break; 1028 1029 case TemplateArgument::Expression: 1030 if (Args[Idx].getAsExpr()->isTypeDependent() || 1031 Args[Idx].getAsExpr()->isValueDependent()) 1032 return true; 1033 break; 1034 1035 case TemplateArgument::Pack: 1036 assert(0 && "FIXME: Implement!"); 1037 break; 1038 } 1039 } 1040 1041 return false; 1042} 1043 1044TemplateSpecializationType:: 1045TemplateSpecializationType(ASTContext &Context, TemplateName T, 1046 const TemplateArgument *Args, 1047 unsigned NumArgs, QualType Canon) 1048 : Type(TemplateSpecialization, 1049 Canon.isNull()? QualType(this, 0) : Canon, 1050 T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)), 1051 Context(Context), 1052 Template(T), NumArgs(NumArgs) 1053{ 1054 assert((!Canon.isNull() || 1055 T.isDependent() || anyDependentTemplateArguments(Args, NumArgs)) && 1056 "No canonical type for non-dependent class template specialization"); 1057 1058 TemplateArgument *TemplateArgs 1059 = reinterpret_cast<TemplateArgument *>(this + 1); 1060 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 1061 new (&TemplateArgs[Arg]) TemplateArgument(Args[Arg]); 1062} 1063 1064void TemplateSpecializationType::Destroy(ASTContext& C) { 1065 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1066 // FIXME: Not all expressions get cloned, so we can't yet perform 1067 // this destruction. 1068 // if (Expr *E = getArg(Arg).getAsExpr()) 1069 // E->Destroy(C); 1070 } 1071} 1072 1073TemplateSpecializationType::iterator 1074TemplateSpecializationType::end() const { 1075 return begin() + getNumArgs(); 1076} 1077 1078const TemplateArgument & 1079TemplateSpecializationType::getArg(unsigned Idx) const { 1080 assert(Idx < getNumArgs() && "Template argument out of range"); 1081 return getArgs()[Idx]; 1082} 1083 1084void 1085TemplateSpecializationType::Profile(llvm::FoldingSetNodeID &ID, 1086 TemplateName T, 1087 const TemplateArgument *Args, 1088 unsigned NumArgs, 1089 ASTContext &Context) { 1090 T.Profile(ID); 1091 for (unsigned Idx = 0; Idx < NumArgs; ++Idx) 1092 Args[Idx].Profile(ID, Context); 1093} 1094 1095const Type *QualifierSet::strip(const Type* T) { 1096 QualType DT = T->getDesugaredType(); 1097 addCVR(DT.getCVRQualifiers()); 1098 1099 if (const ExtQualType* EQT = dyn_cast<ExtQualType>(DT)) { 1100 if (EQT->getAddressSpace()) 1101 addAddressSpace(EQT->getAddressSpace()); 1102 if (EQT->getObjCGCAttr()) 1103 addObjCGCAttrType(EQT->getObjCGCAttr()); 1104 return EQT->getBaseType(); 1105 } else { 1106 // Use the sugared type unless desugaring found extra qualifiers. 1107 return (DT.getCVRQualifiers() ? DT.getTypePtr() : T); 1108 } 1109} 1110 1111QualType QualifierSet::apply(QualType QT, ASTContext& C) { 1112 QT = QT.getWithAdditionalQualifiers(getCVRMask()); 1113 if (hasObjCGCAttrType()) QT = C.getObjCGCQualType(QT, getObjCGCAttrType()); 1114 if (hasAddressSpace()) QT = C.getAddrSpaceQualType(QT, getAddressSpace()); 1115 return QT; 1116} 1117 1118 1119//===----------------------------------------------------------------------===// 1120// Type Printing 1121//===----------------------------------------------------------------------===// 1122 1123void QualType::dump(const char *msg) const { 1124 std::string R = "identifier"; 1125 LangOptions LO; 1126 getAsStringInternal(R, PrintingPolicy(LO)); 1127 if (msg) 1128 fprintf(stderr, "%s: %s\n", msg, R.c_str()); 1129 else 1130 fprintf(stderr, "%s\n", R.c_str()); 1131} 1132void QualType::dump() const { 1133 dump(""); 1134} 1135 1136void Type::dump() const { 1137 std::string S = "identifier"; 1138 LangOptions LO; 1139 getAsStringInternal(S, PrintingPolicy(LO)); 1140 fprintf(stderr, "%s\n", S.c_str()); 1141} 1142 1143 1144 1145static void AppendTypeQualList(std::string &S, unsigned TypeQuals) { 1146 // Note: funkiness to ensure we get a space only between quals. 1147 bool NonePrinted = true; 1148 if (TypeQuals & QualType::Const) 1149 S += "const", NonePrinted = false; 1150 if (TypeQuals & QualType::Volatile) 1151 S += (NonePrinted+" volatile"), NonePrinted = false; 1152 if (TypeQuals & QualType::Restrict) 1153 S += (NonePrinted+" restrict"), NonePrinted = false; 1154} 1155 1156std::string QualType::getAsString() const { 1157 std::string S; 1158 LangOptions LO; 1159 getAsStringInternal(S, PrintingPolicy(LO)); 1160 return S; 1161} 1162 1163void 1164QualType::getAsStringInternal(std::string &S, 1165 const PrintingPolicy &Policy) const { 1166 if (isNull()) { 1167 S += "NULL TYPE"; 1168 return; 1169 } 1170 1171 if (Policy.SuppressSpecifiers && getTypePtr()->isSpecifierType()) 1172 return; 1173 1174 // Print qualifiers as appropriate. 1175 if (unsigned Tq = getCVRQualifiers()) { 1176 std::string TQS; 1177 AppendTypeQualList(TQS, Tq); 1178 if (!S.empty()) 1179 S = TQS + ' ' + S; 1180 else 1181 S = TQS; 1182 } 1183 1184 getTypePtr()->getAsStringInternal(S, Policy); 1185} 1186 1187void BuiltinType::getAsStringInternal(std::string &S, 1188 const PrintingPolicy &Policy) const { 1189 if (S.empty()) { 1190 S = getName(Policy.LangOpts); 1191 } else { 1192 // Prefix the basic type, e.g. 'int X'. 1193 S = ' ' + S; 1194 S = getName(Policy.LangOpts) + S; 1195 } 1196} 1197 1198void FixedWidthIntType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1199 // FIXME: Once we get bitwidth attribute, write as 1200 // "int __attribute__((bitwidth(x)))". 1201 std::string prefix = "__clang_fixedwidth"; 1202 prefix += llvm::utostr_32(Width); 1203 prefix += (char)(Signed ? 'S' : 'U'); 1204 if (S.empty()) { 1205 S = prefix; 1206 } else { 1207 // Prefix the basic type, e.g. 'int X'. 1208 S = prefix + S; 1209 } 1210} 1211 1212 1213void ComplexType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1214 ElementType->getAsStringInternal(S, Policy); 1215 S = "_Complex " + S; 1216} 1217 1218void ExtQualType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1219 bool NeedsSpace = false; 1220 if (AddressSpace) { 1221 S = "__attribute__((address_space("+llvm::utostr_32(AddressSpace)+")))" + S; 1222 NeedsSpace = true; 1223 } 1224 if (GCAttrType != QualType::GCNone) { 1225 if (NeedsSpace) 1226 S += ' '; 1227 S += "__attribute__((objc_gc("; 1228 if (GCAttrType == QualType::Weak) 1229 S += "weak"; 1230 else 1231 S += "strong"; 1232 S += ")))"; 1233 } 1234 BaseType->getAsStringInternal(S, Policy); 1235} 1236 1237void PointerType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1238 S = '*' + S; 1239 1240 // Handle things like 'int (*A)[4];' correctly. 1241 // FIXME: this should include vectors, but vectors use attributes I guess. 1242 if (isa<ArrayType>(getPointeeType())) 1243 S = '(' + S + ')'; 1244 1245 getPointeeType().getAsStringInternal(S, Policy); 1246} 1247 1248void BlockPointerType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1249 S = '^' + S; 1250 PointeeType.getAsStringInternal(S, Policy); 1251} 1252 1253void LValueReferenceType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1254 S = '&' + S; 1255 1256 // Handle things like 'int (&A)[4];' correctly. 1257 // FIXME: this should include vectors, but vectors use attributes I guess. 1258 if (isa<ArrayType>(getPointeeType())) 1259 S = '(' + S + ')'; 1260 1261 getPointeeType().getAsStringInternal(S, Policy); 1262} 1263 1264void RValueReferenceType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1265 S = "&&" + S; 1266 1267 // Handle things like 'int (&&A)[4];' correctly. 1268 // FIXME: this should include vectors, but vectors use attributes I guess. 1269 if (isa<ArrayType>(getPointeeType())) 1270 S = '(' + S + ')'; 1271 1272 getPointeeType().getAsStringInternal(S, Policy); 1273} 1274 1275void MemberPointerType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1276 std::string C; 1277 Class->getAsStringInternal(C, Policy); 1278 C += "::*"; 1279 S = C + S; 1280 1281 // Handle things like 'int (Cls::*A)[4];' correctly. 1282 // FIXME: this should include vectors, but vectors use attributes I guess. 1283 if (isa<ArrayType>(getPointeeType())) 1284 S = '(' + S + ')'; 1285 1286 getPointeeType().getAsStringInternal(S, Policy); 1287} 1288 1289void ConstantArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1290 S += '['; 1291 S += llvm::utostr(getSize().getZExtValue()); 1292 S += ']'; 1293 1294 getElementType().getAsStringInternal(S, Policy); 1295} 1296 1297void ConstantArrayWithExprType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1298 if (Policy.ConstantArraySizeAsWritten) { 1299 std::string SStr; 1300 llvm::raw_string_ostream s(SStr); 1301 getSizeExpr()->printPretty(s, 0, Policy); 1302 S += '['; 1303 S += s.str(); 1304 S += ']'; 1305 getElementType().getAsStringInternal(S, Policy); 1306 } 1307 else 1308 ConstantArrayType::getAsStringInternal(S, Policy); 1309} 1310 1311void ConstantArrayWithoutExprType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1312 if (Policy.ConstantArraySizeAsWritten) { 1313 S += "[]"; 1314 getElementType().getAsStringInternal(S, Policy); 1315 } 1316 else 1317 ConstantArrayType::getAsStringInternal(S, Policy); 1318} 1319 1320void IncompleteArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1321 S += "[]"; 1322 1323 getElementType().getAsStringInternal(S, Policy); 1324} 1325 1326void VariableArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1327 S += '['; 1328 1329 if (getIndexTypeQualifier()) { 1330 AppendTypeQualList(S, getIndexTypeQualifier()); 1331 S += ' '; 1332 } 1333 1334 if (getSizeModifier() == Static) 1335 S += "static"; 1336 else if (getSizeModifier() == Star) 1337 S += '*'; 1338 1339 if (getSizeExpr()) { 1340 std::string SStr; 1341 llvm::raw_string_ostream s(SStr); 1342 getSizeExpr()->printPretty(s, 0, Policy); 1343 S += s.str(); 1344 } 1345 S += ']'; 1346 1347 getElementType().getAsStringInternal(S, Policy); 1348} 1349 1350void DependentSizedArrayType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1351 S += '['; 1352 1353 if (getIndexTypeQualifier()) { 1354 AppendTypeQualList(S, getIndexTypeQualifier()); 1355 S += ' '; 1356 } 1357 1358 if (getSizeModifier() == Static) 1359 S += "static"; 1360 else if (getSizeModifier() == Star) 1361 S += '*'; 1362 1363 if (getSizeExpr()) { 1364 std::string SStr; 1365 llvm::raw_string_ostream s(SStr); 1366 getSizeExpr()->printPretty(s, 0, Policy); 1367 S += s.str(); 1368 } 1369 S += ']'; 1370 1371 getElementType().getAsStringInternal(S, Policy); 1372} 1373 1374void DependentSizedExtVectorType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1375 getElementType().getAsStringInternal(S, Policy); 1376 1377 S += " __attribute__((ext_vector_type("; 1378 if (getSizeExpr()) { 1379 std::string SStr; 1380 llvm::raw_string_ostream s(SStr); 1381 getSizeExpr()->printPretty(s, 0, Policy); 1382 S += s.str(); 1383 } 1384 S += ")))"; 1385} 1386 1387void VectorType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1388 // FIXME: We prefer to print the size directly here, but have no way 1389 // to get the size of the type. 1390 S += " __attribute__((__vector_size__("; 1391 S += llvm::utostr_32(NumElements); // convert back to bytes. 1392 S += " * sizeof(" + ElementType.getAsString() + "))))"; 1393 ElementType.getAsStringInternal(S, Policy); 1394} 1395 1396void ExtVectorType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1397 S += " __attribute__((ext_vector_type("; 1398 S += llvm::utostr_32(NumElements); 1399 S += ")))"; 1400 ElementType.getAsStringInternal(S, Policy); 1401} 1402 1403void TypeOfExprType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1404 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'. 1405 InnerString = ' ' + InnerString; 1406 std::string Str; 1407 llvm::raw_string_ostream s(Str); 1408 getUnderlyingExpr()->printPretty(s, 0, Policy); 1409 InnerString = "typeof " + s.str() + InnerString; 1410} 1411 1412void TypeOfType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1413 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(t) X'. 1414 InnerString = ' ' + InnerString; 1415 std::string Tmp; 1416 getUnderlyingType().getAsStringInternal(Tmp, Policy); 1417 InnerString = "typeof(" + Tmp + ")" + InnerString; 1418} 1419 1420void DecltypeType::getAsStringInternal(std::string &InnerString, 1421 const PrintingPolicy &Policy) const { 1422 if (!InnerString.empty()) // Prefix the basic type, e.g. 'decltype(t) X'. 1423 InnerString = ' ' + InnerString; 1424 std::string Str; 1425 llvm::raw_string_ostream s(Str); 1426 getUnderlyingExpr()->printPretty(s, 0, Policy); 1427 InnerString = "decltype(" + s.str() + ")" + InnerString; 1428} 1429 1430void FunctionNoProtoType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1431 // If needed for precedence reasons, wrap the inner part in grouping parens. 1432 if (!S.empty()) 1433 S = "(" + S + ")"; 1434 1435 S += "()"; 1436 if (getNoReturnAttr()) 1437 S += " __attribute__((noreturn))"; 1438 getResultType().getAsStringInternal(S, Policy); 1439} 1440 1441void FunctionProtoType::getAsStringInternal(std::string &S, const PrintingPolicy &Policy) const { 1442 // If needed for precedence reasons, wrap the inner part in grouping parens. 1443 if (!S.empty()) 1444 S = "(" + S + ")"; 1445 1446 S += "("; 1447 std::string Tmp; 1448 PrintingPolicy ParamPolicy(Policy); 1449 ParamPolicy.SuppressSpecifiers = false; 1450 for (unsigned i = 0, e = getNumArgs(); i != e; ++i) { 1451 if (i) S += ", "; 1452 getArgType(i).getAsStringInternal(Tmp, ParamPolicy); 1453 S += Tmp; 1454 Tmp.clear(); 1455 } 1456 1457 if (isVariadic()) { 1458 if (getNumArgs()) 1459 S += ", "; 1460 S += "..."; 1461 } else if (getNumArgs() == 0 && !Policy.LangOpts.CPlusPlus) { 1462 // Do not emit int() if we have a proto, emit 'int(void)'. 1463 S += "void"; 1464 } 1465 1466 S += ")"; 1467 if (getNoReturnAttr()) 1468 S += " __attribute__((noreturn))"; 1469 getResultType().getAsStringInternal(S, Policy); 1470} 1471 1472 1473void TypedefType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1474 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1475 InnerString = ' ' + InnerString; 1476 InnerString = getDecl()->getIdentifier()->getName() + InnerString; 1477} 1478 1479void TemplateTypeParmType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1480 if (!InnerString.empty()) // Prefix the basic type, e.g. 'parmname X'. 1481 InnerString = ' ' + InnerString; 1482 1483 if (!Name) 1484 InnerString = "type-parameter-" + llvm::utostr_32(Depth) + '-' + 1485 llvm::utostr_32(Index) + InnerString; 1486 else 1487 InnerString = Name->getName() + InnerString; 1488} 1489 1490std::string 1491TemplateSpecializationType::PrintTemplateArgumentList( 1492 const TemplateArgument *Args, 1493 unsigned NumArgs, 1494 const PrintingPolicy &Policy) { 1495 std::string SpecString; 1496 SpecString += '<'; 1497 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1498 if (Arg) 1499 SpecString += ", "; 1500 1501 // Print the argument into a string. 1502 std::string ArgString; 1503 switch (Args[Arg].getKind()) { 1504 case TemplateArgument::Null: 1505 assert(false && "Null template argument"); 1506 break; 1507 1508 case TemplateArgument::Type: 1509 Args[Arg].getAsType().getAsStringInternal(ArgString, Policy); 1510 break; 1511 1512 case TemplateArgument::Declaration: 1513 ArgString = cast<NamedDecl>(Args[Arg].getAsDecl())->getNameAsString(); 1514 break; 1515 1516 case TemplateArgument::Integral: 1517 ArgString = Args[Arg].getAsIntegral()->toString(10, true); 1518 break; 1519 1520 case TemplateArgument::Expression: { 1521 llvm::raw_string_ostream s(ArgString); 1522 Args[Arg].getAsExpr()->printPretty(s, 0, Policy); 1523 break; 1524 } 1525 case TemplateArgument::Pack: 1526 assert(0 && "FIXME: Implement!"); 1527 break; 1528 } 1529 1530 // If this is the first argument and its string representation 1531 // begins with the global scope specifier ('::foo'), add a space 1532 // to avoid printing the diagraph '<:'. 1533 if (!Arg && !ArgString.empty() && ArgString[0] == ':') 1534 SpecString += ' '; 1535 1536 SpecString += ArgString; 1537 } 1538 1539 // If the last character of our string is '>', add another space to 1540 // keep the two '>''s separate tokens. We don't *have* to do this in 1541 // C++0x, but it's still good hygiene. 1542 if (SpecString[SpecString.size() - 1] == '>') 1543 SpecString += ' '; 1544 1545 SpecString += '>'; 1546 1547 return SpecString; 1548} 1549 1550void 1551TemplateSpecializationType:: 1552getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1553 std::string SpecString; 1554 1555 { 1556 llvm::raw_string_ostream OS(SpecString); 1557 Template.print(OS, Policy); 1558 } 1559 1560 SpecString += PrintTemplateArgumentList(getArgs(), getNumArgs(), Policy); 1561 if (InnerString.empty()) 1562 InnerString.swap(SpecString); 1563 else 1564 InnerString = SpecString + ' ' + InnerString; 1565} 1566 1567void QualifiedNameType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1568 std::string MyString; 1569 1570 { 1571 llvm::raw_string_ostream OS(MyString); 1572 NNS->print(OS, Policy); 1573 } 1574 1575 std::string TypeStr; 1576 PrintingPolicy InnerPolicy(Policy); 1577 InnerPolicy.SuppressTagKind = true; 1578 NamedType.getAsStringInternal(TypeStr, InnerPolicy); 1579 1580 MyString += TypeStr; 1581 if (InnerString.empty()) 1582 InnerString.swap(MyString); 1583 else 1584 InnerString = MyString + ' ' + InnerString; 1585} 1586 1587void TypenameType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1588 std::string MyString; 1589 1590 { 1591 llvm::raw_string_ostream OS(MyString); 1592 OS << "typename "; 1593 NNS->print(OS, Policy); 1594 1595 if (const IdentifierInfo *Ident = getIdentifier()) 1596 OS << Ident->getName(); 1597 else if (const TemplateSpecializationType *Spec = getTemplateId()) { 1598 Spec->getTemplateName().print(OS, Policy, true); 1599 OS << TemplateSpecializationType::PrintTemplateArgumentList( 1600 Spec->getArgs(), 1601 Spec->getNumArgs(), 1602 Policy); 1603 } 1604 } 1605 1606 if (InnerString.empty()) 1607 InnerString.swap(MyString); 1608 else 1609 InnerString = MyString + ' ' + InnerString; 1610} 1611 1612void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID, 1613 const ObjCInterfaceDecl *Decl, 1614 ObjCProtocolDecl **protocols, 1615 unsigned NumProtocols) { 1616 ID.AddPointer(Decl); 1617 for (unsigned i = 0; i != NumProtocols; i++) 1618 ID.AddPointer(protocols[i]); 1619} 1620 1621void ObjCInterfaceType::Profile(llvm::FoldingSetNodeID &ID) { 1622 if (getNumProtocols()) 1623 Profile(ID, getDecl(), &Protocols[0], getNumProtocols()); 1624 else 1625 Profile(ID, getDecl(), 0, 0); 1626} 1627 1628void ObjCInterfaceType::getAsStringInternal(std::string &InnerString, 1629 const PrintingPolicy &Policy) const { 1630 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1631 InnerString = ' ' + InnerString; 1632 1633 std::string ObjCQIString = getDecl()->getNameAsString(); 1634 if (getNumProtocols()) { 1635 ObjCQIString += '<'; 1636 bool isFirst = true; 1637 for (qual_iterator I = qual_begin(), E = qual_end(); I != E; ++I) { 1638 if (isFirst) 1639 isFirst = false; 1640 else 1641 ObjCQIString += ','; 1642 ObjCQIString += (*I)->getNameAsString(); 1643 } 1644 ObjCQIString += '>'; 1645 } 1646 InnerString = ObjCQIString + InnerString; 1647} 1648 1649void ObjCObjectPointerType::getAsStringInternal(std::string &InnerString, 1650 const PrintingPolicy &Policy) const { 1651 std::string ObjCQIString; 1652 1653 if (isObjCIdType() || isObjCQualifiedIdType()) 1654 ObjCQIString = "id"; 1655 else if (isObjCClassType() || isObjCQualifiedClassType()) 1656 ObjCQIString = "Class"; 1657 else 1658 ObjCQIString = getInterfaceDecl()->getNameAsString(); 1659 1660 if (!qual_empty()) { 1661 ObjCQIString += '<'; 1662 for (qual_iterator I = qual_begin(), E = qual_end(); I != E; ++I) { 1663 ObjCQIString += (*I)->getNameAsString(); 1664 if (I+1 != E) 1665 ObjCQIString += ','; 1666 } 1667 ObjCQIString += '>'; 1668 } 1669 if (!isObjCIdType() && !isObjCQualifiedIdType()) 1670 ObjCQIString += " *"; // Don't forget the implicit pointer. 1671 else if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1672 InnerString = ' ' + InnerString; 1673 1674 InnerString = ObjCQIString + InnerString; 1675} 1676 1677void TagType::getAsStringInternal(std::string &InnerString, const PrintingPolicy &Policy) const { 1678 if (Policy.SuppressTag) 1679 return; 1680 1681 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1682 InnerString = ' ' + InnerString; 1683 1684 const char *Kind = Policy.SuppressTagKind? 0 : getDecl()->getKindName(); 1685 const char *ID; 1686 if (const IdentifierInfo *II = getDecl()->getIdentifier()) 1687 ID = II->getName(); 1688 else if (TypedefDecl *Typedef = getDecl()->getTypedefForAnonDecl()) { 1689 Kind = 0; 1690 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 1691 ID = Typedef->getIdentifier()->getName(); 1692 } else 1693 ID = "<anonymous>"; 1694 1695 // If this is a class template specialization, print the template 1696 // arguments. 1697 if (ClassTemplateSpecializationDecl *Spec 1698 = dyn_cast<ClassTemplateSpecializationDecl>(getDecl())) { 1699 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1700 std::string TemplateArgsStr 1701 = TemplateSpecializationType::PrintTemplateArgumentList( 1702 TemplateArgs.getFlatArgumentList(), 1703 TemplateArgs.flat_size(), 1704 Policy); 1705 InnerString = TemplateArgsStr + InnerString; 1706 } 1707 1708 if (Kind) { 1709 // Compute the full nested-name-specifier for this type. In C, 1710 // this will always be empty. 1711 std::string ContextStr; 1712 for (DeclContext *DC = getDecl()->getDeclContext(); 1713 !DC->isTranslationUnit(); DC = DC->getParent()) { 1714 std::string MyPart; 1715 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) { 1716 if (NS->getIdentifier()) 1717 MyPart = NS->getNameAsString(); 1718 } else if (ClassTemplateSpecializationDecl *Spec 1719 = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 1720 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1721 std::string TemplateArgsStr 1722 = TemplateSpecializationType::PrintTemplateArgumentList( 1723 TemplateArgs.getFlatArgumentList(), 1724 TemplateArgs.flat_size(), 1725 Policy); 1726 MyPart = Spec->getIdentifier()->getName() + TemplateArgsStr; 1727 } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) { 1728 if (TypedefDecl *Typedef = Tag->getTypedefForAnonDecl()) 1729 MyPart = Typedef->getIdentifier()->getName(); 1730 else if (Tag->getIdentifier()) 1731 MyPart = Tag->getIdentifier()->getName(); 1732 } 1733 1734 if (!MyPart.empty()) 1735 ContextStr = MyPart + "::" + ContextStr; 1736 } 1737 1738 InnerString = std::string(Kind) + " " + ContextStr + ID + InnerString; 1739 } else 1740 InnerString = ID + InnerString; 1741} 1742