1 //===- CXTypes.cpp - Implements 'CXTypes' aspect of libclang ------------===// 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 the 'CXTypes' API hooks in the Clang-C library. 11 // 12 //===--------------------------------------------------------------------===// 13 14 #include "CIndexer.h" 15 #include "CXCursor.h" 16 #include "CXString.h" 17 #include "CXTranslationUnit.h" 18 #include "CXType.h" 19 #include "clang/AST/Decl.h" 20 #include "clang/AST/DeclObjC.h" 21 #include "clang/AST/DeclTemplate.h" 22 #include "clang/AST/Expr.h" 23 #include "clang/AST/Type.h" 24 #include "clang/Frontend/ASTUnit.h" 25 26 using namespace clang; 27 28 static CXTypeKind GetBuiltinTypeKind(const BuiltinType *BT) { 29 #define BTCASE(K) case BuiltinType::K: return CXType_##K 30 switch (BT->getKind()) { 31 BTCASE(Void); 32 BTCASE(Bool); 33 BTCASE(Char_U); 34 BTCASE(UChar); 35 BTCASE(Char16); 36 BTCASE(Char32); 37 BTCASE(UShort); 38 BTCASE(UInt); 39 BTCASE(ULong); 40 BTCASE(ULongLong); 41 BTCASE(UInt128); 42 BTCASE(Char_S); 43 BTCASE(SChar); 44 case BuiltinType::WChar_S: return CXType_WChar; 45 case BuiltinType::WChar_U: return CXType_WChar; 46 BTCASE(Short); 47 BTCASE(Int); 48 BTCASE(Long); 49 BTCASE(LongLong); 50 BTCASE(Int128); 51 BTCASE(Float); 52 BTCASE(Double); 53 BTCASE(LongDouble); 54 BTCASE(Float128); 55 BTCASE(NullPtr); 56 BTCASE(Overload); 57 BTCASE(Dependent); 58 BTCASE(ObjCId); 59 BTCASE(ObjCClass); 60 BTCASE(ObjCSel); 61 default: 62 return CXType_Unexposed; 63 } 64 #undef BTCASE 65 } 66 67 static CXTypeKind GetTypeKind(QualType T) { 68 const Type *TP = T.getTypePtrOrNull(); 69 if (!TP) 70 return CXType_Invalid; 71 72 #define TKCASE(K) case Type::K: return CXType_##K 73 switch (TP->getTypeClass()) { 74 case Type::Builtin: 75 return GetBuiltinTypeKind(cast<BuiltinType>(TP)); 76 TKCASE(Complex); 77 TKCASE(Pointer); 78 TKCASE(BlockPointer); 79 TKCASE(LValueReference); 80 TKCASE(RValueReference); 81 TKCASE(Record); 82 TKCASE(Enum); 83 TKCASE(Typedef); 84 TKCASE(ObjCInterface); 85 TKCASE(ObjCObjectPointer); 86 TKCASE(FunctionNoProto); 87 TKCASE(FunctionProto); 88 TKCASE(ConstantArray); 89 TKCASE(IncompleteArray); 90 TKCASE(VariableArray); 91 TKCASE(DependentSizedArray); 92 TKCASE(Vector); 93 TKCASE(MemberPointer); 94 TKCASE(Auto); 95 TKCASE(Elaborated); 96 default: 97 return CXType_Unexposed; 98 } 99 #undef TKCASE 100 } 101 102 103 CXType cxtype::MakeCXType(QualType T, CXTranslationUnit TU) { 104 CXTypeKind TK = CXType_Invalid; 105 106 if (TU && !T.isNull()) { 107 // Handle attributed types as the original type 108 if (auto *ATT = T->getAs<AttributedType>()) { 109 return MakeCXType(ATT->getModifiedType(), TU); 110 } 111 112 ASTContext &Ctx = cxtu::getASTUnit(TU)->getASTContext(); 113 if (Ctx.getLangOpts().ObjC1) { 114 QualType UnqualT = T.getUnqualifiedType(); 115 if (Ctx.isObjCIdType(UnqualT)) 116 TK = CXType_ObjCId; 117 else if (Ctx.isObjCClassType(UnqualT)) 118 TK = CXType_ObjCClass; 119 else if (Ctx.isObjCSelType(UnqualT)) 120 TK = CXType_ObjCSel; 121 } 122 123 /* Handle decayed types as the original type */ 124 if (const DecayedType *DT = T->getAs<DecayedType>()) { 125 return MakeCXType(DT->getOriginalType(), TU); 126 } 127 } 128 if (TK == CXType_Invalid) 129 TK = GetTypeKind(T); 130 131 CXType CT = { TK, { TK == CXType_Invalid ? nullptr 132 : T.getAsOpaquePtr(), TU } }; 133 return CT; 134 } 135 136 using cxtype::MakeCXType; 137 138 static inline QualType GetQualType(CXType CT) { 139 return QualType::getFromOpaquePtr(CT.data[0]); 140 } 141 142 static inline CXTranslationUnit GetTU(CXType CT) { 143 return static_cast<CXTranslationUnit>(CT.data[1]); 144 } 145 146 extern "C" { 147 148 CXType clang_getCursorType(CXCursor C) { 149 using namespace cxcursor; 150 151 CXTranslationUnit TU = cxcursor::getCursorTU(C); 152 if (!TU) 153 return MakeCXType(QualType(), TU); 154 155 ASTContext &Context = cxtu::getASTUnit(TU)->getASTContext(); 156 if (clang_isExpression(C.kind)) { 157 QualType T = cxcursor::getCursorExpr(C)->getType(); 158 return MakeCXType(T, TU); 159 } 160 161 if (clang_isDeclaration(C.kind)) { 162 const Decl *D = cxcursor::getCursorDecl(C); 163 if (!D) 164 return MakeCXType(QualType(), TU); 165 166 if (const TypeDecl *TD = dyn_cast<TypeDecl>(D)) 167 return MakeCXType(Context.getTypeDeclType(TD), TU); 168 if (const ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) 169 return MakeCXType(Context.getObjCInterfaceType(ID), TU); 170 if (const DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) 171 return MakeCXType(DD->getType(), TU); 172 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) 173 return MakeCXType(VD->getType(), TU); 174 if (const ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(D)) 175 return MakeCXType(PD->getType(), TU); 176 if (const FunctionTemplateDecl *FTD = dyn_cast<FunctionTemplateDecl>(D)) 177 return MakeCXType(FTD->getTemplatedDecl()->getType(), TU); 178 return MakeCXType(QualType(), TU); 179 } 180 181 if (clang_isReference(C.kind)) { 182 switch (C.kind) { 183 case CXCursor_ObjCSuperClassRef: { 184 QualType T 185 = Context.getObjCInterfaceType(getCursorObjCSuperClassRef(C).first); 186 return MakeCXType(T, TU); 187 } 188 189 case CXCursor_ObjCClassRef: { 190 QualType T = Context.getObjCInterfaceType(getCursorObjCClassRef(C).first); 191 return MakeCXType(T, TU); 192 } 193 194 case CXCursor_TypeRef: { 195 QualType T = Context.getTypeDeclType(getCursorTypeRef(C).first); 196 return MakeCXType(T, TU); 197 198 } 199 200 case CXCursor_CXXBaseSpecifier: 201 return cxtype::MakeCXType(getCursorCXXBaseSpecifier(C)->getType(), TU); 202 203 case CXCursor_MemberRef: 204 return cxtype::MakeCXType(getCursorMemberRef(C).first->getType(), TU); 205 206 case CXCursor_VariableRef: 207 return cxtype::MakeCXType(getCursorVariableRef(C).first->getType(), TU); 208 209 case CXCursor_ObjCProtocolRef: 210 case CXCursor_TemplateRef: 211 case CXCursor_NamespaceRef: 212 case CXCursor_OverloadedDeclRef: 213 default: 214 break; 215 } 216 217 return MakeCXType(QualType(), TU); 218 } 219 220 return MakeCXType(QualType(), TU); 221 } 222 223 CXString clang_getTypeSpelling(CXType CT) { 224 QualType T = GetQualType(CT); 225 if (T.isNull()) 226 return cxstring::createEmpty(); 227 228 CXTranslationUnit TU = GetTU(CT); 229 SmallString<64> Str; 230 llvm::raw_svector_ostream OS(Str); 231 PrintingPolicy PP(cxtu::getASTUnit(TU)->getASTContext().getLangOpts()); 232 233 T.print(OS, PP); 234 235 return cxstring::createDup(OS.str()); 236 } 237 238 CXType clang_getTypedefDeclUnderlyingType(CXCursor C) { 239 using namespace cxcursor; 240 CXTranslationUnit TU = cxcursor::getCursorTU(C); 241 242 if (clang_isDeclaration(C.kind)) { 243 const Decl *D = cxcursor::getCursorDecl(C); 244 245 if (const TypedefNameDecl *TD = dyn_cast_or_null<TypedefNameDecl>(D)) { 246 QualType T = TD->getUnderlyingType(); 247 return MakeCXType(T, TU); 248 } 249 250 return MakeCXType(QualType(), TU); 251 } 252 253 return MakeCXType(QualType(), TU); 254 } 255 256 CXType clang_getEnumDeclIntegerType(CXCursor C) { 257 using namespace cxcursor; 258 CXTranslationUnit TU = cxcursor::getCursorTU(C); 259 260 if (clang_isDeclaration(C.kind)) { 261 const Decl *D = cxcursor::getCursorDecl(C); 262 263 if (const EnumDecl *TD = dyn_cast_or_null<EnumDecl>(D)) { 264 QualType T = TD->getIntegerType(); 265 return MakeCXType(T, TU); 266 } 267 268 return MakeCXType(QualType(), TU); 269 } 270 271 return MakeCXType(QualType(), TU); 272 } 273 274 long long clang_getEnumConstantDeclValue(CXCursor C) { 275 using namespace cxcursor; 276 277 if (clang_isDeclaration(C.kind)) { 278 const Decl *D = cxcursor::getCursorDecl(C); 279 280 if (const EnumConstantDecl *TD = dyn_cast_or_null<EnumConstantDecl>(D)) { 281 return TD->getInitVal().getSExtValue(); 282 } 283 284 return LLONG_MIN; 285 } 286 287 return LLONG_MIN; 288 } 289 290 unsigned long long clang_getEnumConstantDeclUnsignedValue(CXCursor C) { 291 using namespace cxcursor; 292 293 if (clang_isDeclaration(C.kind)) { 294 const Decl *D = cxcursor::getCursorDecl(C); 295 296 if (const EnumConstantDecl *TD = dyn_cast_or_null<EnumConstantDecl>(D)) { 297 return TD->getInitVal().getZExtValue(); 298 } 299 300 return ULLONG_MAX; 301 } 302 303 return ULLONG_MAX; 304 } 305 306 int clang_getFieldDeclBitWidth(CXCursor C) { 307 using namespace cxcursor; 308 309 if (clang_isDeclaration(C.kind)) { 310 const Decl *D = getCursorDecl(C); 311 312 if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) { 313 if (FD->isBitField()) 314 return FD->getBitWidthValue(getCursorContext(C)); 315 } 316 } 317 318 return -1; 319 } 320 321 CXType clang_getCanonicalType(CXType CT) { 322 if (CT.kind == CXType_Invalid) 323 return CT; 324 325 QualType T = GetQualType(CT); 326 CXTranslationUnit TU = GetTU(CT); 327 328 if (T.isNull()) 329 return MakeCXType(QualType(), GetTU(CT)); 330 331 return MakeCXType(cxtu::getASTUnit(TU)->getASTContext() 332 .getCanonicalType(T), 333 TU); 334 } 335 336 unsigned clang_isConstQualifiedType(CXType CT) { 337 QualType T = GetQualType(CT); 338 return T.isLocalConstQualified(); 339 } 340 341 unsigned clang_isVolatileQualifiedType(CXType CT) { 342 QualType T = GetQualType(CT); 343 return T.isLocalVolatileQualified(); 344 } 345 346 unsigned clang_isRestrictQualifiedType(CXType CT) { 347 QualType T = GetQualType(CT); 348 return T.isLocalRestrictQualified(); 349 } 350 351 CXType clang_getPointeeType(CXType CT) { 352 QualType T = GetQualType(CT); 353 const Type *TP = T.getTypePtrOrNull(); 354 355 if (!TP) 356 return MakeCXType(QualType(), GetTU(CT)); 357 358 switch (TP->getTypeClass()) { 359 case Type::Pointer: 360 T = cast<PointerType>(TP)->getPointeeType(); 361 break; 362 case Type::BlockPointer: 363 T = cast<BlockPointerType>(TP)->getPointeeType(); 364 break; 365 case Type::LValueReference: 366 case Type::RValueReference: 367 T = cast<ReferenceType>(TP)->getPointeeType(); 368 break; 369 case Type::ObjCObjectPointer: 370 T = cast<ObjCObjectPointerType>(TP)->getPointeeType(); 371 break; 372 case Type::MemberPointer: 373 T = cast<MemberPointerType>(TP)->getPointeeType(); 374 break; 375 default: 376 T = QualType(); 377 break; 378 } 379 return MakeCXType(T, GetTU(CT)); 380 } 381 382 CXCursor clang_getTypeDeclaration(CXType CT) { 383 if (CT.kind == CXType_Invalid) 384 return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound); 385 386 QualType T = GetQualType(CT); 387 const Type *TP = T.getTypePtrOrNull(); 388 389 if (!TP) 390 return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound); 391 392 Decl *D = nullptr; 393 394 try_again: 395 switch (TP->getTypeClass()) { 396 case Type::Typedef: 397 D = cast<TypedefType>(TP)->getDecl(); 398 break; 399 case Type::ObjCObject: 400 D = cast<ObjCObjectType>(TP)->getInterface(); 401 break; 402 case Type::ObjCInterface: 403 D = cast<ObjCInterfaceType>(TP)->getDecl(); 404 break; 405 case Type::Record: 406 case Type::Enum: 407 D = cast<TagType>(TP)->getDecl(); 408 break; 409 case Type::TemplateSpecialization: 410 if (const RecordType *Record = TP->getAs<RecordType>()) 411 D = Record->getDecl(); 412 else 413 D = cast<TemplateSpecializationType>(TP)->getTemplateName() 414 .getAsTemplateDecl(); 415 break; 416 417 case Type::Auto: 418 TP = cast<AutoType>(TP)->getDeducedType().getTypePtrOrNull(); 419 if (TP) 420 goto try_again; 421 break; 422 423 case Type::InjectedClassName: 424 D = cast<InjectedClassNameType>(TP)->getDecl(); 425 break; 426 427 // FIXME: Template type parameters! 428 429 case Type::Elaborated: 430 TP = cast<ElaboratedType>(TP)->getNamedType().getTypePtrOrNull(); 431 goto try_again; 432 433 default: 434 break; 435 } 436 437 if (!D) 438 return cxcursor::MakeCXCursorInvalid(CXCursor_NoDeclFound); 439 440 return cxcursor::MakeCXCursor(D, GetTU(CT)); 441 } 442 443 CXString clang_getTypeKindSpelling(enum CXTypeKind K) { 444 const char *s = nullptr; 445 #define TKIND(X) case CXType_##X: s = "" #X ""; break 446 switch (K) { 447 TKIND(Invalid); 448 TKIND(Unexposed); 449 TKIND(Void); 450 TKIND(Bool); 451 TKIND(Char_U); 452 TKIND(UChar); 453 TKIND(Char16); 454 TKIND(Char32); 455 TKIND(UShort); 456 TKIND(UInt); 457 TKIND(ULong); 458 TKIND(ULongLong); 459 TKIND(UInt128); 460 TKIND(Char_S); 461 TKIND(SChar); 462 case CXType_WChar: s = "WChar"; break; 463 TKIND(Short); 464 TKIND(Int); 465 TKIND(Long); 466 TKIND(LongLong); 467 TKIND(Int128); 468 TKIND(Float); 469 TKIND(Double); 470 TKIND(LongDouble); 471 TKIND(Float128); 472 TKIND(NullPtr); 473 TKIND(Overload); 474 TKIND(Dependent); 475 TKIND(ObjCId); 476 TKIND(ObjCClass); 477 TKIND(ObjCSel); 478 TKIND(Complex); 479 TKIND(Pointer); 480 TKIND(BlockPointer); 481 TKIND(LValueReference); 482 TKIND(RValueReference); 483 TKIND(Record); 484 TKIND(Enum); 485 TKIND(Typedef); 486 TKIND(ObjCInterface); 487 TKIND(ObjCObjectPointer); 488 TKIND(FunctionNoProto); 489 TKIND(FunctionProto); 490 TKIND(ConstantArray); 491 TKIND(IncompleteArray); 492 TKIND(VariableArray); 493 TKIND(DependentSizedArray); 494 TKIND(Vector); 495 TKIND(MemberPointer); 496 TKIND(Auto); 497 TKIND(Elaborated); 498 } 499 #undef TKIND 500 return cxstring::createRef(s); 501 } 502 503 unsigned clang_equalTypes(CXType A, CXType B) { 504 return A.data[0] == B.data[0] && A.data[1] == B.data[1]; 505 } 506 507 unsigned clang_isFunctionTypeVariadic(CXType X) { 508 QualType T = GetQualType(X); 509 if (T.isNull()) 510 return 0; 511 512 if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) 513 return (unsigned)FD->isVariadic(); 514 515 if (T->getAs<FunctionNoProtoType>()) 516 return 1; 517 518 return 0; 519 } 520 521 CXCallingConv clang_getFunctionTypeCallingConv(CXType X) { 522 QualType T = GetQualType(X); 523 if (T.isNull()) 524 return CXCallingConv_Invalid; 525 526 if (const FunctionType *FD = T->getAs<FunctionType>()) { 527 #define TCALLINGCONV(X) case CC_##X: return CXCallingConv_##X 528 switch (FD->getCallConv()) { 529 TCALLINGCONV(C); 530 TCALLINGCONV(X86StdCall); 531 TCALLINGCONV(X86FastCall); 532 TCALLINGCONV(X86ThisCall); 533 TCALLINGCONV(X86Pascal); 534 TCALLINGCONV(X86VectorCall); 535 TCALLINGCONV(X86_64Win64); 536 TCALLINGCONV(X86_64SysV); 537 TCALLINGCONV(AAPCS); 538 TCALLINGCONV(AAPCS_VFP); 539 TCALLINGCONV(IntelOclBicc); 540 TCALLINGCONV(Swift); 541 TCALLINGCONV(PreserveMost); 542 TCALLINGCONV(PreserveAll); 543 case CC_SpirFunction: return CXCallingConv_Unexposed; 544 case CC_OpenCLKernel: return CXCallingConv_Unexposed; 545 break; 546 } 547 #undef TCALLINGCONV 548 } 549 550 return CXCallingConv_Invalid; 551 } 552 553 int clang_getNumArgTypes(CXType X) { 554 QualType T = GetQualType(X); 555 if (T.isNull()) 556 return -1; 557 558 if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) { 559 return FD->getNumParams(); 560 } 561 562 if (T->getAs<FunctionNoProtoType>()) { 563 return 0; 564 } 565 566 return -1; 567 } 568 569 CXType clang_getArgType(CXType X, unsigned i) { 570 QualType T = GetQualType(X); 571 if (T.isNull()) 572 return MakeCXType(QualType(), GetTU(X)); 573 574 if (const FunctionProtoType *FD = T->getAs<FunctionProtoType>()) { 575 unsigned numParams = FD->getNumParams(); 576 if (i >= numParams) 577 return MakeCXType(QualType(), GetTU(X)); 578 579 return MakeCXType(FD->getParamType(i), GetTU(X)); 580 } 581 582 return MakeCXType(QualType(), GetTU(X)); 583 } 584 585 CXType clang_getResultType(CXType X) { 586 QualType T = GetQualType(X); 587 if (T.isNull()) 588 return MakeCXType(QualType(), GetTU(X)); 589 590 if (const FunctionType *FD = T->getAs<FunctionType>()) 591 return MakeCXType(FD->getReturnType(), GetTU(X)); 592 593 return MakeCXType(QualType(), GetTU(X)); 594 } 595 596 CXType clang_getCursorResultType(CXCursor C) { 597 if (clang_isDeclaration(C.kind)) { 598 const Decl *D = cxcursor::getCursorDecl(C); 599 if (const ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(D)) 600 return MakeCXType(MD->getReturnType(), cxcursor::getCursorTU(C)); 601 602 return clang_getResultType(clang_getCursorType(C)); 603 } 604 605 return MakeCXType(QualType(), cxcursor::getCursorTU(C)); 606 } 607 608 unsigned clang_isPODType(CXType X) { 609 QualType T = GetQualType(X); 610 if (T.isNull()) 611 return 0; 612 613 CXTranslationUnit TU = GetTU(X); 614 615 return T.isPODType(cxtu::getASTUnit(TU)->getASTContext()) ? 1 : 0; 616 } 617 618 CXType clang_getElementType(CXType CT) { 619 QualType ET = QualType(); 620 QualType T = GetQualType(CT); 621 const Type *TP = T.getTypePtrOrNull(); 622 623 if (TP) { 624 switch (TP->getTypeClass()) { 625 case Type::ConstantArray: 626 ET = cast<ConstantArrayType> (TP)->getElementType(); 627 break; 628 case Type::IncompleteArray: 629 ET = cast<IncompleteArrayType> (TP)->getElementType(); 630 break; 631 case Type::VariableArray: 632 ET = cast<VariableArrayType> (TP)->getElementType(); 633 break; 634 case Type::DependentSizedArray: 635 ET = cast<DependentSizedArrayType> (TP)->getElementType(); 636 break; 637 case Type::Vector: 638 ET = cast<VectorType> (TP)->getElementType(); 639 break; 640 case Type::Complex: 641 ET = cast<ComplexType> (TP)->getElementType(); 642 break; 643 default: 644 break; 645 } 646 } 647 return MakeCXType(ET, GetTU(CT)); 648 } 649 650 long long clang_getNumElements(CXType CT) { 651 long long result = -1; 652 QualType T = GetQualType(CT); 653 const Type *TP = T.getTypePtrOrNull(); 654 655 if (TP) { 656 switch (TP->getTypeClass()) { 657 case Type::ConstantArray: 658 result = cast<ConstantArrayType> (TP)->getSize().getSExtValue(); 659 break; 660 case Type::Vector: 661 result = cast<VectorType> (TP)->getNumElements(); 662 break; 663 default: 664 break; 665 } 666 } 667 return result; 668 } 669 670 CXType clang_getArrayElementType(CXType CT) { 671 QualType ET = QualType(); 672 QualType T = GetQualType(CT); 673 const Type *TP = T.getTypePtrOrNull(); 674 675 if (TP) { 676 switch (TP->getTypeClass()) { 677 case Type::ConstantArray: 678 ET = cast<ConstantArrayType> (TP)->getElementType(); 679 break; 680 case Type::IncompleteArray: 681 ET = cast<IncompleteArrayType> (TP)->getElementType(); 682 break; 683 case Type::VariableArray: 684 ET = cast<VariableArrayType> (TP)->getElementType(); 685 break; 686 case Type::DependentSizedArray: 687 ET = cast<DependentSizedArrayType> (TP)->getElementType(); 688 break; 689 default: 690 break; 691 } 692 } 693 return MakeCXType(ET, GetTU(CT)); 694 } 695 696 long long clang_getArraySize(CXType CT) { 697 long long result = -1; 698 QualType T = GetQualType(CT); 699 const Type *TP = T.getTypePtrOrNull(); 700 701 if (TP) { 702 switch (TP->getTypeClass()) { 703 case Type::ConstantArray: 704 result = cast<ConstantArrayType> (TP)->getSize().getSExtValue(); 705 break; 706 default: 707 break; 708 } 709 } 710 return result; 711 } 712 713 long long clang_Type_getAlignOf(CXType T) { 714 if (T.kind == CXType_Invalid) 715 return CXTypeLayoutError_Invalid; 716 ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext(); 717 QualType QT = GetQualType(T); 718 // [expr.alignof] p1: return size_t value for complete object type, reference 719 // or array. 720 // [expr.alignof] p3: if reference type, return size of referenced type 721 if (QT->isReferenceType()) 722 QT = QT.getNonReferenceType(); 723 if (QT->isIncompleteType()) 724 return CXTypeLayoutError_Incomplete; 725 if (QT->isDependentType()) 726 return CXTypeLayoutError_Dependent; 727 // Exceptions by GCC extension - see ASTContext.cpp:1313 getTypeInfoImpl 728 // if (QT->isFunctionType()) return 4; // Bug #15511 - should be 1 729 // if (QT->isVoidType()) return 1; 730 return Ctx.getTypeAlignInChars(QT).getQuantity(); 731 } 732 733 CXType clang_Type_getClassType(CXType CT) { 734 QualType ET = QualType(); 735 QualType T = GetQualType(CT); 736 const Type *TP = T.getTypePtrOrNull(); 737 738 if (TP && TP->getTypeClass() == Type::MemberPointer) { 739 ET = QualType(cast<MemberPointerType> (TP)->getClass(), 0); 740 } 741 return MakeCXType(ET, GetTU(CT)); 742 } 743 744 long long clang_Type_getSizeOf(CXType T) { 745 if (T.kind == CXType_Invalid) 746 return CXTypeLayoutError_Invalid; 747 ASTContext &Ctx = cxtu::getASTUnit(GetTU(T))->getASTContext(); 748 QualType QT = GetQualType(T); 749 // [expr.sizeof] p2: if reference type, return size of referenced type 750 if (QT->isReferenceType()) 751 QT = QT.getNonReferenceType(); 752 // [expr.sizeof] p1: return -1 on: func, incomplete, bitfield, incomplete 753 // enumeration 754 // Note: We get the cxtype, not the cxcursor, so we can't call 755 // FieldDecl->isBitField() 756 // [expr.sizeof] p3: pointer ok, function not ok. 757 // [gcc extension] lib/AST/ExprConstant.cpp:1372 HandleSizeof : vla == error 758 if (QT->isIncompleteType()) 759 return CXTypeLayoutError_Incomplete; 760 if (QT->isDependentType()) 761 return CXTypeLayoutError_Dependent; 762 if (!QT->isConstantSizeType()) 763 return CXTypeLayoutError_NotConstantSize; 764 // [gcc extension] lib/AST/ExprConstant.cpp:1372 765 // HandleSizeof : {voidtype,functype} == 1 766 // not handled by ASTContext.cpp:1313 getTypeInfoImpl 767 if (QT->isVoidType() || QT->isFunctionType()) 768 return 1; 769 return Ctx.getTypeSizeInChars(QT).getQuantity(); 770 } 771 772 static long long visitRecordForValidation(const RecordDecl *RD) { 773 for (const auto *I : RD->fields()){ 774 QualType FQT = I->getType(); 775 if (FQT->isIncompleteType()) 776 return CXTypeLayoutError_Incomplete; 777 if (FQT->isDependentType()) 778 return CXTypeLayoutError_Dependent; 779 // recurse 780 if (const RecordType *ChildType = I->getType()->getAs<RecordType>()) { 781 if (const RecordDecl *Child = ChildType->getDecl()) { 782 long long ret = visitRecordForValidation(Child); 783 if (ret < 0) 784 return ret; 785 } 786 } 787 // else try next field 788 } 789 return 0; 790 } 791 792 static long long validateFieldParentType(CXCursor PC, CXType PT){ 793 if (clang_isInvalid(PC.kind)) 794 return CXTypeLayoutError_Invalid; 795 const RecordDecl *RD = 796 dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC)); 797 // validate parent declaration 798 if (!RD || RD->isInvalidDecl()) 799 return CXTypeLayoutError_Invalid; 800 RD = RD->getDefinition(); 801 if (!RD) 802 return CXTypeLayoutError_Incomplete; 803 if (RD->isInvalidDecl()) 804 return CXTypeLayoutError_Invalid; 805 // validate parent type 806 QualType RT = GetQualType(PT); 807 if (RT->isIncompleteType()) 808 return CXTypeLayoutError_Incomplete; 809 if (RT->isDependentType()) 810 return CXTypeLayoutError_Dependent; 811 // We recurse into all record fields to detect incomplete and dependent types. 812 long long Error = visitRecordForValidation(RD); 813 if (Error < 0) 814 return Error; 815 return 0; 816 } 817 818 long long clang_Type_getOffsetOf(CXType PT, const char *S) { 819 // check that PT is not incomplete/dependent 820 CXCursor PC = clang_getTypeDeclaration(PT); 821 long long Error = validateFieldParentType(PC,PT); 822 if (Error < 0) 823 return Error; 824 if (!S) 825 return CXTypeLayoutError_InvalidFieldName; 826 // lookup field 827 ASTContext &Ctx = cxtu::getASTUnit(GetTU(PT))->getASTContext(); 828 IdentifierInfo *II = &Ctx.Idents.get(S); 829 DeclarationName FieldName(II); 830 const RecordDecl *RD = 831 dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC)); 832 // verified in validateFieldParentType 833 RD = RD->getDefinition(); 834 RecordDecl::lookup_result Res = RD->lookup(FieldName); 835 // If a field of the parent record is incomplete, lookup will fail. 836 // and we would return InvalidFieldName instead of Incomplete. 837 // But this erroneous results does protects again a hidden assertion failure 838 // in the RecordLayoutBuilder 839 if (Res.size() != 1) 840 return CXTypeLayoutError_InvalidFieldName; 841 if (const FieldDecl *FD = dyn_cast<FieldDecl>(Res.front())) 842 return Ctx.getFieldOffset(FD); 843 if (const IndirectFieldDecl *IFD = dyn_cast<IndirectFieldDecl>(Res.front())) 844 return Ctx.getFieldOffset(IFD); 845 // we don't want any other Decl Type. 846 return CXTypeLayoutError_InvalidFieldName; 847 } 848 849 long long clang_Cursor_getOffsetOfField(CXCursor C) { 850 if (clang_isDeclaration(C.kind)) { 851 // we need to validate the parent type 852 CXCursor PC = clang_getCursorSemanticParent(C); 853 CXType PT = clang_getCursorType(PC); 854 long long Error = validateFieldParentType(PC,PT); 855 if (Error < 0) 856 return Error; 857 // proceed with the offset calculation 858 const Decl *D = cxcursor::getCursorDecl(C); 859 ASTContext &Ctx = cxcursor::getCursorContext(C); 860 if (const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) 861 return Ctx.getFieldOffset(FD); 862 if (const IndirectFieldDecl *IFD = dyn_cast_or_null<IndirectFieldDecl>(D)) 863 return Ctx.getFieldOffset(IFD); 864 } 865 return -1; 866 } 867 868 enum CXRefQualifierKind clang_Type_getCXXRefQualifier(CXType T) { 869 QualType QT = GetQualType(T); 870 if (QT.isNull()) 871 return CXRefQualifier_None; 872 const FunctionProtoType *FD = QT->getAs<FunctionProtoType>(); 873 if (!FD) 874 return CXRefQualifier_None; 875 switch (FD->getRefQualifier()) { 876 case RQ_None: 877 return CXRefQualifier_None; 878 case RQ_LValue: 879 return CXRefQualifier_LValue; 880 case RQ_RValue: 881 return CXRefQualifier_RValue; 882 } 883 return CXRefQualifier_None; 884 } 885 886 unsigned clang_Cursor_isBitField(CXCursor C) { 887 if (!clang_isDeclaration(C.kind)) 888 return 0; 889 const FieldDecl *FD = dyn_cast_or_null<FieldDecl>(cxcursor::getCursorDecl(C)); 890 if (!FD) 891 return 0; 892 return FD->isBitField(); 893 } 894 895 CXString clang_getDeclObjCTypeEncoding(CXCursor C) { 896 if (!clang_isDeclaration(C.kind)) 897 return cxstring::createEmpty(); 898 899 const Decl *D = cxcursor::getCursorDecl(C); 900 ASTContext &Ctx = cxcursor::getCursorContext(C); 901 std::string encoding; 902 903 if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D)) { 904 if (Ctx.getObjCEncodingForMethodDecl(OMD, encoding)) 905 return cxstring::createRef("?"); 906 } else if (const ObjCPropertyDecl *OPD = dyn_cast<ObjCPropertyDecl>(D)) 907 Ctx.getObjCEncodingForPropertyDecl(OPD, nullptr, encoding); 908 else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 909 Ctx.getObjCEncodingForFunctionDecl(FD, encoding); 910 else { 911 QualType Ty; 912 if (const TypeDecl *TD = dyn_cast<TypeDecl>(D)) 913 Ty = Ctx.getTypeDeclType(TD); 914 if (const ValueDecl *VD = dyn_cast<ValueDecl>(D)) 915 Ty = VD->getType(); 916 else return cxstring::createRef("?"); 917 Ctx.getObjCEncodingForType(Ty, encoding); 918 } 919 920 return cxstring::createDup(encoding); 921 } 922 923 int clang_Type_getNumTemplateArguments(CXType CT) { 924 QualType T = GetQualType(CT); 925 if (T.isNull()) 926 return -1; 927 const CXXRecordDecl *RecordDecl = T->getAsCXXRecordDecl(); 928 if (!RecordDecl) 929 return -1; 930 const ClassTemplateSpecializationDecl *TemplateDecl = 931 dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl); 932 if (!TemplateDecl) 933 return -1; 934 return TemplateDecl->getTemplateArgs().size(); 935 } 936 937 CXType clang_Type_getTemplateArgumentAsType(CXType CT, unsigned i) { 938 QualType T = GetQualType(CT); 939 if (T.isNull()) 940 return MakeCXType(QualType(), GetTU(CT)); 941 const CXXRecordDecl *RecordDecl = T->getAsCXXRecordDecl(); 942 if (!RecordDecl) 943 return MakeCXType(QualType(), GetTU(CT)); 944 const ClassTemplateSpecializationDecl *TemplateDecl = 945 dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl); 946 if (!TemplateDecl) 947 return MakeCXType(QualType(), GetTU(CT)); 948 const TemplateArgumentList &TA = TemplateDecl->getTemplateArgs(); 949 if (TA.size() <= i) 950 return MakeCXType(QualType(), GetTU(CT)); 951 const TemplateArgument &A = TA.get(i); 952 if (A.getKind() != TemplateArgument::Type) 953 return MakeCXType(QualType(), GetTU(CT)); 954 return MakeCXType(A.getAsType(), GetTU(CT)); 955 } 956 957 unsigned clang_Type_visitFields(CXType PT, 958 CXFieldVisitor visitor, 959 CXClientData client_data){ 960 CXCursor PC = clang_getTypeDeclaration(PT); 961 if (clang_isInvalid(PC.kind)) 962 return false; 963 const RecordDecl *RD = 964 dyn_cast_or_null<RecordDecl>(cxcursor::getCursorDecl(PC)); 965 if (!RD || RD->isInvalidDecl()) 966 return false; 967 RD = RD->getDefinition(); 968 if (!RD || RD->isInvalidDecl()) 969 return false; 970 971 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end(); 972 I != E; ++I){ 973 const FieldDecl *FD = dyn_cast_or_null<FieldDecl>((*I)); 974 // Callback to the client. 975 switch (visitor(cxcursor::MakeCXCursor(FD, GetTU(PT)), client_data)){ 976 case CXVisit_Break: 977 return true; 978 case CXVisit_Continue: 979 break; 980 } 981 } 982 return true; 983 } 984 985 unsigned clang_Cursor_isAnonymous(CXCursor C){ 986 if (!clang_isDeclaration(C.kind)) 987 return 0; 988 const Decl *D = cxcursor::getCursorDecl(C); 989 if (const RecordDecl *FD = dyn_cast_or_null<RecordDecl>(D)) 990 return FD->isAnonymousStructOrUnion(); 991 return 0; 992 } 993 994 CXType clang_Type_getNamedType(CXType CT){ 995 QualType T = GetQualType(CT); 996 const Type *TP = T.getTypePtrOrNull(); 997 998 if (TP && TP->getTypeClass() == Type::Elaborated) 999 return MakeCXType(cast<ElaboratedType>(TP)->getNamedType(), GetTU(CT)); 1000 1001 return MakeCXType(QualType(), GetTU(CT)); 1002 } 1003 1004 } // end: extern "C" 1005