1 //===--- TypePrinter.cpp - Pretty-Print Clang Types -----------------------===// 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 contains code to print types from Clang's type system. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/PrettyPrinter.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/Decl.h" 17 #include "clang/AST/DeclObjC.h" 18 #include "clang/AST/DeclTemplate.h" 19 #include "clang/AST/Expr.h" 20 #include "clang/AST/Type.h" 21 #include "clang/Basic/LangOptions.h" 22 #include "clang/Basic/SourceManager.h" 23 #include "llvm/ADT/SmallString.h" 24 #include "llvm/ADT/StringExtras.h" 25 #include "llvm/Support/SaveAndRestore.h" 26 #include "llvm/Support/raw_ostream.h" 27 using namespace clang; 28 29 namespace { 30 /// \brief RAII object that enables printing of the ARC __strong lifetime 31 /// qualifier. 32 class IncludeStrongLifetimeRAII { 33 PrintingPolicy &Policy; 34 bool Old; 35 36 public: 37 explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy) 38 : Policy(Policy), Old(Policy.SuppressStrongLifetime) { 39 if (!Policy.SuppressLifetimeQualifiers) 40 Policy.SuppressStrongLifetime = false; 41 } 42 43 ~IncludeStrongLifetimeRAII() { 44 Policy.SuppressStrongLifetime = Old; 45 } 46 }; 47 48 class ParamPolicyRAII { 49 PrintingPolicy &Policy; 50 bool Old; 51 52 public: 53 explicit ParamPolicyRAII(PrintingPolicy &Policy) 54 : Policy(Policy), Old(Policy.SuppressSpecifiers) { 55 Policy.SuppressSpecifiers = false; 56 } 57 58 ~ParamPolicyRAII() { 59 Policy.SuppressSpecifiers = Old; 60 } 61 }; 62 63 class ElaboratedTypePolicyRAII { 64 PrintingPolicy &Policy; 65 bool SuppressTagKeyword; 66 bool SuppressScope; 67 68 public: 69 explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) { 70 SuppressTagKeyword = Policy.SuppressTagKeyword; 71 SuppressScope = Policy.SuppressScope; 72 Policy.SuppressTagKeyword = true; 73 Policy.SuppressScope = true; 74 } 75 76 ~ElaboratedTypePolicyRAII() { 77 Policy.SuppressTagKeyword = SuppressTagKeyword; 78 Policy.SuppressScope = SuppressScope; 79 } 80 }; 81 82 class TypePrinter { 83 PrintingPolicy Policy; 84 bool HasEmptyPlaceHolder; 85 bool InsideCCAttribute; 86 87 public: 88 explicit TypePrinter(const PrintingPolicy &Policy) 89 : Policy(Policy), HasEmptyPlaceHolder(false), InsideCCAttribute(false) { } 90 91 void print(const Type *ty, Qualifiers qs, raw_ostream &OS, 92 StringRef PlaceHolder); 93 void print(QualType T, raw_ostream &OS, StringRef PlaceHolder); 94 95 static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier); 96 void spaceBeforePlaceHolder(raw_ostream &OS); 97 void printTypeSpec(const NamedDecl *D, raw_ostream &OS); 98 99 void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS); 100 void printBefore(QualType T, raw_ostream &OS); 101 void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS); 102 void printAfter(QualType T, raw_ostream &OS); 103 void AppendScope(DeclContext *DC, raw_ostream &OS); 104 void printTag(TagDecl *T, raw_ostream &OS); 105 #define ABSTRACT_TYPE(CLASS, PARENT) 106 #define TYPE(CLASS, PARENT) \ 107 void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \ 108 void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS); 109 #include "clang/AST/TypeNodes.def" 110 }; 111 } 112 113 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, bool C99) { 114 bool appendSpace = false; 115 if (TypeQuals & Qualifiers::Const) { 116 OS << "const"; 117 appendSpace = true; 118 } 119 if (TypeQuals & Qualifiers::Volatile) { 120 if (appendSpace) OS << ' '; 121 OS << "volatile"; 122 appendSpace = true; 123 } 124 if (TypeQuals & Qualifiers::Restrict) { 125 if (appendSpace) OS << ' '; 126 if (C99) { 127 OS << "restrict"; 128 } else { 129 OS << "__restrict"; 130 } 131 } 132 } 133 134 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) { 135 if (!HasEmptyPlaceHolder) 136 OS << ' '; 137 } 138 139 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) { 140 SplitQualType split = t.split(); 141 print(split.Ty, split.Quals, OS, PlaceHolder); 142 } 143 144 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS, 145 StringRef PlaceHolder) { 146 if (!T) { 147 OS << "NULL TYPE"; 148 return; 149 } 150 151 SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty()); 152 153 printBefore(T, Quals, OS); 154 OS << PlaceHolder; 155 printAfter(T, Quals, OS); 156 } 157 158 bool TypePrinter::canPrefixQualifiers(const Type *T, 159 bool &NeedARCStrongQualifier) { 160 // CanPrefixQualifiers - We prefer to print type qualifiers before the type, 161 // so that we get "const int" instead of "int const", but we can't do this if 162 // the type is complex. For example if the type is "int*", we *must* print 163 // "int * const", printing "const int *" is different. Only do this when the 164 // type expands to a simple string. 165 bool CanPrefixQualifiers = false; 166 NeedARCStrongQualifier = false; 167 Type::TypeClass TC = T->getTypeClass(); 168 if (const AutoType *AT = dyn_cast<AutoType>(T)) 169 TC = AT->desugar()->getTypeClass(); 170 if (const SubstTemplateTypeParmType *Subst 171 = dyn_cast<SubstTemplateTypeParmType>(T)) 172 TC = Subst->getReplacementType()->getTypeClass(); 173 174 switch (TC) { 175 case Type::Auto: 176 case Type::Builtin: 177 case Type::Complex: 178 case Type::UnresolvedUsing: 179 case Type::Typedef: 180 case Type::TypeOfExpr: 181 case Type::TypeOf: 182 case Type::Decltype: 183 case Type::UnaryTransform: 184 case Type::Record: 185 case Type::Enum: 186 case Type::Elaborated: 187 case Type::TemplateTypeParm: 188 case Type::SubstTemplateTypeParmPack: 189 case Type::TemplateSpecialization: 190 case Type::InjectedClassName: 191 case Type::DependentName: 192 case Type::DependentTemplateSpecialization: 193 case Type::ObjCObject: 194 case Type::ObjCInterface: 195 case Type::Atomic: 196 CanPrefixQualifiers = true; 197 break; 198 199 case Type::ObjCObjectPointer: 200 CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() || 201 T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType(); 202 break; 203 204 case Type::ConstantArray: 205 case Type::IncompleteArray: 206 case Type::VariableArray: 207 case Type::DependentSizedArray: 208 NeedARCStrongQualifier = true; 209 // Fall through 210 211 case Type::Adjusted: 212 case Type::Decayed: 213 case Type::Pointer: 214 case Type::BlockPointer: 215 case Type::LValueReference: 216 case Type::RValueReference: 217 case Type::MemberPointer: 218 case Type::DependentSizedExtVector: 219 case Type::Vector: 220 case Type::ExtVector: 221 case Type::FunctionProto: 222 case Type::FunctionNoProto: 223 case Type::Paren: 224 case Type::Attributed: 225 case Type::PackExpansion: 226 case Type::SubstTemplateTypeParm: 227 CanPrefixQualifiers = false; 228 break; 229 } 230 231 return CanPrefixQualifiers; 232 } 233 234 void TypePrinter::printBefore(QualType T, raw_ostream &OS) { 235 SplitQualType Split = T.split(); 236 237 // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2 238 // at this level. 239 Qualifiers Quals = Split.Quals; 240 if (const SubstTemplateTypeParmType *Subst = 241 dyn_cast<SubstTemplateTypeParmType>(Split.Ty)) 242 Quals -= QualType(Subst, 0).getQualifiers(); 243 244 printBefore(Split.Ty, Quals, OS); 245 } 246 247 /// \brief Prints the part of the type string before an identifier, e.g. for 248 /// "int foo[10]" it prints "int ". 249 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) { 250 if (Policy.SuppressSpecifiers && T->isSpecifierType()) 251 return; 252 253 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder); 254 255 // Print qualifiers as appropriate. 256 257 bool CanPrefixQualifiers = false; 258 bool NeedARCStrongQualifier = false; 259 CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier); 260 261 if (CanPrefixQualifiers && !Quals.empty()) { 262 if (NeedARCStrongQualifier) { 263 IncludeStrongLifetimeRAII Strong(Policy); 264 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true); 265 } else { 266 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true); 267 } 268 } 269 270 bool hasAfterQuals = false; 271 if (!CanPrefixQualifiers && !Quals.empty()) { 272 hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy); 273 if (hasAfterQuals) 274 HasEmptyPlaceHolder = false; 275 } 276 277 switch (T->getTypeClass()) { 278 #define ABSTRACT_TYPE(CLASS, PARENT) 279 #define TYPE(CLASS, PARENT) case Type::CLASS: \ 280 print##CLASS##Before(cast<CLASS##Type>(T), OS); \ 281 break; 282 #include "clang/AST/TypeNodes.def" 283 } 284 285 if (hasAfterQuals) { 286 if (NeedARCStrongQualifier) { 287 IncludeStrongLifetimeRAII Strong(Policy); 288 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get()); 289 } else { 290 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get()); 291 } 292 } 293 } 294 295 void TypePrinter::printAfter(QualType t, raw_ostream &OS) { 296 SplitQualType split = t.split(); 297 printAfter(split.Ty, split.Quals, OS); 298 } 299 300 /// \brief Prints the part of the type string after an identifier, e.g. for 301 /// "int foo[10]" it prints "[10]". 302 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) { 303 switch (T->getTypeClass()) { 304 #define ABSTRACT_TYPE(CLASS, PARENT) 305 #define TYPE(CLASS, PARENT) case Type::CLASS: \ 306 print##CLASS##After(cast<CLASS##Type>(T), OS); \ 307 break; 308 #include "clang/AST/TypeNodes.def" 309 } 310 } 311 312 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) { 313 OS << T->getName(Policy); 314 spaceBeforePlaceHolder(OS); 315 } 316 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) { } 317 318 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) { 319 OS << "_Complex "; 320 printBefore(T->getElementType(), OS); 321 } 322 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) { 323 printAfter(T->getElementType(), OS); 324 } 325 326 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) { 327 IncludeStrongLifetimeRAII Strong(Policy); 328 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 329 printBefore(T->getPointeeType(), OS); 330 // Handle things like 'int (*A)[4];' correctly. 331 // FIXME: this should include vectors, but vectors use attributes I guess. 332 if (isa<ArrayType>(T->getPointeeType())) 333 OS << '('; 334 OS << '*'; 335 } 336 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) { 337 IncludeStrongLifetimeRAII Strong(Policy); 338 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 339 // Handle things like 'int (*A)[4];' correctly. 340 // FIXME: this should include vectors, but vectors use attributes I guess. 341 if (isa<ArrayType>(T->getPointeeType())) 342 OS << ')'; 343 printAfter(T->getPointeeType(), OS); 344 } 345 346 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T, 347 raw_ostream &OS) { 348 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 349 printBefore(T->getPointeeType(), OS); 350 OS << '^'; 351 } 352 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T, 353 raw_ostream &OS) { 354 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 355 printAfter(T->getPointeeType(), OS); 356 } 357 358 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T, 359 raw_ostream &OS) { 360 IncludeStrongLifetimeRAII Strong(Policy); 361 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 362 printBefore(T->getPointeeTypeAsWritten(), OS); 363 // Handle things like 'int (&A)[4];' correctly. 364 // FIXME: this should include vectors, but vectors use attributes I guess. 365 if (isa<ArrayType>(T->getPointeeTypeAsWritten())) 366 OS << '('; 367 OS << '&'; 368 } 369 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T, 370 raw_ostream &OS) { 371 IncludeStrongLifetimeRAII Strong(Policy); 372 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 373 // Handle things like 'int (&A)[4];' correctly. 374 // FIXME: this should include vectors, but vectors use attributes I guess. 375 if (isa<ArrayType>(T->getPointeeTypeAsWritten())) 376 OS << ')'; 377 printAfter(T->getPointeeTypeAsWritten(), OS); 378 } 379 380 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T, 381 raw_ostream &OS) { 382 IncludeStrongLifetimeRAII Strong(Policy); 383 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 384 printBefore(T->getPointeeTypeAsWritten(), OS); 385 // Handle things like 'int (&&A)[4];' correctly. 386 // FIXME: this should include vectors, but vectors use attributes I guess. 387 if (isa<ArrayType>(T->getPointeeTypeAsWritten())) 388 OS << '('; 389 OS << "&&"; 390 } 391 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T, 392 raw_ostream &OS) { 393 IncludeStrongLifetimeRAII Strong(Policy); 394 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 395 // Handle things like 'int (&&A)[4];' correctly. 396 // FIXME: this should include vectors, but vectors use attributes I guess. 397 if (isa<ArrayType>(T->getPointeeTypeAsWritten())) 398 OS << ')'; 399 printAfter(T->getPointeeTypeAsWritten(), OS); 400 } 401 402 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T, 403 raw_ostream &OS) { 404 IncludeStrongLifetimeRAII Strong(Policy); 405 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 406 printBefore(T->getPointeeType(), OS); 407 // Handle things like 'int (Cls::*A)[4];' correctly. 408 // FIXME: this should include vectors, but vectors use attributes I guess. 409 if (isa<ArrayType>(T->getPointeeType())) 410 OS << '('; 411 412 PrintingPolicy InnerPolicy(Policy); 413 InnerPolicy.SuppressTag = false; 414 TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef()); 415 416 OS << "::*"; 417 } 418 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T, 419 raw_ostream &OS) { 420 IncludeStrongLifetimeRAII Strong(Policy); 421 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 422 // Handle things like 'int (Cls::*A)[4];' correctly. 423 // FIXME: this should include vectors, but vectors use attributes I guess. 424 if (isa<ArrayType>(T->getPointeeType())) 425 OS << ')'; 426 printAfter(T->getPointeeType(), OS); 427 } 428 429 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T, 430 raw_ostream &OS) { 431 IncludeStrongLifetimeRAII Strong(Policy); 432 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 433 printBefore(T->getElementType(), OS); 434 } 435 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T, 436 raw_ostream &OS) { 437 OS << '['; 438 if (T->getIndexTypeQualifiers().hasQualifiers()) { 439 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.LangOpts.C99); 440 OS << ' '; 441 } 442 443 if (T->getSizeModifier() == ArrayType::Static) 444 OS << "static "; 445 446 OS << T->getSize().getZExtValue() << ']'; 447 printAfter(T->getElementType(), OS); 448 } 449 450 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T, 451 raw_ostream &OS) { 452 IncludeStrongLifetimeRAII Strong(Policy); 453 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 454 printBefore(T->getElementType(), OS); 455 } 456 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T, 457 raw_ostream &OS) { 458 OS << "[]"; 459 printAfter(T->getElementType(), OS); 460 } 461 462 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T, 463 raw_ostream &OS) { 464 IncludeStrongLifetimeRAII Strong(Policy); 465 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 466 printBefore(T->getElementType(), OS); 467 } 468 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T, 469 raw_ostream &OS) { 470 OS << '['; 471 if (T->getIndexTypeQualifiers().hasQualifiers()) { 472 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.LangOpts.C99); 473 OS << ' '; 474 } 475 476 if (T->getSizeModifier() == VariableArrayType::Static) 477 OS << "static "; 478 else if (T->getSizeModifier() == VariableArrayType::Star) 479 OS << '*'; 480 481 if (T->getSizeExpr()) 482 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 483 OS << ']'; 484 485 printAfter(T->getElementType(), OS); 486 } 487 488 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) { 489 // Print the adjusted representation, otherwise the adjustment will be 490 // invisible. 491 printBefore(T->getAdjustedType(), OS); 492 } 493 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) { 494 printAfter(T->getAdjustedType(), OS); 495 } 496 497 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) { 498 // Print as though it's a pointer. 499 printAdjustedBefore(T, OS); 500 } 501 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) { 502 printAdjustedAfter(T, OS); 503 } 504 505 void TypePrinter::printDependentSizedArrayBefore( 506 const DependentSizedArrayType *T, 507 raw_ostream &OS) { 508 IncludeStrongLifetimeRAII Strong(Policy); 509 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 510 printBefore(T->getElementType(), OS); 511 } 512 void TypePrinter::printDependentSizedArrayAfter( 513 const DependentSizedArrayType *T, 514 raw_ostream &OS) { 515 OS << '['; 516 if (T->getSizeExpr()) 517 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 518 OS << ']'; 519 printAfter(T->getElementType(), OS); 520 } 521 522 void TypePrinter::printDependentSizedExtVectorBefore( 523 const DependentSizedExtVectorType *T, 524 raw_ostream &OS) { 525 printBefore(T->getElementType(), OS); 526 } 527 void TypePrinter::printDependentSizedExtVectorAfter( 528 const DependentSizedExtVectorType *T, 529 raw_ostream &OS) { 530 OS << " __attribute__((ext_vector_type("; 531 if (T->getSizeExpr()) 532 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 533 OS << ")))"; 534 printAfter(T->getElementType(), OS); 535 } 536 537 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) { 538 switch (T->getVectorKind()) { 539 case VectorType::AltiVecPixel: 540 OS << "__vector __pixel "; 541 break; 542 case VectorType::AltiVecBool: 543 OS << "__vector __bool "; 544 printBefore(T->getElementType(), OS); 545 break; 546 case VectorType::AltiVecVector: 547 OS << "__vector "; 548 printBefore(T->getElementType(), OS); 549 break; 550 case VectorType::NeonVector: 551 OS << "__attribute__((neon_vector_type(" 552 << T->getNumElements() << "))) "; 553 printBefore(T->getElementType(), OS); 554 break; 555 case VectorType::NeonPolyVector: 556 OS << "__attribute__((neon_polyvector_type(" << 557 T->getNumElements() << "))) "; 558 printBefore(T->getElementType(), OS); 559 break; 560 case VectorType::GenericVector: { 561 // FIXME: We prefer to print the size directly here, but have no way 562 // to get the size of the type. 563 OS << "__attribute__((__vector_size__(" 564 << T->getNumElements() 565 << " * sizeof("; 566 print(T->getElementType(), OS, StringRef()); 567 OS << ")))) "; 568 printBefore(T->getElementType(), OS); 569 break; 570 } 571 } 572 } 573 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) { 574 printAfter(T->getElementType(), OS); 575 } 576 577 void TypePrinter::printExtVectorBefore(const ExtVectorType *T, 578 raw_ostream &OS) { 579 printBefore(T->getElementType(), OS); 580 } 581 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) { 582 printAfter(T->getElementType(), OS); 583 OS << " __attribute__((ext_vector_type("; 584 OS << T->getNumElements(); 585 OS << ")))"; 586 } 587 588 void 589 FunctionProtoType::printExceptionSpecification(raw_ostream &OS, 590 const PrintingPolicy &Policy) 591 const { 592 593 if (hasDynamicExceptionSpec()) { 594 OS << " throw("; 595 if (getExceptionSpecType() == EST_MSAny) 596 OS << "..."; 597 else 598 for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) { 599 if (I) 600 OS << ", "; 601 602 OS << getExceptionType(I).stream(Policy); 603 } 604 OS << ')'; 605 } else if (isNoexceptExceptionSpec(getExceptionSpecType())) { 606 OS << " noexcept"; 607 if (getExceptionSpecType() == EST_ComputedNoexcept) { 608 OS << '('; 609 if (getNoexceptExpr()) 610 getNoexceptExpr()->printPretty(OS, nullptr, Policy); 611 OS << ')'; 612 } 613 } 614 } 615 616 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T, 617 raw_ostream &OS) { 618 if (T->hasTrailingReturn()) { 619 OS << "auto "; 620 if (!HasEmptyPlaceHolder) 621 OS << '('; 622 } else { 623 // If needed for precedence reasons, wrap the inner part in grouping parens. 624 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false); 625 printBefore(T->getReturnType(), OS); 626 if (!PrevPHIsEmpty.get()) 627 OS << '('; 628 } 629 } 630 631 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T, 632 raw_ostream &OS) { 633 // If needed for precedence reasons, wrap the inner part in grouping parens. 634 if (!HasEmptyPlaceHolder) 635 OS << ')'; 636 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 637 638 OS << '('; 639 { 640 ParamPolicyRAII ParamPolicy(Policy); 641 for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) { 642 if (i) OS << ", "; 643 print(T->getParamType(i), OS, StringRef()); 644 } 645 } 646 647 if (T->isVariadic()) { 648 if (T->getNumParams()) 649 OS << ", "; 650 OS << "..."; 651 } else if (T->getNumParams() == 0 && !Policy.LangOpts.CPlusPlus) { 652 // Do not emit int() if we have a proto, emit 'int(void)'. 653 OS << "void"; 654 } 655 656 OS << ')'; 657 658 FunctionType::ExtInfo Info = T->getExtInfo(); 659 660 if (!InsideCCAttribute) { 661 switch (Info.getCC()) { 662 case CC_C: 663 // The C calling convention is the default on the vast majority of platforms 664 // we support. If the user wrote it explicitly, it will usually be printed 665 // while traversing the AttributedType. If the type has been desugared, let 666 // the canonical spelling be the implicit calling convention. 667 // FIXME: It would be better to be explicit in certain contexts, such as a 668 // cdecl function typedef used to declare a member function with the 669 // Microsoft C++ ABI. 670 break; 671 case CC_X86StdCall: 672 OS << " __attribute__((stdcall))"; 673 break; 674 case CC_X86FastCall: 675 OS << " __attribute__((fastcall))"; 676 break; 677 case CC_X86ThisCall: 678 OS << " __attribute__((thiscall))"; 679 break; 680 case CC_X86VectorCall: 681 OS << " __attribute__((vectorcall))"; 682 break; 683 case CC_X86Pascal: 684 OS << " __attribute__((pascal))"; 685 break; 686 case CC_AAPCS: 687 OS << " __attribute__((pcs(\"aapcs\")))"; 688 break; 689 case CC_AAPCS_VFP: 690 OS << " __attribute__((pcs(\"aapcs-vfp\")))"; 691 break; 692 case CC_IntelOclBicc: 693 OS << " __attribute__((intel_ocl_bicc))"; 694 break; 695 case CC_X86_64Win64: 696 OS << " __attribute__((ms_abi))"; 697 break; 698 case CC_X86_64SysV: 699 OS << " __attribute__((sysv_abi))"; 700 break; 701 case CC_SpirFunction: 702 case CC_SpirKernel: 703 // Do nothing. These CCs are not available as attributes. 704 break; 705 } 706 } 707 708 if (Info.getNoReturn()) 709 OS << " __attribute__((noreturn))"; 710 if (Info.getRegParm()) 711 OS << " __attribute__((regparm (" 712 << Info.getRegParm() << ")))"; 713 714 if (unsigned quals = T->getTypeQuals()) { 715 OS << ' '; 716 AppendTypeQualList(OS, quals, Policy.LangOpts.C99); 717 } 718 719 switch (T->getRefQualifier()) { 720 case RQ_None: 721 break; 722 723 case RQ_LValue: 724 OS << " &"; 725 break; 726 727 case RQ_RValue: 728 OS << " &&"; 729 break; 730 } 731 T->printExceptionSpecification(OS, Policy); 732 733 if (T->hasTrailingReturn()) { 734 OS << " -> "; 735 print(T->getReturnType(), OS, StringRef()); 736 } else 737 printAfter(T->getReturnType(), OS); 738 } 739 740 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T, 741 raw_ostream &OS) { 742 // If needed for precedence reasons, wrap the inner part in grouping parens. 743 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false); 744 printBefore(T->getReturnType(), OS); 745 if (!PrevPHIsEmpty.get()) 746 OS << '('; 747 } 748 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T, 749 raw_ostream &OS) { 750 // If needed for precedence reasons, wrap the inner part in grouping parens. 751 if (!HasEmptyPlaceHolder) 752 OS << ')'; 753 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 754 755 OS << "()"; 756 if (T->getNoReturnAttr()) 757 OS << " __attribute__((noreturn))"; 758 printAfter(T->getReturnType(), OS); 759 } 760 761 void TypePrinter::printTypeSpec(const NamedDecl *D, raw_ostream &OS) { 762 IdentifierInfo *II = D->getIdentifier(); 763 OS << II->getName(); 764 spaceBeforePlaceHolder(OS); 765 } 766 767 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T, 768 raw_ostream &OS) { 769 printTypeSpec(T->getDecl(), OS); 770 } 771 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T, 772 raw_ostream &OS) { } 773 774 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) { 775 printTypeSpec(T->getDecl(), OS); 776 } 777 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) { } 778 779 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T, 780 raw_ostream &OS) { 781 OS << "typeof "; 782 if (T->getUnderlyingExpr()) 783 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy); 784 spaceBeforePlaceHolder(OS); 785 } 786 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T, 787 raw_ostream &OS) { } 788 789 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) { 790 OS << "typeof("; 791 print(T->getUnderlyingType(), OS, StringRef()); 792 OS << ')'; 793 spaceBeforePlaceHolder(OS); 794 } 795 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) { } 796 797 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) { 798 OS << "decltype("; 799 if (T->getUnderlyingExpr()) 800 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy); 801 OS << ')'; 802 spaceBeforePlaceHolder(OS); 803 } 804 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) { } 805 806 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T, 807 raw_ostream &OS) { 808 IncludeStrongLifetimeRAII Strong(Policy); 809 810 switch (T->getUTTKind()) { 811 case UnaryTransformType::EnumUnderlyingType: 812 OS << "__underlying_type("; 813 print(T->getBaseType(), OS, StringRef()); 814 OS << ')'; 815 spaceBeforePlaceHolder(OS); 816 return; 817 } 818 819 printBefore(T->getBaseType(), OS); 820 } 821 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T, 822 raw_ostream &OS) { 823 IncludeStrongLifetimeRAII Strong(Policy); 824 825 switch (T->getUTTKind()) { 826 case UnaryTransformType::EnumUnderlyingType: 827 return; 828 } 829 830 printAfter(T->getBaseType(), OS); 831 } 832 833 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) { 834 // If the type has been deduced, do not print 'auto'. 835 if (!T->getDeducedType().isNull()) { 836 printBefore(T->getDeducedType(), OS); 837 } else { 838 switch (T->getKeyword()) { 839 case AutoTypeKeyword::Auto: OS << "auto"; break; 840 case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break; 841 case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break; 842 } 843 spaceBeforePlaceHolder(OS); 844 } 845 } 846 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) { 847 // If the type has been deduced, do not print 'auto'. 848 if (!T->getDeducedType().isNull()) 849 printAfter(T->getDeducedType(), OS); 850 } 851 852 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) { 853 IncludeStrongLifetimeRAII Strong(Policy); 854 855 OS << "_Atomic("; 856 print(T->getValueType(), OS, StringRef()); 857 OS << ')'; 858 spaceBeforePlaceHolder(OS); 859 } 860 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) { } 861 862 /// Appends the given scope to the end of a string. 863 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) { 864 if (DC->isTranslationUnit()) return; 865 if (DC->isFunctionOrMethod()) return; 866 AppendScope(DC->getParent(), OS); 867 868 if (NamespaceDecl *NS = dyn_cast<NamespaceDecl>(DC)) { 869 if (Policy.SuppressUnwrittenScope && 870 (NS->isAnonymousNamespace() || NS->isInline())) 871 return; 872 if (NS->getIdentifier()) 873 OS << NS->getName() << "::"; 874 else 875 OS << "(anonymous namespace)::"; 876 } else if (ClassTemplateSpecializationDecl *Spec 877 = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 878 IncludeStrongLifetimeRAII Strong(Policy); 879 OS << Spec->getIdentifier()->getName(); 880 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 881 TemplateSpecializationType::PrintTemplateArgumentList(OS, 882 TemplateArgs.data(), 883 TemplateArgs.size(), 884 Policy); 885 OS << "::"; 886 } else if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) { 887 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl()) 888 OS << Typedef->getIdentifier()->getName() << "::"; 889 else if (Tag->getIdentifier()) 890 OS << Tag->getIdentifier()->getName() << "::"; 891 else 892 return; 893 } 894 } 895 896 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) { 897 if (Policy.SuppressTag) 898 return; 899 900 bool HasKindDecoration = false; 901 902 // bool SuppressTagKeyword 903 // = Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword; 904 905 // We don't print tags unless this is an elaborated type. 906 // In C, we just assume every RecordType is an elaborated type. 907 if (!(Policy.LangOpts.CPlusPlus || Policy.SuppressTagKeyword || 908 D->getTypedefNameForAnonDecl())) { 909 HasKindDecoration = true; 910 OS << D->getKindName(); 911 OS << ' '; 912 } 913 914 // Compute the full nested-name-specifier for this type. 915 // In C, this will always be empty except when the type 916 // being printed is anonymous within other Record. 917 if (!Policy.SuppressScope) 918 AppendScope(D->getDeclContext(), OS); 919 920 if (const IdentifierInfo *II = D->getIdentifier()) 921 OS << II->getName(); 922 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) { 923 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 924 OS << Typedef->getIdentifier()->getName(); 925 } else { 926 // Make an unambiguous representation for anonymous types, e.g. 927 // (anonymous enum at /usr/include/string.h:120:9) 928 OS << (Policy.MSVCFormatting ? '`' : '('); 929 930 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) { 931 OS << "lambda"; 932 HasKindDecoration = true; 933 } else { 934 OS << "anonymous"; 935 } 936 937 if (Policy.AnonymousTagLocations) { 938 // Suppress the redundant tag keyword if we just printed one. 939 // We don't have to worry about ElaboratedTypes here because you can't 940 // refer to an anonymous type with one. 941 if (!HasKindDecoration) 942 OS << " " << D->getKindName(); 943 944 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc( 945 D->getLocation()); 946 if (PLoc.isValid()) { 947 OS << " at " << PLoc.getFilename() 948 << ':' << PLoc.getLine() 949 << ':' << PLoc.getColumn(); 950 } 951 } 952 953 OS << (Policy.MSVCFormatting ? '\'' : ')'); 954 } 955 956 // If this is a class template specialization, print the template 957 // arguments. 958 if (ClassTemplateSpecializationDecl *Spec 959 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 960 const TemplateArgument *Args; 961 unsigned NumArgs; 962 if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) { 963 const TemplateSpecializationType *TST = 964 cast<TemplateSpecializationType>(TAW->getType()); 965 Args = TST->getArgs(); 966 NumArgs = TST->getNumArgs(); 967 } else { 968 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 969 Args = TemplateArgs.data(); 970 NumArgs = TemplateArgs.size(); 971 } 972 IncludeStrongLifetimeRAII Strong(Policy); 973 TemplateSpecializationType::PrintTemplateArgumentList(OS, 974 Args, NumArgs, 975 Policy); 976 } 977 978 spaceBeforePlaceHolder(OS); 979 } 980 981 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) { 982 printTag(T->getDecl(), OS); 983 } 984 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) { } 985 986 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) { 987 printTag(T->getDecl(), OS); 988 } 989 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) { } 990 991 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T, 992 raw_ostream &OS) { 993 if (IdentifierInfo *Id = T->getIdentifier()) 994 OS << Id->getName(); 995 else 996 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex(); 997 spaceBeforePlaceHolder(OS); 998 } 999 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T, 1000 raw_ostream &OS) { } 1001 1002 void TypePrinter::printSubstTemplateTypeParmBefore( 1003 const SubstTemplateTypeParmType *T, 1004 raw_ostream &OS) { 1005 IncludeStrongLifetimeRAII Strong(Policy); 1006 printBefore(T->getReplacementType(), OS); 1007 } 1008 void TypePrinter::printSubstTemplateTypeParmAfter( 1009 const SubstTemplateTypeParmType *T, 1010 raw_ostream &OS) { 1011 IncludeStrongLifetimeRAII Strong(Policy); 1012 printAfter(T->getReplacementType(), OS); 1013 } 1014 1015 void TypePrinter::printSubstTemplateTypeParmPackBefore( 1016 const SubstTemplateTypeParmPackType *T, 1017 raw_ostream &OS) { 1018 IncludeStrongLifetimeRAII Strong(Policy); 1019 printTemplateTypeParmBefore(T->getReplacedParameter(), OS); 1020 } 1021 void TypePrinter::printSubstTemplateTypeParmPackAfter( 1022 const SubstTemplateTypeParmPackType *T, 1023 raw_ostream &OS) { 1024 IncludeStrongLifetimeRAII Strong(Policy); 1025 printTemplateTypeParmAfter(T->getReplacedParameter(), OS); 1026 } 1027 1028 void TypePrinter::printTemplateSpecializationBefore( 1029 const TemplateSpecializationType *T, 1030 raw_ostream &OS) { 1031 IncludeStrongLifetimeRAII Strong(Policy); 1032 T->getTemplateName().print(OS, Policy); 1033 1034 TemplateSpecializationType::PrintTemplateArgumentList(OS, 1035 T->getArgs(), 1036 T->getNumArgs(), 1037 Policy); 1038 spaceBeforePlaceHolder(OS); 1039 } 1040 void TypePrinter::printTemplateSpecializationAfter( 1041 const TemplateSpecializationType *T, 1042 raw_ostream &OS) { } 1043 1044 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T, 1045 raw_ostream &OS) { 1046 printTemplateSpecializationBefore(T->getInjectedTST(), OS); 1047 } 1048 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T, 1049 raw_ostream &OS) { } 1050 1051 void TypePrinter::printElaboratedBefore(const ElaboratedType *T, 1052 raw_ostream &OS) { 1053 if (Policy.SuppressTag && isa<TagType>(T->getNamedType())) 1054 return; 1055 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1056 if (T->getKeyword() != ETK_None) 1057 OS << " "; 1058 NestedNameSpecifier* Qualifier = T->getQualifier(); 1059 if (Qualifier) 1060 Qualifier->print(OS, Policy); 1061 1062 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1063 printBefore(T->getNamedType(), OS); 1064 } 1065 void TypePrinter::printElaboratedAfter(const ElaboratedType *T, 1066 raw_ostream &OS) { 1067 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1068 printAfter(T->getNamedType(), OS); 1069 } 1070 1071 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) { 1072 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1073 printBefore(T->getInnerType(), OS); 1074 OS << '('; 1075 } else 1076 printBefore(T->getInnerType(), OS); 1077 } 1078 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) { 1079 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1080 OS << ')'; 1081 printAfter(T->getInnerType(), OS); 1082 } else 1083 printAfter(T->getInnerType(), OS); 1084 } 1085 1086 void TypePrinter::printDependentNameBefore(const DependentNameType *T, 1087 raw_ostream &OS) { 1088 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1089 if (T->getKeyword() != ETK_None) 1090 OS << " "; 1091 1092 T->getQualifier()->print(OS, Policy); 1093 1094 OS << T->getIdentifier()->getName(); 1095 spaceBeforePlaceHolder(OS); 1096 } 1097 void TypePrinter::printDependentNameAfter(const DependentNameType *T, 1098 raw_ostream &OS) { } 1099 1100 void TypePrinter::printDependentTemplateSpecializationBefore( 1101 const DependentTemplateSpecializationType *T, raw_ostream &OS) { 1102 IncludeStrongLifetimeRAII Strong(Policy); 1103 1104 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1105 if (T->getKeyword() != ETK_None) 1106 OS << " "; 1107 1108 if (T->getQualifier()) 1109 T->getQualifier()->print(OS, Policy); 1110 OS << T->getIdentifier()->getName(); 1111 TemplateSpecializationType::PrintTemplateArgumentList(OS, 1112 T->getArgs(), 1113 T->getNumArgs(), 1114 Policy); 1115 spaceBeforePlaceHolder(OS); 1116 } 1117 void TypePrinter::printDependentTemplateSpecializationAfter( 1118 const DependentTemplateSpecializationType *T, raw_ostream &OS) { } 1119 1120 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T, 1121 raw_ostream &OS) { 1122 printBefore(T->getPattern(), OS); 1123 } 1124 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T, 1125 raw_ostream &OS) { 1126 printAfter(T->getPattern(), OS); 1127 OS << "..."; 1128 } 1129 1130 void TypePrinter::printAttributedBefore(const AttributedType *T, 1131 raw_ostream &OS) { 1132 // Prefer the macro forms of the GC and ownership qualifiers. 1133 if (T->getAttrKind() == AttributedType::attr_objc_gc || 1134 T->getAttrKind() == AttributedType::attr_objc_ownership) 1135 return printBefore(T->getEquivalentType(), OS); 1136 1137 if (T->getAttrKind() == AttributedType::attr_objc_kindof) 1138 OS << "__kindof "; 1139 1140 printBefore(T->getModifiedType(), OS); 1141 1142 if (T->isMSTypeSpec()) { 1143 switch (T->getAttrKind()) { 1144 default: return; 1145 case AttributedType::attr_ptr32: OS << " __ptr32"; break; 1146 case AttributedType::attr_ptr64: OS << " __ptr64"; break; 1147 case AttributedType::attr_sptr: OS << " __sptr"; break; 1148 case AttributedType::attr_uptr: OS << " __uptr"; break; 1149 } 1150 spaceBeforePlaceHolder(OS); 1151 } 1152 1153 // Print nullability type specifiers. 1154 if (T->getAttrKind() == AttributedType::attr_nonnull || 1155 T->getAttrKind() == AttributedType::attr_nullable || 1156 T->getAttrKind() == AttributedType::attr_null_unspecified) { 1157 if (T->getAttrKind() == AttributedType::attr_nonnull) 1158 OS << " _Nonnull"; 1159 else if (T->getAttrKind() == AttributedType::attr_nullable) 1160 OS << " _Nullable"; 1161 else if (T->getAttrKind() == AttributedType::attr_null_unspecified) 1162 OS << " _Null_unspecified"; 1163 else 1164 llvm_unreachable("unhandled nullability"); 1165 spaceBeforePlaceHolder(OS); 1166 } 1167 } 1168 1169 void TypePrinter::printAttributedAfter(const AttributedType *T, 1170 raw_ostream &OS) { 1171 // Prefer the macro forms of the GC and ownership qualifiers. 1172 if (T->getAttrKind() == AttributedType::attr_objc_gc || 1173 T->getAttrKind() == AttributedType::attr_objc_ownership) 1174 return printAfter(T->getEquivalentType(), OS); 1175 1176 if (T->getAttrKind() == AttributedType::attr_objc_kindof) 1177 return; 1178 1179 // TODO: not all attributes are GCC-style attributes. 1180 if (T->isMSTypeSpec()) 1181 return; 1182 1183 // Nothing to print after. 1184 if (T->getAttrKind() == AttributedType::attr_nonnull || 1185 T->getAttrKind() == AttributedType::attr_nullable || 1186 T->getAttrKind() == AttributedType::attr_null_unspecified) 1187 return printAfter(T->getModifiedType(), OS); 1188 1189 // If this is a calling convention attribute, don't print the implicit CC from 1190 // the modified type. 1191 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv()); 1192 1193 printAfter(T->getModifiedType(), OS); 1194 1195 // Don't print the inert __unsafe_unretained attribute at all. 1196 if (T->getAttrKind() == AttributedType::attr_objc_inert_unsafe_unretained) 1197 return; 1198 1199 // Print nullability type specifiers that occur after 1200 if (T->getAttrKind() == AttributedType::attr_nonnull || 1201 T->getAttrKind() == AttributedType::attr_nullable || 1202 T->getAttrKind() == AttributedType::attr_null_unspecified) { 1203 if (T->getAttrKind() == AttributedType::attr_nonnull) 1204 OS << " _Nonnull"; 1205 else if (T->getAttrKind() == AttributedType::attr_nullable) 1206 OS << " _Nullable"; 1207 else if (T->getAttrKind() == AttributedType::attr_null_unspecified) 1208 OS << " _Null_unspecified"; 1209 else 1210 llvm_unreachable("unhandled nullability"); 1211 1212 return; 1213 } 1214 1215 OS << " __attribute__(("; 1216 switch (T->getAttrKind()) { 1217 default: llvm_unreachable("This attribute should have been handled already"); 1218 case AttributedType::attr_address_space: 1219 OS << "address_space("; 1220 OS << T->getEquivalentType().getAddressSpace(); 1221 OS << ')'; 1222 break; 1223 1224 case AttributedType::attr_vector_size: { 1225 OS << "__vector_size__("; 1226 if (const VectorType *vector =T->getEquivalentType()->getAs<VectorType>()) { 1227 OS << vector->getNumElements(); 1228 OS << " * sizeof("; 1229 print(vector->getElementType(), OS, StringRef()); 1230 OS << ')'; 1231 } 1232 OS << ')'; 1233 break; 1234 } 1235 1236 case AttributedType::attr_neon_vector_type: 1237 case AttributedType::attr_neon_polyvector_type: { 1238 if (T->getAttrKind() == AttributedType::attr_neon_vector_type) 1239 OS << "neon_vector_type("; 1240 else 1241 OS << "neon_polyvector_type("; 1242 const VectorType *vector = T->getEquivalentType()->getAs<VectorType>(); 1243 OS << vector->getNumElements(); 1244 OS << ')'; 1245 break; 1246 } 1247 1248 case AttributedType::attr_regparm: { 1249 // FIXME: When Sema learns to form this AttributedType, avoid printing the 1250 // attribute again in printFunctionProtoAfter. 1251 OS << "regparm("; 1252 QualType t = T->getEquivalentType(); 1253 while (!t->isFunctionType()) 1254 t = t->getPointeeType(); 1255 OS << t->getAs<FunctionType>()->getRegParmType(); 1256 OS << ')'; 1257 break; 1258 } 1259 1260 case AttributedType::attr_objc_gc: { 1261 OS << "objc_gc("; 1262 1263 QualType tmp = T->getEquivalentType(); 1264 while (tmp.getObjCGCAttr() == Qualifiers::GCNone) { 1265 QualType next = tmp->getPointeeType(); 1266 if (next == tmp) break; 1267 tmp = next; 1268 } 1269 1270 if (tmp.isObjCGCWeak()) 1271 OS << "weak"; 1272 else 1273 OS << "strong"; 1274 OS << ')'; 1275 break; 1276 } 1277 1278 case AttributedType::attr_objc_ownership: 1279 OS << "objc_ownership("; 1280 switch (T->getEquivalentType().getObjCLifetime()) { 1281 case Qualifiers::OCL_None: llvm_unreachable("no ownership!"); 1282 case Qualifiers::OCL_ExplicitNone: OS << "none"; break; 1283 case Qualifiers::OCL_Strong: OS << "strong"; break; 1284 case Qualifiers::OCL_Weak: OS << "weak"; break; 1285 case Qualifiers::OCL_Autoreleasing: OS << "autoreleasing"; break; 1286 } 1287 OS << ')'; 1288 break; 1289 1290 // FIXME: When Sema learns to form this AttributedType, avoid printing the 1291 // attribute again in printFunctionProtoAfter. 1292 case AttributedType::attr_noreturn: OS << "noreturn"; break; 1293 1294 case AttributedType::attr_cdecl: OS << "cdecl"; break; 1295 case AttributedType::attr_fastcall: OS << "fastcall"; break; 1296 case AttributedType::attr_stdcall: OS << "stdcall"; break; 1297 case AttributedType::attr_thiscall: OS << "thiscall"; break; 1298 case AttributedType::attr_vectorcall: OS << "vectorcall"; break; 1299 case AttributedType::attr_pascal: OS << "pascal"; break; 1300 case AttributedType::attr_ms_abi: OS << "ms_abi"; break; 1301 case AttributedType::attr_sysv_abi: OS << "sysv_abi"; break; 1302 case AttributedType::attr_pcs: 1303 case AttributedType::attr_pcs_vfp: { 1304 OS << "pcs("; 1305 QualType t = T->getEquivalentType(); 1306 while (!t->isFunctionType()) 1307 t = t->getPointeeType(); 1308 OS << (t->getAs<FunctionType>()->getCallConv() == CC_AAPCS ? 1309 "\"aapcs\"" : "\"aapcs-vfp\""); 1310 OS << ')'; 1311 break; 1312 } 1313 case AttributedType::attr_inteloclbicc: OS << "inteloclbicc"; break; 1314 } 1315 OS << "))"; 1316 } 1317 1318 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T, 1319 raw_ostream &OS) { 1320 OS << T->getDecl()->getName(); 1321 spaceBeforePlaceHolder(OS); 1322 } 1323 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T, 1324 raw_ostream &OS) { } 1325 1326 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T, 1327 raw_ostream &OS) { 1328 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1329 !T->isKindOfTypeAsWritten()) 1330 return printBefore(T->getBaseType(), OS); 1331 1332 if (T->isKindOfTypeAsWritten()) 1333 OS << "__kindof "; 1334 1335 print(T->getBaseType(), OS, StringRef()); 1336 1337 if (T->isSpecializedAsWritten()) { 1338 bool isFirst = true; 1339 OS << '<'; 1340 for (auto typeArg : T->getTypeArgsAsWritten()) { 1341 if (isFirst) 1342 isFirst = false; 1343 else 1344 OS << ","; 1345 1346 print(typeArg, OS, StringRef()); 1347 } 1348 OS << '>'; 1349 } 1350 1351 if (!T->qual_empty()) { 1352 bool isFirst = true; 1353 OS << '<'; 1354 for (const auto *I : T->quals()) { 1355 if (isFirst) 1356 isFirst = false; 1357 else 1358 OS << ','; 1359 OS << I->getName(); 1360 } 1361 OS << '>'; 1362 } 1363 1364 spaceBeforePlaceHolder(OS); 1365 } 1366 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T, 1367 raw_ostream &OS) { 1368 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1369 !T->isKindOfTypeAsWritten()) 1370 return printAfter(T->getBaseType(), OS); 1371 } 1372 1373 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T, 1374 raw_ostream &OS) { 1375 printBefore(T->getPointeeType(), OS); 1376 1377 // If we need to print the pointer, print it now. 1378 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() && 1379 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) { 1380 if (HasEmptyPlaceHolder) 1381 OS << ' '; 1382 OS << '*'; 1383 } 1384 } 1385 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T, 1386 raw_ostream &OS) { } 1387 1388 void TemplateSpecializationType:: 1389 PrintTemplateArgumentList(raw_ostream &OS, 1390 const TemplateArgumentListInfo &Args, 1391 const PrintingPolicy &Policy) { 1392 return PrintTemplateArgumentList(OS, 1393 Args.getArgumentArray(), 1394 Args.size(), 1395 Policy); 1396 } 1397 1398 void 1399 TemplateSpecializationType::PrintTemplateArgumentList( 1400 raw_ostream &OS, 1401 const TemplateArgument *Args, 1402 unsigned NumArgs, 1403 const PrintingPolicy &Policy, 1404 bool SkipBrackets) { 1405 const char *Comma = Policy.MSVCFormatting ? "," : ", "; 1406 if (!SkipBrackets) 1407 OS << '<'; 1408 1409 bool needSpace = false; 1410 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1411 // Print the argument into a string. 1412 SmallString<128> Buf; 1413 llvm::raw_svector_ostream ArgOS(Buf); 1414 if (Args[Arg].getKind() == TemplateArgument::Pack) { 1415 if (Args[Arg].pack_size() && Arg > 0) 1416 OS << Comma; 1417 PrintTemplateArgumentList(ArgOS, 1418 Args[Arg].pack_begin(), 1419 Args[Arg].pack_size(), 1420 Policy, true); 1421 } else { 1422 if (Arg > 0) 1423 OS << Comma; 1424 Args[Arg].print(Policy, ArgOS); 1425 } 1426 StringRef ArgString = ArgOS.str(); 1427 1428 // If this is the first argument and its string representation 1429 // begins with the global scope specifier ('::foo'), add a space 1430 // to avoid printing the diagraph '<:'. 1431 if (!Arg && !ArgString.empty() && ArgString[0] == ':') 1432 OS << ' '; 1433 1434 OS << ArgString; 1435 1436 needSpace = (!ArgString.empty() && ArgString.back() == '>'); 1437 } 1438 1439 // If the last character of our string is '>', add another space to 1440 // keep the two '>''s separate tokens. We don't *have* to do this in 1441 // C++0x, but it's still good hygiene. 1442 if (needSpace) 1443 OS << ' '; 1444 1445 if (!SkipBrackets) 1446 OS << '>'; 1447 } 1448 1449 // Sadly, repeat all that with TemplateArgLoc. 1450 void TemplateSpecializationType:: 1451 PrintTemplateArgumentList(raw_ostream &OS, 1452 const TemplateArgumentLoc *Args, unsigned NumArgs, 1453 const PrintingPolicy &Policy) { 1454 OS << '<'; 1455 const char *Comma = Policy.MSVCFormatting ? "," : ", "; 1456 1457 bool needSpace = false; 1458 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1459 if (Arg > 0) 1460 OS << Comma; 1461 1462 // Print the argument into a string. 1463 SmallString<128> Buf; 1464 llvm::raw_svector_ostream ArgOS(Buf); 1465 if (Args[Arg].getArgument().getKind() == TemplateArgument::Pack) { 1466 PrintTemplateArgumentList(ArgOS, 1467 Args[Arg].getArgument().pack_begin(), 1468 Args[Arg].getArgument().pack_size(), 1469 Policy, true); 1470 } else { 1471 Args[Arg].getArgument().print(Policy, ArgOS); 1472 } 1473 StringRef ArgString = ArgOS.str(); 1474 1475 // If this is the first argument and its string representation 1476 // begins with the global scope specifier ('::foo'), add a space 1477 // to avoid printing the diagraph '<:'. 1478 if (!Arg && !ArgString.empty() && ArgString[0] == ':') 1479 OS << ' '; 1480 1481 OS << ArgString; 1482 1483 needSpace = (!ArgString.empty() && ArgString.back() == '>'); 1484 } 1485 1486 // If the last character of our string is '>', add another space to 1487 // keep the two '>''s separate tokens. We don't *have* to do this in 1488 // C++0x, but it's still good hygiene. 1489 if (needSpace) 1490 OS << ' '; 1491 1492 OS << '>'; 1493 } 1494 1495 std::string Qualifiers::getAsString() const { 1496 LangOptions LO; 1497 return getAsString(PrintingPolicy(LO)); 1498 } 1499 1500 // Appends qualifiers to the given string, separated by spaces. Will 1501 // prefix a space if the string is non-empty. Will not append a final 1502 // space. 1503 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const { 1504 SmallString<64> Buf; 1505 llvm::raw_svector_ostream StrOS(Buf); 1506 print(StrOS, Policy); 1507 return StrOS.str(); 1508 } 1509 1510 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const { 1511 if (getCVRQualifiers()) 1512 return false; 1513 1514 if (getAddressSpace()) 1515 return false; 1516 1517 if (getObjCGCAttr()) 1518 return false; 1519 1520 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) 1521 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)) 1522 return false; 1523 1524 return true; 1525 } 1526 1527 // Appends qualifiers to the given string, separated by spaces. Will 1528 // prefix a space if the string is non-empty. Will not append a final 1529 // space. 1530 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy, 1531 bool appendSpaceIfNonEmpty) const { 1532 bool addSpace = false; 1533 1534 unsigned quals = getCVRQualifiers(); 1535 if (quals) { 1536 AppendTypeQualList(OS, quals, Policy.LangOpts.C99); 1537 addSpace = true; 1538 } 1539 if (unsigned addrspace = getAddressSpace()) { 1540 if (addSpace) 1541 OS << ' '; 1542 addSpace = true; 1543 switch (addrspace) { 1544 case LangAS::opencl_global: 1545 OS << "__global"; 1546 break; 1547 case LangAS::opencl_local: 1548 OS << "__local"; 1549 break; 1550 case LangAS::opencl_constant: 1551 OS << "__constant"; 1552 break; 1553 case LangAS::opencl_generic: 1554 OS << "__generic"; 1555 break; 1556 default: 1557 OS << "__attribute__((address_space("; 1558 OS << addrspace; 1559 OS << ")))"; 1560 } 1561 } 1562 if (Qualifiers::GC gc = getObjCGCAttr()) { 1563 if (addSpace) 1564 OS << ' '; 1565 addSpace = true; 1566 if (gc == Qualifiers::Weak) 1567 OS << "__weak"; 1568 else 1569 OS << "__strong"; 1570 } 1571 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) { 1572 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){ 1573 if (addSpace) 1574 OS << ' '; 1575 addSpace = true; 1576 } 1577 1578 switch (lifetime) { 1579 case Qualifiers::OCL_None: llvm_unreachable("none but true"); 1580 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break; 1581 case Qualifiers::OCL_Strong: 1582 if (!Policy.SuppressStrongLifetime) 1583 OS << "__strong"; 1584 break; 1585 1586 case Qualifiers::OCL_Weak: OS << "__weak"; break; 1587 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break; 1588 } 1589 } 1590 1591 if (appendSpaceIfNonEmpty && addSpace) 1592 OS << ' '; 1593 } 1594 1595 std::string QualType::getAsString(const PrintingPolicy &Policy) const { 1596 std::string S; 1597 getAsStringInternal(S, Policy); 1598 return S; 1599 } 1600 1601 std::string QualType::getAsString(const Type *ty, Qualifiers qs) { 1602 std::string buffer; 1603 LangOptions options; 1604 getAsStringInternal(ty, qs, buffer, PrintingPolicy(options)); 1605 return buffer; 1606 } 1607 1608 void QualType::print(const Type *ty, Qualifiers qs, 1609 raw_ostream &OS, const PrintingPolicy &policy, 1610 const Twine &PlaceHolder) { 1611 SmallString<128> PHBuf; 1612 StringRef PH = PlaceHolder.toStringRef(PHBuf); 1613 1614 TypePrinter(policy).print(ty, qs, OS, PH); 1615 } 1616 1617 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs, 1618 std::string &buffer, 1619 const PrintingPolicy &policy) { 1620 SmallString<256> Buf; 1621 llvm::raw_svector_ostream StrOS(Buf); 1622 TypePrinter(policy).print(ty, qs, StrOS, buffer); 1623 std::string str = StrOS.str(); 1624 buffer.swap(str); 1625 } 1626