1 //===- TypePrinter.cpp - Pretty-Print Clang Types -------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This contains code to print types from Clang's type system. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/PrettyPrinter.h" 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/Decl.h" 16 #include "clang/AST/DeclBase.h" 17 #include "clang/AST/DeclCXX.h" 18 #include "clang/AST/DeclObjC.h" 19 #include "clang/AST/DeclTemplate.h" 20 #include "clang/AST/Expr.h" 21 #include "clang/AST/NestedNameSpecifier.h" 22 #include "clang/AST/TemplateBase.h" 23 #include "clang/AST/TemplateName.h" 24 #include "clang/AST/Type.h" 25 #include "clang/Basic/AddressSpaces.h" 26 #include "clang/Basic/ExceptionSpecificationType.h" 27 #include "clang/Basic/IdentifierTable.h" 28 #include "clang/Basic/LLVM.h" 29 #include "clang/Basic/LangOptions.h" 30 #include "clang/Basic/SourceLocation.h" 31 #include "clang/Basic/SourceManager.h" 32 #include "clang/Basic/Specifiers.h" 33 #include "llvm/ADT/ArrayRef.h" 34 #include "llvm/ADT/SmallString.h" 35 #include "llvm/ADT/StringRef.h" 36 #include "llvm/ADT/Twine.h" 37 #include "llvm/Support/Casting.h" 38 #include "llvm/Support/Compiler.h" 39 #include "llvm/Support/ErrorHandling.h" 40 #include "llvm/Support/SaveAndRestore.h" 41 #include "llvm/Support/raw_ostream.h" 42 #include <cassert> 43 #include <string> 44 45 using namespace clang; 46 47 namespace { 48 49 /// RAII object that enables printing of the ARC __strong lifetime 50 /// qualifier. 51 class IncludeStrongLifetimeRAII { 52 PrintingPolicy &Policy; 53 bool Old; 54 55 public: 56 explicit IncludeStrongLifetimeRAII(PrintingPolicy &Policy) 57 : Policy(Policy), Old(Policy.SuppressStrongLifetime) { 58 if (!Policy.SuppressLifetimeQualifiers) 59 Policy.SuppressStrongLifetime = false; 60 } 61 62 ~IncludeStrongLifetimeRAII() { 63 Policy.SuppressStrongLifetime = Old; 64 } 65 }; 66 67 class ParamPolicyRAII { 68 PrintingPolicy &Policy; 69 bool Old; 70 71 public: 72 explicit ParamPolicyRAII(PrintingPolicy &Policy) 73 : Policy(Policy), Old(Policy.SuppressSpecifiers) { 74 Policy.SuppressSpecifiers = false; 75 } 76 77 ~ParamPolicyRAII() { 78 Policy.SuppressSpecifiers = Old; 79 } 80 }; 81 82 class ElaboratedTypePolicyRAII { 83 PrintingPolicy &Policy; 84 bool SuppressTagKeyword; 85 bool SuppressScope; 86 87 public: 88 explicit ElaboratedTypePolicyRAII(PrintingPolicy &Policy) : Policy(Policy) { 89 SuppressTagKeyword = Policy.SuppressTagKeyword; 90 SuppressScope = Policy.SuppressScope; 91 Policy.SuppressTagKeyword = true; 92 Policy.SuppressScope = true; 93 } 94 95 ~ElaboratedTypePolicyRAII() { 96 Policy.SuppressTagKeyword = SuppressTagKeyword; 97 Policy.SuppressScope = SuppressScope; 98 } 99 }; 100 101 class TypePrinter { 102 PrintingPolicy Policy; 103 unsigned Indentation; 104 bool HasEmptyPlaceHolder = false; 105 bool InsideCCAttribute = false; 106 107 public: 108 explicit TypePrinter(const PrintingPolicy &Policy, unsigned Indentation = 0) 109 : Policy(Policy), Indentation(Indentation) {} 110 111 void print(const Type *ty, Qualifiers qs, raw_ostream &OS, 112 StringRef PlaceHolder); 113 void print(QualType T, raw_ostream &OS, StringRef PlaceHolder); 114 115 static bool canPrefixQualifiers(const Type *T, bool &NeedARCStrongQualifier); 116 void spaceBeforePlaceHolder(raw_ostream &OS); 117 void printTypeSpec(NamedDecl *D, raw_ostream &OS); 118 119 void printBefore(QualType T, raw_ostream &OS); 120 void printAfter(QualType T, raw_ostream &OS); 121 void AppendScope(DeclContext *DC, raw_ostream &OS); 122 void printTag(TagDecl *T, raw_ostream &OS); 123 void printFunctionAfter(const FunctionType::ExtInfo &Info, raw_ostream &OS); 124 #define ABSTRACT_TYPE(CLASS, PARENT) 125 #define TYPE(CLASS, PARENT) \ 126 void print##CLASS##Before(const CLASS##Type *T, raw_ostream &OS); \ 127 void print##CLASS##After(const CLASS##Type *T, raw_ostream &OS); 128 #include "clang/AST/TypeNodes.inc" 129 130 private: 131 void printBefore(const Type *ty, Qualifiers qs, raw_ostream &OS); 132 void printAfter(const Type *ty, Qualifiers qs, raw_ostream &OS); 133 }; 134 135 } // namespace 136 137 static void AppendTypeQualList(raw_ostream &OS, unsigned TypeQuals, 138 bool HasRestrictKeyword) { 139 bool appendSpace = false; 140 if (TypeQuals & Qualifiers::Const) { 141 OS << "const"; 142 appendSpace = true; 143 } 144 if (TypeQuals & Qualifiers::Volatile) { 145 if (appendSpace) OS << ' '; 146 OS << "volatile"; 147 appendSpace = true; 148 } 149 if (TypeQuals & Qualifiers::Restrict) { 150 if (appendSpace) OS << ' '; 151 if (HasRestrictKeyword) { 152 OS << "restrict"; 153 } else { 154 OS << "__restrict"; 155 } 156 } 157 } 158 159 void TypePrinter::spaceBeforePlaceHolder(raw_ostream &OS) { 160 if (!HasEmptyPlaceHolder) 161 OS << ' '; 162 } 163 164 static SplitQualType splitAccordingToPolicy(QualType QT, 165 const PrintingPolicy &Policy) { 166 if (Policy.PrintCanonicalTypes) 167 QT = QT.getCanonicalType(); 168 return QT.split(); 169 } 170 171 void TypePrinter::print(QualType t, raw_ostream &OS, StringRef PlaceHolder) { 172 SplitQualType split = splitAccordingToPolicy(t, Policy); 173 print(split.Ty, split.Quals, OS, PlaceHolder); 174 } 175 176 void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS, 177 StringRef PlaceHolder) { 178 if (!T) { 179 OS << "NULL TYPE"; 180 return; 181 } 182 183 SaveAndRestore<bool> PHVal(HasEmptyPlaceHolder, PlaceHolder.empty()); 184 185 printBefore(T, Quals, OS); 186 OS << PlaceHolder; 187 printAfter(T, Quals, OS); 188 } 189 190 bool TypePrinter::canPrefixQualifiers(const Type *T, 191 bool &NeedARCStrongQualifier) { 192 // CanPrefixQualifiers - We prefer to print type qualifiers before the type, 193 // so that we get "const int" instead of "int const", but we can't do this if 194 // the type is complex. For example if the type is "int*", we *must* print 195 // "int * const", printing "const int *" is different. Only do this when the 196 // type expands to a simple string. 197 bool CanPrefixQualifiers = false; 198 NeedARCStrongQualifier = false; 199 Type::TypeClass TC = T->getTypeClass(); 200 if (const auto *AT = dyn_cast<AutoType>(T)) 201 TC = AT->desugar()->getTypeClass(); 202 if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(T)) 203 TC = Subst->getReplacementType()->getTypeClass(); 204 205 switch (TC) { 206 case Type::Auto: 207 case Type::Builtin: 208 case Type::Complex: 209 case Type::UnresolvedUsing: 210 case Type::Typedef: 211 case Type::TypeOfExpr: 212 case Type::TypeOf: 213 case Type::Decltype: 214 case Type::UnaryTransform: 215 case Type::Record: 216 case Type::Enum: 217 case Type::Elaborated: 218 case Type::TemplateTypeParm: 219 case Type::SubstTemplateTypeParmPack: 220 case Type::DeducedTemplateSpecialization: 221 case Type::TemplateSpecialization: 222 case Type::InjectedClassName: 223 case Type::DependentName: 224 case Type::DependentTemplateSpecialization: 225 case Type::ObjCObject: 226 case Type::ObjCTypeParam: 227 case Type::ObjCInterface: 228 case Type::Atomic: 229 case Type::Pipe: 230 CanPrefixQualifiers = true; 231 break; 232 233 case Type::ObjCObjectPointer: 234 CanPrefixQualifiers = T->isObjCIdType() || T->isObjCClassType() || 235 T->isObjCQualifiedIdType() || T->isObjCQualifiedClassType(); 236 break; 237 238 case Type::ConstantArray: 239 case Type::IncompleteArray: 240 case Type::VariableArray: 241 case Type::DependentSizedArray: 242 NeedARCStrongQualifier = true; 243 LLVM_FALLTHROUGH; 244 245 case Type::Adjusted: 246 case Type::Decayed: 247 case Type::Pointer: 248 case Type::BlockPointer: 249 case Type::LValueReference: 250 case Type::RValueReference: 251 case Type::MemberPointer: 252 case Type::DependentAddressSpace: 253 case Type::DependentVector: 254 case Type::DependentSizedExtVector: 255 case Type::Vector: 256 case Type::ExtVector: 257 case Type::FunctionProto: 258 case Type::FunctionNoProto: 259 case Type::Paren: 260 case Type::PackExpansion: 261 case Type::SubstTemplateTypeParm: 262 case Type::MacroQualified: 263 CanPrefixQualifiers = false; 264 break; 265 266 case Type::Attributed: { 267 // We still want to print the address_space before the type if it is an 268 // address_space attribute. 269 const auto *AttrTy = cast<AttributedType>(T); 270 CanPrefixQualifiers = AttrTy->getAttrKind() == attr::AddressSpace; 271 } 272 } 273 274 return CanPrefixQualifiers; 275 } 276 277 void TypePrinter::printBefore(QualType T, raw_ostream &OS) { 278 SplitQualType Split = splitAccordingToPolicy(T, Policy); 279 280 // If we have cv1 T, where T is substituted for cv2 U, only print cv1 - cv2 281 // at this level. 282 Qualifiers Quals = Split.Quals; 283 if (const auto *Subst = dyn_cast<SubstTemplateTypeParmType>(Split.Ty)) 284 Quals -= QualType(Subst, 0).getQualifiers(); 285 286 printBefore(Split.Ty, Quals, OS); 287 } 288 289 /// Prints the part of the type string before an identifier, e.g. for 290 /// "int foo[10]" it prints "int ". 291 void TypePrinter::printBefore(const Type *T,Qualifiers Quals, raw_ostream &OS) { 292 if (Policy.SuppressSpecifiers && T->isSpecifierType()) 293 return; 294 295 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder); 296 297 // Print qualifiers as appropriate. 298 299 bool CanPrefixQualifiers = false; 300 bool NeedARCStrongQualifier = false; 301 CanPrefixQualifiers = canPrefixQualifiers(T, NeedARCStrongQualifier); 302 303 if (CanPrefixQualifiers && !Quals.empty()) { 304 if (NeedARCStrongQualifier) { 305 IncludeStrongLifetimeRAII Strong(Policy); 306 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true); 307 } else { 308 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/true); 309 } 310 } 311 312 bool hasAfterQuals = false; 313 if (!CanPrefixQualifiers && !Quals.empty()) { 314 hasAfterQuals = !Quals.isEmptyWhenPrinted(Policy); 315 if (hasAfterQuals) 316 HasEmptyPlaceHolder = false; 317 } 318 319 switch (T->getTypeClass()) { 320 #define ABSTRACT_TYPE(CLASS, PARENT) 321 #define TYPE(CLASS, PARENT) case Type::CLASS: \ 322 print##CLASS##Before(cast<CLASS##Type>(T), OS); \ 323 break; 324 #include "clang/AST/TypeNodes.inc" 325 } 326 327 if (hasAfterQuals) { 328 if (NeedARCStrongQualifier) { 329 IncludeStrongLifetimeRAII Strong(Policy); 330 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get()); 331 } else { 332 Quals.print(OS, Policy, /*appendSpaceIfNonEmpty=*/!PrevPHIsEmpty.get()); 333 } 334 } 335 } 336 337 void TypePrinter::printAfter(QualType t, raw_ostream &OS) { 338 SplitQualType split = splitAccordingToPolicy(t, Policy); 339 printAfter(split.Ty, split.Quals, OS); 340 } 341 342 /// Prints the part of the type string after an identifier, e.g. for 343 /// "int foo[10]" it prints "[10]". 344 void TypePrinter::printAfter(const Type *T, Qualifiers Quals, raw_ostream &OS) { 345 switch (T->getTypeClass()) { 346 #define ABSTRACT_TYPE(CLASS, PARENT) 347 #define TYPE(CLASS, PARENT) case Type::CLASS: \ 348 print##CLASS##After(cast<CLASS##Type>(T), OS); \ 349 break; 350 #include "clang/AST/TypeNodes.inc" 351 } 352 } 353 354 void TypePrinter::printBuiltinBefore(const BuiltinType *T, raw_ostream &OS) { 355 OS << T->getName(Policy); 356 spaceBeforePlaceHolder(OS); 357 } 358 359 void TypePrinter::printBuiltinAfter(const BuiltinType *T, raw_ostream &OS) {} 360 361 void TypePrinter::printComplexBefore(const ComplexType *T, raw_ostream &OS) { 362 OS << "_Complex "; 363 printBefore(T->getElementType(), OS); 364 } 365 366 void TypePrinter::printComplexAfter(const ComplexType *T, raw_ostream &OS) { 367 printAfter(T->getElementType(), OS); 368 } 369 370 void TypePrinter::printPointerBefore(const PointerType *T, raw_ostream &OS) { 371 IncludeStrongLifetimeRAII Strong(Policy); 372 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 373 printBefore(T->getPointeeType(), OS); 374 // Handle things like 'int (*A)[4];' correctly. 375 // FIXME: this should include vectors, but vectors use attributes I guess. 376 if (isa<ArrayType>(T->getPointeeType())) 377 OS << '('; 378 OS << '*'; 379 } 380 381 void TypePrinter::printPointerAfter(const PointerType *T, raw_ostream &OS) { 382 IncludeStrongLifetimeRAII Strong(Policy); 383 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 384 // Handle things like 'int (*A)[4];' correctly. 385 // FIXME: this should include vectors, but vectors use attributes I guess. 386 if (isa<ArrayType>(T->getPointeeType())) 387 OS << ')'; 388 printAfter(T->getPointeeType(), OS); 389 } 390 391 void TypePrinter::printBlockPointerBefore(const BlockPointerType *T, 392 raw_ostream &OS) { 393 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 394 printBefore(T->getPointeeType(), OS); 395 OS << '^'; 396 } 397 398 void TypePrinter::printBlockPointerAfter(const BlockPointerType *T, 399 raw_ostream &OS) { 400 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 401 printAfter(T->getPointeeType(), OS); 402 } 403 404 // When printing a reference, the referenced type might also be a reference. 405 // If so, we want to skip that before printing the inner type. 406 static QualType skipTopLevelReferences(QualType T) { 407 if (auto *Ref = T->getAs<ReferenceType>()) 408 return skipTopLevelReferences(Ref->getPointeeTypeAsWritten()); 409 return T; 410 } 411 412 void TypePrinter::printLValueReferenceBefore(const LValueReferenceType *T, 413 raw_ostream &OS) { 414 IncludeStrongLifetimeRAII Strong(Policy); 415 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 416 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 417 printBefore(Inner, OS); 418 // Handle things like 'int (&A)[4];' correctly. 419 // FIXME: this should include vectors, but vectors use attributes I guess. 420 if (isa<ArrayType>(Inner)) 421 OS << '('; 422 OS << '&'; 423 } 424 425 void TypePrinter::printLValueReferenceAfter(const LValueReferenceType *T, 426 raw_ostream &OS) { 427 IncludeStrongLifetimeRAII Strong(Policy); 428 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 429 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 430 // Handle things like 'int (&A)[4];' correctly. 431 // FIXME: this should include vectors, but vectors use attributes I guess. 432 if (isa<ArrayType>(Inner)) 433 OS << ')'; 434 printAfter(Inner, OS); 435 } 436 437 void TypePrinter::printRValueReferenceBefore(const RValueReferenceType *T, 438 raw_ostream &OS) { 439 IncludeStrongLifetimeRAII Strong(Policy); 440 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 441 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 442 printBefore(Inner, OS); 443 // Handle things like 'int (&&A)[4];' correctly. 444 // FIXME: this should include vectors, but vectors use attributes I guess. 445 if (isa<ArrayType>(Inner)) 446 OS << '('; 447 OS << "&&"; 448 } 449 450 void TypePrinter::printRValueReferenceAfter(const RValueReferenceType *T, 451 raw_ostream &OS) { 452 IncludeStrongLifetimeRAII Strong(Policy); 453 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 454 QualType Inner = skipTopLevelReferences(T->getPointeeTypeAsWritten()); 455 // Handle things like 'int (&&A)[4];' correctly. 456 // FIXME: this should include vectors, but vectors use attributes I guess. 457 if (isa<ArrayType>(Inner)) 458 OS << ')'; 459 printAfter(Inner, OS); 460 } 461 462 void TypePrinter::printMemberPointerBefore(const MemberPointerType *T, 463 raw_ostream &OS) { 464 IncludeStrongLifetimeRAII Strong(Policy); 465 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 466 printBefore(T->getPointeeType(), OS); 467 // Handle things like 'int (Cls::*A)[4];' correctly. 468 // FIXME: this should include vectors, but vectors use attributes I guess. 469 if (isa<ArrayType>(T->getPointeeType())) 470 OS << '('; 471 472 PrintingPolicy InnerPolicy(Policy); 473 InnerPolicy.IncludeTagDefinition = false; 474 TypePrinter(InnerPolicy).print(QualType(T->getClass(), 0), OS, StringRef()); 475 476 OS << "::*"; 477 } 478 479 void TypePrinter::printMemberPointerAfter(const MemberPointerType *T, 480 raw_ostream &OS) { 481 IncludeStrongLifetimeRAII Strong(Policy); 482 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 483 // Handle things like 'int (Cls::*A)[4];' correctly. 484 // FIXME: this should include vectors, but vectors use attributes I guess. 485 if (isa<ArrayType>(T->getPointeeType())) 486 OS << ')'; 487 printAfter(T->getPointeeType(), OS); 488 } 489 490 void TypePrinter::printConstantArrayBefore(const ConstantArrayType *T, 491 raw_ostream &OS) { 492 IncludeStrongLifetimeRAII Strong(Policy); 493 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 494 printBefore(T->getElementType(), OS); 495 } 496 497 void TypePrinter::printConstantArrayAfter(const ConstantArrayType *T, 498 raw_ostream &OS) { 499 OS << '['; 500 if (T->getIndexTypeQualifiers().hasQualifiers()) { 501 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), 502 Policy.Restrict); 503 OS << ' '; 504 } 505 506 if (T->getSizeModifier() == ArrayType::Static) 507 OS << "static "; 508 509 OS << T->getSize().getZExtValue() << ']'; 510 printAfter(T->getElementType(), OS); 511 } 512 513 void TypePrinter::printIncompleteArrayBefore(const IncompleteArrayType *T, 514 raw_ostream &OS) { 515 IncludeStrongLifetimeRAII Strong(Policy); 516 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 517 printBefore(T->getElementType(), OS); 518 } 519 520 void TypePrinter::printIncompleteArrayAfter(const IncompleteArrayType *T, 521 raw_ostream &OS) { 522 OS << "[]"; 523 printAfter(T->getElementType(), OS); 524 } 525 526 void TypePrinter::printVariableArrayBefore(const VariableArrayType *T, 527 raw_ostream &OS) { 528 IncludeStrongLifetimeRAII Strong(Policy); 529 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 530 printBefore(T->getElementType(), OS); 531 } 532 533 void TypePrinter::printVariableArrayAfter(const VariableArrayType *T, 534 raw_ostream &OS) { 535 OS << '['; 536 if (T->getIndexTypeQualifiers().hasQualifiers()) { 537 AppendTypeQualList(OS, T->getIndexTypeCVRQualifiers(), Policy.Restrict); 538 OS << ' '; 539 } 540 541 if (T->getSizeModifier() == VariableArrayType::Static) 542 OS << "static "; 543 else if (T->getSizeModifier() == VariableArrayType::Star) 544 OS << '*'; 545 546 if (T->getSizeExpr()) 547 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 548 OS << ']'; 549 550 printAfter(T->getElementType(), OS); 551 } 552 553 void TypePrinter::printAdjustedBefore(const AdjustedType *T, raw_ostream &OS) { 554 // Print the adjusted representation, otherwise the adjustment will be 555 // invisible. 556 printBefore(T->getAdjustedType(), OS); 557 } 558 559 void TypePrinter::printAdjustedAfter(const AdjustedType *T, raw_ostream &OS) { 560 printAfter(T->getAdjustedType(), OS); 561 } 562 563 void TypePrinter::printDecayedBefore(const DecayedType *T, raw_ostream &OS) { 564 // Print as though it's a pointer. 565 printAdjustedBefore(T, OS); 566 } 567 568 void TypePrinter::printDecayedAfter(const DecayedType *T, raw_ostream &OS) { 569 printAdjustedAfter(T, OS); 570 } 571 572 void TypePrinter::printDependentSizedArrayBefore( 573 const DependentSizedArrayType *T, 574 raw_ostream &OS) { 575 IncludeStrongLifetimeRAII Strong(Policy); 576 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 577 printBefore(T->getElementType(), OS); 578 } 579 580 void TypePrinter::printDependentSizedArrayAfter( 581 const DependentSizedArrayType *T, 582 raw_ostream &OS) { 583 OS << '['; 584 if (T->getSizeExpr()) 585 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 586 OS << ']'; 587 printAfter(T->getElementType(), OS); 588 } 589 590 void TypePrinter::printDependentAddressSpaceBefore( 591 const DependentAddressSpaceType *T, raw_ostream &OS) { 592 printBefore(T->getPointeeType(), OS); 593 } 594 595 void TypePrinter::printDependentAddressSpaceAfter( 596 const DependentAddressSpaceType *T, raw_ostream &OS) { 597 OS << " __attribute__((address_space("; 598 if (T->getAddrSpaceExpr()) 599 T->getAddrSpaceExpr()->printPretty(OS, nullptr, Policy); 600 OS << ")))"; 601 printAfter(T->getPointeeType(), OS); 602 } 603 604 void TypePrinter::printDependentSizedExtVectorBefore( 605 const DependentSizedExtVectorType *T, 606 raw_ostream &OS) { 607 printBefore(T->getElementType(), OS); 608 } 609 610 void TypePrinter::printDependentSizedExtVectorAfter( 611 const DependentSizedExtVectorType *T, 612 raw_ostream &OS) { 613 OS << " __attribute__((ext_vector_type("; 614 if (T->getSizeExpr()) 615 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 616 OS << ")))"; 617 printAfter(T->getElementType(), OS); 618 } 619 620 void TypePrinter::printVectorBefore(const VectorType *T, raw_ostream &OS) { 621 switch (T->getVectorKind()) { 622 case VectorType::AltiVecPixel: 623 OS << "__vector __pixel "; 624 break; 625 case VectorType::AltiVecBool: 626 OS << "__vector __bool "; 627 printBefore(T->getElementType(), OS); 628 break; 629 case VectorType::AltiVecVector: 630 OS << "__vector "; 631 printBefore(T->getElementType(), OS); 632 break; 633 case VectorType::NeonVector: 634 OS << "__attribute__((neon_vector_type(" 635 << T->getNumElements() << "))) "; 636 printBefore(T->getElementType(), OS); 637 break; 638 case VectorType::NeonPolyVector: 639 OS << "__attribute__((neon_polyvector_type(" << 640 T->getNumElements() << "))) "; 641 printBefore(T->getElementType(), OS); 642 break; 643 case VectorType::GenericVector: { 644 // FIXME: We prefer to print the size directly here, but have no way 645 // to get the size of the type. 646 OS << "__attribute__((__vector_size__(" 647 << T->getNumElements() 648 << " * sizeof("; 649 print(T->getElementType(), OS, StringRef()); 650 OS << ")))) "; 651 printBefore(T->getElementType(), OS); 652 break; 653 } 654 } 655 } 656 657 void TypePrinter::printVectorAfter(const VectorType *T, raw_ostream &OS) { 658 printAfter(T->getElementType(), OS); 659 } 660 661 void TypePrinter::printDependentVectorBefore( 662 const DependentVectorType *T, raw_ostream &OS) { 663 switch (T->getVectorKind()) { 664 case VectorType::AltiVecPixel: 665 OS << "__vector __pixel "; 666 break; 667 case VectorType::AltiVecBool: 668 OS << "__vector __bool "; 669 printBefore(T->getElementType(), OS); 670 break; 671 case VectorType::AltiVecVector: 672 OS << "__vector "; 673 printBefore(T->getElementType(), OS); 674 break; 675 case VectorType::NeonVector: 676 OS << "__attribute__((neon_vector_type("; 677 if (T->getSizeExpr()) 678 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 679 OS << "))) "; 680 printBefore(T->getElementType(), OS); 681 break; 682 case VectorType::NeonPolyVector: 683 OS << "__attribute__((neon_polyvector_type("; 684 if (T->getSizeExpr()) 685 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 686 OS << "))) "; 687 printBefore(T->getElementType(), OS); 688 break; 689 case VectorType::GenericVector: { 690 // FIXME: We prefer to print the size directly here, but have no way 691 // to get the size of the type. 692 OS << "__attribute__((__vector_size__("; 693 if (T->getSizeExpr()) 694 T->getSizeExpr()->printPretty(OS, nullptr, Policy); 695 OS << " * sizeof("; 696 print(T->getElementType(), OS, StringRef()); 697 OS << ")))) "; 698 printBefore(T->getElementType(), OS); 699 break; 700 } 701 } 702 } 703 704 void TypePrinter::printDependentVectorAfter( 705 const DependentVectorType *T, raw_ostream &OS) { 706 printAfter(T->getElementType(), OS); 707 } 708 709 void TypePrinter::printExtVectorBefore(const ExtVectorType *T, 710 raw_ostream &OS) { 711 printBefore(T->getElementType(), OS); 712 } 713 714 void TypePrinter::printExtVectorAfter(const ExtVectorType *T, raw_ostream &OS) { 715 printAfter(T->getElementType(), OS); 716 OS << " __attribute__((ext_vector_type("; 717 OS << T->getNumElements(); 718 OS << ")))"; 719 } 720 721 void 722 FunctionProtoType::printExceptionSpecification(raw_ostream &OS, 723 const PrintingPolicy &Policy) 724 const { 725 if (hasDynamicExceptionSpec()) { 726 OS << " throw("; 727 if (getExceptionSpecType() == EST_MSAny) 728 OS << "..."; 729 else 730 for (unsigned I = 0, N = getNumExceptions(); I != N; ++I) { 731 if (I) 732 OS << ", "; 733 734 OS << getExceptionType(I).stream(Policy); 735 } 736 OS << ')'; 737 } else if (EST_NoThrow == getExceptionSpecType()) { 738 OS << " __attribute__((nothrow))"; 739 } else if (isNoexceptExceptionSpec(getExceptionSpecType())) { 740 OS << " noexcept"; 741 // FIXME:Is it useful to print out the expression for a non-dependent 742 // noexcept specification? 743 if (isComputedNoexcept(getExceptionSpecType())) { 744 OS << '('; 745 if (getNoexceptExpr()) 746 getNoexceptExpr()->printPretty(OS, nullptr, Policy); 747 OS << ')'; 748 } 749 } 750 } 751 752 void TypePrinter::printFunctionProtoBefore(const FunctionProtoType *T, 753 raw_ostream &OS) { 754 if (T->hasTrailingReturn()) { 755 OS << "auto "; 756 if (!HasEmptyPlaceHolder) 757 OS << '('; 758 } else { 759 // If needed for precedence reasons, wrap the inner part in grouping parens. 760 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false); 761 printBefore(T->getReturnType(), OS); 762 if (!PrevPHIsEmpty.get()) 763 OS << '('; 764 } 765 } 766 767 StringRef clang::getParameterABISpelling(ParameterABI ABI) { 768 switch (ABI) { 769 case ParameterABI::Ordinary: 770 llvm_unreachable("asking for spelling of ordinary parameter ABI"); 771 case ParameterABI::SwiftContext: 772 return "swift_context"; 773 case ParameterABI::SwiftErrorResult: 774 return "swift_error_result"; 775 case ParameterABI::SwiftIndirectResult: 776 return "swift_indirect_result"; 777 } 778 llvm_unreachable("bad parameter ABI kind"); 779 } 780 781 void TypePrinter::printFunctionProtoAfter(const FunctionProtoType *T, 782 raw_ostream &OS) { 783 // If needed for precedence reasons, wrap the inner part in grouping parens. 784 if (!HasEmptyPlaceHolder) 785 OS << ')'; 786 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 787 788 OS << '('; 789 { 790 ParamPolicyRAII ParamPolicy(Policy); 791 for (unsigned i = 0, e = T->getNumParams(); i != e; ++i) { 792 if (i) OS << ", "; 793 794 auto EPI = T->getExtParameterInfo(i); 795 if (EPI.isConsumed()) OS << "__attribute__((ns_consumed)) "; 796 if (EPI.isNoEscape()) 797 OS << "__attribute__((noescape)) "; 798 auto ABI = EPI.getABI(); 799 if (ABI != ParameterABI::Ordinary) 800 OS << "__attribute__((" << getParameterABISpelling(ABI) << ")) "; 801 802 print(T->getParamType(i), OS, StringRef()); 803 } 804 } 805 806 if (T->isVariadic()) { 807 if (T->getNumParams()) 808 OS << ", "; 809 OS << "..."; 810 } else if (T->getNumParams() == 0 && Policy.UseVoidForZeroParams) { 811 // Do not emit int() if we have a proto, emit 'int(void)'. 812 OS << "void"; 813 } 814 815 OS << ')'; 816 817 FunctionType::ExtInfo Info = T->getExtInfo(); 818 819 printFunctionAfter(Info, OS); 820 821 if (!T->getMethodQuals().empty()) 822 OS << " " << T->getMethodQuals().getAsString(); 823 824 switch (T->getRefQualifier()) { 825 case RQ_None: 826 break; 827 828 case RQ_LValue: 829 OS << " &"; 830 break; 831 832 case RQ_RValue: 833 OS << " &&"; 834 break; 835 } 836 T->printExceptionSpecification(OS, Policy); 837 838 if (T->hasTrailingReturn()) { 839 OS << " -> "; 840 print(T->getReturnType(), OS, StringRef()); 841 } else 842 printAfter(T->getReturnType(), OS); 843 } 844 845 void TypePrinter::printFunctionAfter(const FunctionType::ExtInfo &Info, 846 raw_ostream &OS) { 847 if (!InsideCCAttribute) { 848 switch (Info.getCC()) { 849 case CC_C: 850 // The C calling convention is the default on the vast majority of platforms 851 // we support. If the user wrote it explicitly, it will usually be printed 852 // while traversing the AttributedType. If the type has been desugared, let 853 // the canonical spelling be the implicit calling convention. 854 // FIXME: It would be better to be explicit in certain contexts, such as a 855 // cdecl function typedef used to declare a member function with the 856 // Microsoft C++ ABI. 857 break; 858 case CC_X86StdCall: 859 OS << " __attribute__((stdcall))"; 860 break; 861 case CC_X86FastCall: 862 OS << " __attribute__((fastcall))"; 863 break; 864 case CC_X86ThisCall: 865 OS << " __attribute__((thiscall))"; 866 break; 867 case CC_X86VectorCall: 868 OS << " __attribute__((vectorcall))"; 869 break; 870 case CC_X86Pascal: 871 OS << " __attribute__((pascal))"; 872 break; 873 case CC_AAPCS: 874 OS << " __attribute__((pcs(\"aapcs\")))"; 875 break; 876 case CC_AAPCS_VFP: 877 OS << " __attribute__((pcs(\"aapcs-vfp\")))"; 878 break; 879 case CC_AArch64VectorCall: 880 OS << "__attribute__((aarch64_vector_pcs))"; 881 break; 882 case CC_IntelOclBicc: 883 OS << " __attribute__((intel_ocl_bicc))"; 884 break; 885 case CC_Win64: 886 OS << " __attribute__((ms_abi))"; 887 break; 888 case CC_X86_64SysV: 889 OS << " __attribute__((sysv_abi))"; 890 break; 891 case CC_X86RegCall: 892 OS << " __attribute__((regcall))"; 893 break; 894 case CC_SpirFunction: 895 case CC_OpenCLKernel: 896 // Do nothing. These CCs are not available as attributes. 897 break; 898 case CC_Swift: 899 OS << " __attribute__((swiftcall))"; 900 break; 901 case CC_PreserveMost: 902 OS << " __attribute__((preserve_most))"; 903 break; 904 case CC_PreserveAll: 905 OS << " __attribute__((preserve_all))"; 906 break; 907 } 908 } 909 910 if (Info.getNoReturn()) 911 OS << " __attribute__((noreturn))"; 912 if (Info.getProducesResult()) 913 OS << " __attribute__((ns_returns_retained))"; 914 if (Info.getRegParm()) 915 OS << " __attribute__((regparm (" 916 << Info.getRegParm() << ")))"; 917 if (Info.getNoCallerSavedRegs()) 918 OS << " __attribute__((no_caller_saved_registers))"; 919 if (Info.getNoCfCheck()) 920 OS << " __attribute__((nocf_check))"; 921 } 922 923 void TypePrinter::printFunctionNoProtoBefore(const FunctionNoProtoType *T, 924 raw_ostream &OS) { 925 // If needed for precedence reasons, wrap the inner part in grouping parens. 926 SaveAndRestore<bool> PrevPHIsEmpty(HasEmptyPlaceHolder, false); 927 printBefore(T->getReturnType(), OS); 928 if (!PrevPHIsEmpty.get()) 929 OS << '('; 930 } 931 932 void TypePrinter::printFunctionNoProtoAfter(const FunctionNoProtoType *T, 933 raw_ostream &OS) { 934 // If needed for precedence reasons, wrap the inner part in grouping parens. 935 if (!HasEmptyPlaceHolder) 936 OS << ')'; 937 SaveAndRestore<bool> NonEmptyPH(HasEmptyPlaceHolder, false); 938 939 OS << "()"; 940 printFunctionAfter(T->getExtInfo(), OS); 941 printAfter(T->getReturnType(), OS); 942 } 943 944 void TypePrinter::printTypeSpec(NamedDecl *D, raw_ostream &OS) { 945 946 // Compute the full nested-name-specifier for this type. 947 // In C, this will always be empty except when the type 948 // being printed is anonymous within other Record. 949 if (!Policy.SuppressScope) 950 AppendScope(D->getDeclContext(), OS); 951 952 IdentifierInfo *II = D->getIdentifier(); 953 OS << II->getName(); 954 spaceBeforePlaceHolder(OS); 955 } 956 957 void TypePrinter::printUnresolvedUsingBefore(const UnresolvedUsingType *T, 958 raw_ostream &OS) { 959 printTypeSpec(T->getDecl(), OS); 960 } 961 962 void TypePrinter::printUnresolvedUsingAfter(const UnresolvedUsingType *T, 963 raw_ostream &OS) {} 964 965 void TypePrinter::printTypedefBefore(const TypedefType *T, raw_ostream &OS) { 966 printTypeSpec(T->getDecl(), OS); 967 } 968 969 void TypePrinter::printMacroQualifiedBefore(const MacroQualifiedType *T, 970 raw_ostream &OS) { 971 StringRef MacroName = T->getMacroIdentifier()->getName(); 972 OS << MacroName << " "; 973 974 // Since this type is meant to print the macro instead of the whole attribute, 975 // we trim any attributes and go directly to the original modified type. 976 printBefore(T->getModifiedType(), OS); 977 } 978 979 void TypePrinter::printMacroQualifiedAfter(const MacroQualifiedType *T, 980 raw_ostream &OS) { 981 printAfter(T->getModifiedType(), OS); 982 } 983 984 void TypePrinter::printTypedefAfter(const TypedefType *T, raw_ostream &OS) {} 985 986 void TypePrinter::printTypeOfExprBefore(const TypeOfExprType *T, 987 raw_ostream &OS) { 988 OS << "typeof "; 989 if (T->getUnderlyingExpr()) 990 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy); 991 spaceBeforePlaceHolder(OS); 992 } 993 994 void TypePrinter::printTypeOfExprAfter(const TypeOfExprType *T, 995 raw_ostream &OS) {} 996 997 void TypePrinter::printTypeOfBefore(const TypeOfType *T, raw_ostream &OS) { 998 OS << "typeof("; 999 print(T->getUnderlyingType(), OS, StringRef()); 1000 OS << ')'; 1001 spaceBeforePlaceHolder(OS); 1002 } 1003 1004 void TypePrinter::printTypeOfAfter(const TypeOfType *T, raw_ostream &OS) {} 1005 1006 void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) { 1007 OS << "decltype("; 1008 if (T->getUnderlyingExpr()) 1009 T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy); 1010 OS << ')'; 1011 spaceBeforePlaceHolder(OS); 1012 } 1013 1014 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {} 1015 1016 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T, 1017 raw_ostream &OS) { 1018 IncludeStrongLifetimeRAII Strong(Policy); 1019 1020 switch (T->getUTTKind()) { 1021 case UnaryTransformType::EnumUnderlyingType: 1022 OS << "__underlying_type("; 1023 print(T->getBaseType(), OS, StringRef()); 1024 OS << ')'; 1025 spaceBeforePlaceHolder(OS); 1026 return; 1027 } 1028 1029 printBefore(T->getBaseType(), OS); 1030 } 1031 1032 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T, 1033 raw_ostream &OS) { 1034 IncludeStrongLifetimeRAII Strong(Policy); 1035 1036 switch (T->getUTTKind()) { 1037 case UnaryTransformType::EnumUnderlyingType: 1038 return; 1039 } 1040 1041 printAfter(T->getBaseType(), OS); 1042 } 1043 1044 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) { 1045 // If the type has been deduced, do not print 'auto'. 1046 if (!T->getDeducedType().isNull()) { 1047 printBefore(T->getDeducedType(), OS); 1048 } else { 1049 if (T->isConstrained()) { 1050 OS << T->getTypeConstraintConcept()->getName(); 1051 auto Args = T->getTypeConstraintArguments(); 1052 if (!Args.empty()) 1053 printTemplateArgumentList(OS, Args, Policy); 1054 OS << ' '; 1055 } 1056 switch (T->getKeyword()) { 1057 case AutoTypeKeyword::Auto: OS << "auto"; break; 1058 case AutoTypeKeyword::DecltypeAuto: OS << "decltype(auto)"; break; 1059 case AutoTypeKeyword::GNUAutoType: OS << "__auto_type"; break; 1060 } 1061 spaceBeforePlaceHolder(OS); 1062 } 1063 } 1064 1065 void TypePrinter::printAutoAfter(const AutoType *T, raw_ostream &OS) { 1066 // If the type has been deduced, do not print 'auto'. 1067 if (!T->getDeducedType().isNull()) 1068 printAfter(T->getDeducedType(), OS); 1069 } 1070 1071 void TypePrinter::printDeducedTemplateSpecializationBefore( 1072 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1073 // If the type has been deduced, print the deduced type. 1074 if (!T->getDeducedType().isNull()) { 1075 printBefore(T->getDeducedType(), OS); 1076 } else { 1077 IncludeStrongLifetimeRAII Strong(Policy); 1078 T->getTemplateName().print(OS, Policy); 1079 spaceBeforePlaceHolder(OS); 1080 } 1081 } 1082 1083 void TypePrinter::printDeducedTemplateSpecializationAfter( 1084 const DeducedTemplateSpecializationType *T, raw_ostream &OS) { 1085 // If the type has been deduced, print the deduced type. 1086 if (!T->getDeducedType().isNull()) 1087 printAfter(T->getDeducedType(), OS); 1088 } 1089 1090 void TypePrinter::printAtomicBefore(const AtomicType *T, raw_ostream &OS) { 1091 IncludeStrongLifetimeRAII Strong(Policy); 1092 1093 OS << "_Atomic("; 1094 print(T->getValueType(), OS, StringRef()); 1095 OS << ')'; 1096 spaceBeforePlaceHolder(OS); 1097 } 1098 1099 void TypePrinter::printAtomicAfter(const AtomicType *T, raw_ostream &OS) {} 1100 1101 void TypePrinter::printPipeBefore(const PipeType *T, raw_ostream &OS) { 1102 IncludeStrongLifetimeRAII Strong(Policy); 1103 1104 if (T->isReadOnly()) 1105 OS << "read_only "; 1106 else 1107 OS << "write_only "; 1108 OS << "pipe "; 1109 print(T->getElementType(), OS, StringRef()); 1110 spaceBeforePlaceHolder(OS); 1111 } 1112 1113 void TypePrinter::printPipeAfter(const PipeType *T, raw_ostream &OS) {} 1114 1115 /// Appends the given scope to the end of a string. 1116 void TypePrinter::AppendScope(DeclContext *DC, raw_ostream &OS) { 1117 if (DC->isTranslationUnit()) return; 1118 if (DC->isFunctionOrMethod()) return; 1119 AppendScope(DC->getParent(), OS); 1120 1121 if (const auto *NS = dyn_cast<NamespaceDecl>(DC)) { 1122 if (Policy.SuppressUnwrittenScope && 1123 (NS->isAnonymousNamespace() || NS->isInline())) 1124 return; 1125 if (NS->getIdentifier()) 1126 OS << NS->getName() << "::"; 1127 else 1128 OS << "(anonymous namespace)::"; 1129 } else if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) { 1130 IncludeStrongLifetimeRAII Strong(Policy); 1131 OS << Spec->getIdentifier()->getName(); 1132 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1133 printTemplateArgumentList(OS, TemplateArgs.asArray(), Policy); 1134 OS << "::"; 1135 } else if (const auto *Tag = dyn_cast<TagDecl>(DC)) { 1136 if (TypedefNameDecl *Typedef = Tag->getTypedefNameForAnonDecl()) 1137 OS << Typedef->getIdentifier()->getName() << "::"; 1138 else if (Tag->getIdentifier()) 1139 OS << Tag->getIdentifier()->getName() << "::"; 1140 else 1141 return; 1142 } 1143 } 1144 1145 void TypePrinter::printTag(TagDecl *D, raw_ostream &OS) { 1146 if (Policy.IncludeTagDefinition) { 1147 PrintingPolicy SubPolicy = Policy; 1148 SubPolicy.IncludeTagDefinition = false; 1149 D->print(OS, SubPolicy, Indentation); 1150 spaceBeforePlaceHolder(OS); 1151 return; 1152 } 1153 1154 bool HasKindDecoration = false; 1155 1156 // We don't print tags unless this is an elaborated type. 1157 // In C, we just assume every RecordType is an elaborated type. 1158 if (!Policy.SuppressTagKeyword && !D->getTypedefNameForAnonDecl()) { 1159 HasKindDecoration = true; 1160 OS << D->getKindName(); 1161 OS << ' '; 1162 } 1163 1164 // Compute the full nested-name-specifier for this type. 1165 // In C, this will always be empty except when the type 1166 // being printed is anonymous within other Record. 1167 if (!Policy.SuppressScope) 1168 AppendScope(D->getDeclContext(), OS); 1169 1170 if (const IdentifierInfo *II = D->getIdentifier()) 1171 OS << II->getName(); 1172 else if (TypedefNameDecl *Typedef = D->getTypedefNameForAnonDecl()) { 1173 assert(Typedef->getIdentifier() && "Typedef without identifier?"); 1174 OS << Typedef->getIdentifier()->getName(); 1175 } else { 1176 // Make an unambiguous representation for anonymous types, e.g. 1177 // (anonymous enum at /usr/include/string.h:120:9) 1178 OS << (Policy.MSVCFormatting ? '`' : '('); 1179 1180 if (isa<CXXRecordDecl>(D) && cast<CXXRecordDecl>(D)->isLambda()) { 1181 OS << "lambda"; 1182 HasKindDecoration = true; 1183 } else { 1184 OS << "anonymous"; 1185 } 1186 1187 if (Policy.AnonymousTagLocations) { 1188 // Suppress the redundant tag keyword if we just printed one. 1189 // We don't have to worry about ElaboratedTypes here because you can't 1190 // refer to an anonymous type with one. 1191 if (!HasKindDecoration) 1192 OS << " " << D->getKindName(); 1193 1194 PresumedLoc PLoc = D->getASTContext().getSourceManager().getPresumedLoc( 1195 D->getLocation()); 1196 if (PLoc.isValid()) { 1197 OS << " at "; 1198 StringRef File = PLoc.getFilename(); 1199 if (auto *Callbacks = Policy.Callbacks) 1200 OS << Callbacks->remapPath(File); 1201 else 1202 OS << File; 1203 OS << ':' << PLoc.getLine() << ':' << PLoc.getColumn(); 1204 } 1205 } 1206 1207 OS << (Policy.MSVCFormatting ? '\'' : ')'); 1208 } 1209 1210 // If this is a class template specialization, print the template 1211 // arguments. 1212 if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 1213 ArrayRef<TemplateArgument> Args; 1214 TypeSourceInfo *TAW = Spec->getTypeAsWritten(); 1215 if (!Policy.PrintCanonicalTypes && TAW) { 1216 const TemplateSpecializationType *TST = 1217 cast<TemplateSpecializationType>(TAW->getType()); 1218 Args = TST->template_arguments(); 1219 } else { 1220 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 1221 Args = TemplateArgs.asArray(); 1222 } 1223 IncludeStrongLifetimeRAII Strong(Policy); 1224 printTemplateArgumentList(OS, Args, Policy); 1225 } 1226 1227 spaceBeforePlaceHolder(OS); 1228 } 1229 1230 void TypePrinter::printRecordBefore(const RecordType *T, raw_ostream &OS) { 1231 printTag(T->getDecl(), OS); 1232 } 1233 1234 void TypePrinter::printRecordAfter(const RecordType *T, raw_ostream &OS) {} 1235 1236 void TypePrinter::printEnumBefore(const EnumType *T, raw_ostream &OS) { 1237 printTag(T->getDecl(), OS); 1238 } 1239 1240 void TypePrinter::printEnumAfter(const EnumType *T, raw_ostream &OS) {} 1241 1242 void TypePrinter::printTemplateTypeParmBefore(const TemplateTypeParmType *T, 1243 raw_ostream &OS) { 1244 TemplateTypeParmDecl *D = T->getDecl(); 1245 if (D && D->isImplicit()) { 1246 if (auto *TC = D->getTypeConstraint()) { 1247 TC->print(OS, Policy); 1248 OS << ' '; 1249 } 1250 OS << "auto"; 1251 } else if (IdentifierInfo *Id = T->getIdentifier()) 1252 OS << Id->getName(); 1253 else 1254 OS << "type-parameter-" << T->getDepth() << '-' << T->getIndex(); 1255 1256 spaceBeforePlaceHolder(OS); 1257 } 1258 1259 void TypePrinter::printTemplateTypeParmAfter(const TemplateTypeParmType *T, 1260 raw_ostream &OS) {} 1261 1262 void TypePrinter::printSubstTemplateTypeParmBefore( 1263 const SubstTemplateTypeParmType *T, 1264 raw_ostream &OS) { 1265 IncludeStrongLifetimeRAII Strong(Policy); 1266 printBefore(T->getReplacementType(), OS); 1267 } 1268 1269 void TypePrinter::printSubstTemplateTypeParmAfter( 1270 const SubstTemplateTypeParmType *T, 1271 raw_ostream &OS) { 1272 IncludeStrongLifetimeRAII Strong(Policy); 1273 printAfter(T->getReplacementType(), OS); 1274 } 1275 1276 void TypePrinter::printSubstTemplateTypeParmPackBefore( 1277 const SubstTemplateTypeParmPackType *T, 1278 raw_ostream &OS) { 1279 IncludeStrongLifetimeRAII Strong(Policy); 1280 printTemplateTypeParmBefore(T->getReplacedParameter(), OS); 1281 } 1282 1283 void TypePrinter::printSubstTemplateTypeParmPackAfter( 1284 const SubstTemplateTypeParmPackType *T, 1285 raw_ostream &OS) { 1286 IncludeStrongLifetimeRAII Strong(Policy); 1287 printTemplateTypeParmAfter(T->getReplacedParameter(), OS); 1288 } 1289 1290 void TypePrinter::printTemplateSpecializationBefore( 1291 const TemplateSpecializationType *T, 1292 raw_ostream &OS) { 1293 IncludeStrongLifetimeRAII Strong(Policy); 1294 T->getTemplateName().print(OS, Policy); 1295 1296 printTemplateArgumentList(OS, T->template_arguments(), Policy); 1297 spaceBeforePlaceHolder(OS); 1298 } 1299 1300 void TypePrinter::printTemplateSpecializationAfter( 1301 const TemplateSpecializationType *T, 1302 raw_ostream &OS) {} 1303 1304 void TypePrinter::printInjectedClassNameBefore(const InjectedClassNameType *T, 1305 raw_ostream &OS) { 1306 printTemplateSpecializationBefore(T->getInjectedTST(), OS); 1307 } 1308 1309 void TypePrinter::printInjectedClassNameAfter(const InjectedClassNameType *T, 1310 raw_ostream &OS) {} 1311 1312 void TypePrinter::printElaboratedBefore(const ElaboratedType *T, 1313 raw_ostream &OS) { 1314 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) { 1315 TagDecl *OwnedTagDecl = T->getOwnedTagDecl(); 1316 assert(OwnedTagDecl->getTypeForDecl() == T->getNamedType().getTypePtr() && 1317 "OwnedTagDecl expected to be a declaration for the type"); 1318 PrintingPolicy SubPolicy = Policy; 1319 SubPolicy.IncludeTagDefinition = false; 1320 OwnedTagDecl->print(OS, SubPolicy, Indentation); 1321 spaceBeforePlaceHolder(OS); 1322 return; 1323 } 1324 1325 // The tag definition will take care of these. 1326 if (!Policy.IncludeTagDefinition) 1327 { 1328 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1329 if (T->getKeyword() != ETK_None) 1330 OS << " "; 1331 NestedNameSpecifier *Qualifier = T->getQualifier(); 1332 if (Qualifier) 1333 Qualifier->print(OS, Policy); 1334 } 1335 1336 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1337 printBefore(T->getNamedType(), OS); 1338 } 1339 1340 void TypePrinter::printElaboratedAfter(const ElaboratedType *T, 1341 raw_ostream &OS) { 1342 if (Policy.IncludeTagDefinition && T->getOwnedTagDecl()) 1343 return; 1344 ElaboratedTypePolicyRAII PolicyRAII(Policy); 1345 printAfter(T->getNamedType(), OS); 1346 } 1347 1348 void TypePrinter::printParenBefore(const ParenType *T, raw_ostream &OS) { 1349 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1350 printBefore(T->getInnerType(), OS); 1351 OS << '('; 1352 } else 1353 printBefore(T->getInnerType(), OS); 1354 } 1355 1356 void TypePrinter::printParenAfter(const ParenType *T, raw_ostream &OS) { 1357 if (!HasEmptyPlaceHolder && !isa<FunctionType>(T->getInnerType())) { 1358 OS << ')'; 1359 printAfter(T->getInnerType(), OS); 1360 } else 1361 printAfter(T->getInnerType(), OS); 1362 } 1363 1364 void TypePrinter::printDependentNameBefore(const DependentNameType *T, 1365 raw_ostream &OS) { 1366 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1367 if (T->getKeyword() != ETK_None) 1368 OS << " "; 1369 1370 T->getQualifier()->print(OS, Policy); 1371 1372 OS << T->getIdentifier()->getName(); 1373 spaceBeforePlaceHolder(OS); 1374 } 1375 1376 void TypePrinter::printDependentNameAfter(const DependentNameType *T, 1377 raw_ostream &OS) {} 1378 1379 void TypePrinter::printDependentTemplateSpecializationBefore( 1380 const DependentTemplateSpecializationType *T, raw_ostream &OS) { 1381 IncludeStrongLifetimeRAII Strong(Policy); 1382 1383 OS << TypeWithKeyword::getKeywordName(T->getKeyword()); 1384 if (T->getKeyword() != ETK_None) 1385 OS << " "; 1386 1387 if (T->getQualifier()) 1388 T->getQualifier()->print(OS, Policy); 1389 OS << T->getIdentifier()->getName(); 1390 printTemplateArgumentList(OS, T->template_arguments(), Policy); 1391 spaceBeforePlaceHolder(OS); 1392 } 1393 1394 void TypePrinter::printDependentTemplateSpecializationAfter( 1395 const DependentTemplateSpecializationType *T, raw_ostream &OS) {} 1396 1397 void TypePrinter::printPackExpansionBefore(const PackExpansionType *T, 1398 raw_ostream &OS) { 1399 printBefore(T->getPattern(), OS); 1400 } 1401 1402 void TypePrinter::printPackExpansionAfter(const PackExpansionType *T, 1403 raw_ostream &OS) { 1404 printAfter(T->getPattern(), OS); 1405 OS << "..."; 1406 } 1407 1408 void TypePrinter::printAttributedBefore(const AttributedType *T, 1409 raw_ostream &OS) { 1410 // FIXME: Generate this with TableGen. 1411 1412 // Prefer the macro forms of the GC and ownership qualifiers. 1413 if (T->getAttrKind() == attr::ObjCGC || 1414 T->getAttrKind() == attr::ObjCOwnership) 1415 return printBefore(T->getEquivalentType(), OS); 1416 1417 if (T->getAttrKind() == attr::ObjCKindOf) 1418 OS << "__kindof "; 1419 1420 if (T->getAttrKind() == attr::AddressSpace) 1421 printBefore(T->getEquivalentType(), OS); 1422 else 1423 printBefore(T->getModifiedType(), OS); 1424 1425 if (T->isMSTypeSpec()) { 1426 switch (T->getAttrKind()) { 1427 default: return; 1428 case attr::Ptr32: OS << " __ptr32"; break; 1429 case attr::Ptr64: OS << " __ptr64"; break; 1430 case attr::SPtr: OS << " __sptr"; break; 1431 case attr::UPtr: OS << " __uptr"; break; 1432 } 1433 spaceBeforePlaceHolder(OS); 1434 } 1435 1436 // Print nullability type specifiers. 1437 if (T->getImmediateNullability()) { 1438 if (T->getAttrKind() == attr::TypeNonNull) 1439 OS << " _Nonnull"; 1440 else if (T->getAttrKind() == attr::TypeNullable) 1441 OS << " _Nullable"; 1442 else if (T->getAttrKind() == attr::TypeNullUnspecified) 1443 OS << " _Null_unspecified"; 1444 else 1445 llvm_unreachable("unhandled nullability"); 1446 spaceBeforePlaceHolder(OS); 1447 } 1448 } 1449 1450 void TypePrinter::printAttributedAfter(const AttributedType *T, 1451 raw_ostream &OS) { 1452 // FIXME: Generate this with TableGen. 1453 1454 // Prefer the macro forms of the GC and ownership qualifiers. 1455 if (T->getAttrKind() == attr::ObjCGC || 1456 T->getAttrKind() == attr::ObjCOwnership) 1457 return printAfter(T->getEquivalentType(), OS); 1458 1459 // If this is a calling convention attribute, don't print the implicit CC from 1460 // the modified type. 1461 SaveAndRestore<bool> MaybeSuppressCC(InsideCCAttribute, T->isCallingConv()); 1462 1463 printAfter(T->getModifiedType(), OS); 1464 1465 // Some attributes are printed as qualifiers before the type, so we have 1466 // nothing left to do. 1467 if (T->getAttrKind() == attr::ObjCKindOf || 1468 T->isMSTypeSpec() || T->getImmediateNullability()) 1469 return; 1470 1471 // Don't print the inert __unsafe_unretained attribute at all. 1472 if (T->getAttrKind() == attr::ObjCInertUnsafeUnretained) 1473 return; 1474 1475 // Don't print ns_returns_retained unless it had an effect. 1476 if (T->getAttrKind() == attr::NSReturnsRetained && 1477 !T->getEquivalentType()->castAs<FunctionType>() 1478 ->getExtInfo().getProducesResult()) 1479 return; 1480 1481 if (T->getAttrKind() == attr::LifetimeBound) { 1482 OS << " [[clang::lifetimebound]]"; 1483 return; 1484 } 1485 1486 // The printing of the address_space attribute is handled by the qualifier 1487 // since it is still stored in the qualifier. Return early to prevent printing 1488 // this twice. 1489 if (T->getAttrKind() == attr::AddressSpace) 1490 return; 1491 1492 OS << " __attribute__(("; 1493 switch (T->getAttrKind()) { 1494 #define TYPE_ATTR(NAME) 1495 #define DECL_OR_TYPE_ATTR(NAME) 1496 #define ATTR(NAME) case attr::NAME: 1497 #include "clang/Basic/AttrList.inc" 1498 llvm_unreachable("non-type attribute attached to type"); 1499 1500 case attr::OpenCLPrivateAddressSpace: 1501 case attr::OpenCLGlobalAddressSpace: 1502 case attr::OpenCLLocalAddressSpace: 1503 case attr::OpenCLConstantAddressSpace: 1504 case attr::OpenCLGenericAddressSpace: 1505 // FIXME: Update printAttributedBefore to print these once we generate 1506 // AttributedType nodes for them. 1507 break; 1508 1509 case attr::LifetimeBound: 1510 case attr::TypeNonNull: 1511 case attr::TypeNullable: 1512 case attr::TypeNullUnspecified: 1513 case attr::ObjCGC: 1514 case attr::ObjCInertUnsafeUnretained: 1515 case attr::ObjCKindOf: 1516 case attr::ObjCOwnership: 1517 case attr::Ptr32: 1518 case attr::Ptr64: 1519 case attr::SPtr: 1520 case attr::UPtr: 1521 case attr::AddressSpace: 1522 llvm_unreachable("This attribute should have been handled already"); 1523 1524 case attr::NSReturnsRetained: 1525 OS << "ns_returns_retained"; 1526 break; 1527 1528 // FIXME: When Sema learns to form this AttributedType, avoid printing the 1529 // attribute again in printFunctionProtoAfter. 1530 case attr::AnyX86NoCfCheck: OS << "nocf_check"; break; 1531 case attr::CDecl: OS << "cdecl"; break; 1532 case attr::FastCall: OS << "fastcall"; break; 1533 case attr::StdCall: OS << "stdcall"; break; 1534 case attr::ThisCall: OS << "thiscall"; break; 1535 case attr::SwiftCall: OS << "swiftcall"; break; 1536 case attr::VectorCall: OS << "vectorcall"; break; 1537 case attr::Pascal: OS << "pascal"; break; 1538 case attr::MSABI: OS << "ms_abi"; break; 1539 case attr::SysVABI: OS << "sysv_abi"; break; 1540 case attr::RegCall: OS << "regcall"; break; 1541 case attr::Pcs: { 1542 OS << "pcs("; 1543 QualType t = T->getEquivalentType(); 1544 while (!t->isFunctionType()) 1545 t = t->getPointeeType(); 1546 OS << (t->castAs<FunctionType>()->getCallConv() == CC_AAPCS ? 1547 "\"aapcs\"" : "\"aapcs-vfp\""); 1548 OS << ')'; 1549 break; 1550 } 1551 case attr::AArch64VectorPcs: OS << "aarch64_vector_pcs"; break; 1552 case attr::IntelOclBicc: OS << "inteloclbicc"; break; 1553 case attr::PreserveMost: 1554 OS << "preserve_most"; 1555 break; 1556 1557 case attr::PreserveAll: 1558 OS << "preserve_all"; 1559 break; 1560 case attr::NoDeref: 1561 OS << "noderef"; 1562 break; 1563 case attr::AcquireHandle: 1564 OS << "acquire_handle"; 1565 break; 1566 } 1567 OS << "))"; 1568 } 1569 1570 void TypePrinter::printObjCInterfaceBefore(const ObjCInterfaceType *T, 1571 raw_ostream &OS) { 1572 OS << T->getDecl()->getName(); 1573 spaceBeforePlaceHolder(OS); 1574 } 1575 1576 void TypePrinter::printObjCInterfaceAfter(const ObjCInterfaceType *T, 1577 raw_ostream &OS) {} 1578 1579 void TypePrinter::printObjCTypeParamBefore(const ObjCTypeParamType *T, 1580 raw_ostream &OS) { 1581 OS << T->getDecl()->getName(); 1582 if (!T->qual_empty()) { 1583 bool isFirst = true; 1584 OS << '<'; 1585 for (const auto *I : T->quals()) { 1586 if (isFirst) 1587 isFirst = false; 1588 else 1589 OS << ','; 1590 OS << I->getName(); 1591 } 1592 OS << '>'; 1593 } 1594 1595 spaceBeforePlaceHolder(OS); 1596 } 1597 1598 void TypePrinter::printObjCTypeParamAfter(const ObjCTypeParamType *T, 1599 raw_ostream &OS) {} 1600 1601 void TypePrinter::printObjCObjectBefore(const ObjCObjectType *T, 1602 raw_ostream &OS) { 1603 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1604 !T->isKindOfTypeAsWritten()) 1605 return printBefore(T->getBaseType(), OS); 1606 1607 if (T->isKindOfTypeAsWritten()) 1608 OS << "__kindof "; 1609 1610 print(T->getBaseType(), OS, StringRef()); 1611 1612 if (T->isSpecializedAsWritten()) { 1613 bool isFirst = true; 1614 OS << '<'; 1615 for (auto typeArg : T->getTypeArgsAsWritten()) { 1616 if (isFirst) 1617 isFirst = false; 1618 else 1619 OS << ","; 1620 1621 print(typeArg, OS, StringRef()); 1622 } 1623 OS << '>'; 1624 } 1625 1626 if (!T->qual_empty()) { 1627 bool isFirst = true; 1628 OS << '<'; 1629 for (const auto *I : T->quals()) { 1630 if (isFirst) 1631 isFirst = false; 1632 else 1633 OS << ','; 1634 OS << I->getName(); 1635 } 1636 OS << '>'; 1637 } 1638 1639 spaceBeforePlaceHolder(OS); 1640 } 1641 1642 void TypePrinter::printObjCObjectAfter(const ObjCObjectType *T, 1643 raw_ostream &OS) { 1644 if (T->qual_empty() && T->isUnspecializedAsWritten() && 1645 !T->isKindOfTypeAsWritten()) 1646 return printAfter(T->getBaseType(), OS); 1647 } 1648 1649 void TypePrinter::printObjCObjectPointerBefore(const ObjCObjectPointerType *T, 1650 raw_ostream &OS) { 1651 printBefore(T->getPointeeType(), OS); 1652 1653 // If we need to print the pointer, print it now. 1654 if (!T->isObjCIdType() && !T->isObjCQualifiedIdType() && 1655 !T->isObjCClassType() && !T->isObjCQualifiedClassType()) { 1656 if (HasEmptyPlaceHolder) 1657 OS << ' '; 1658 OS << '*'; 1659 } 1660 } 1661 1662 void TypePrinter::printObjCObjectPointerAfter(const ObjCObjectPointerType *T, 1663 raw_ostream &OS) {} 1664 1665 static 1666 const TemplateArgument &getArgument(const TemplateArgument &A) { return A; } 1667 1668 static const TemplateArgument &getArgument(const TemplateArgumentLoc &A) { 1669 return A.getArgument(); 1670 } 1671 1672 static void printArgument(const TemplateArgument &A, const PrintingPolicy &PP, 1673 llvm::raw_ostream &OS) { 1674 A.print(PP, OS); 1675 } 1676 1677 static void printArgument(const TemplateArgumentLoc &A, 1678 const PrintingPolicy &PP, llvm::raw_ostream &OS) { 1679 const TemplateArgument::ArgKind &Kind = A.getArgument().getKind(); 1680 if (Kind == TemplateArgument::ArgKind::Type) 1681 return A.getTypeSourceInfo()->getType().print(OS, PP); 1682 return A.getArgument().print(PP, OS); 1683 } 1684 1685 template<typename TA> 1686 static void printTo(raw_ostream &OS, ArrayRef<TA> Args, 1687 const PrintingPolicy &Policy, bool SkipBrackets) { 1688 const char *Comma = Policy.MSVCFormatting ? "," : ", "; 1689 if (!SkipBrackets) 1690 OS << '<'; 1691 1692 bool NeedSpace = false; 1693 bool FirstArg = true; 1694 for (const auto &Arg : Args) { 1695 // Print the argument into a string. 1696 SmallString<128> Buf; 1697 llvm::raw_svector_ostream ArgOS(Buf); 1698 const TemplateArgument &Argument = getArgument(Arg); 1699 if (Argument.getKind() == TemplateArgument::Pack) { 1700 if (Argument.pack_size() && !FirstArg) 1701 OS << Comma; 1702 printTo(ArgOS, Argument.getPackAsArray(), Policy, true); 1703 } else { 1704 if (!FirstArg) 1705 OS << Comma; 1706 // Tries to print the argument with location info if exists. 1707 printArgument(Arg, Policy, ArgOS); 1708 } 1709 StringRef ArgString = ArgOS.str(); 1710 1711 // If this is the first argument and its string representation 1712 // begins with the global scope specifier ('::foo'), add a space 1713 // to avoid printing the diagraph '<:'. 1714 if (FirstArg && !ArgString.empty() && ArgString[0] == ':') 1715 OS << ' '; 1716 1717 OS << ArgString; 1718 1719 NeedSpace = (!ArgString.empty() && ArgString.back() == '>'); 1720 FirstArg = false; 1721 } 1722 1723 // If the last character of our string is '>', add another space to 1724 // keep the two '>''s separate tokens. We don't *have* to do this in 1725 // C++0x, but it's still good hygiene. 1726 if (NeedSpace) 1727 OS << ' '; 1728 1729 if (!SkipBrackets) 1730 OS << '>'; 1731 } 1732 1733 void clang::printTemplateArgumentList(raw_ostream &OS, 1734 const TemplateArgumentListInfo &Args, 1735 const PrintingPolicy &Policy) { 1736 return printTo(OS, Args.arguments(), Policy, false); 1737 } 1738 1739 void clang::printTemplateArgumentList(raw_ostream &OS, 1740 ArrayRef<TemplateArgument> Args, 1741 const PrintingPolicy &Policy) { 1742 printTo(OS, Args, Policy, false); 1743 } 1744 1745 void clang::printTemplateArgumentList(raw_ostream &OS, 1746 ArrayRef<TemplateArgumentLoc> Args, 1747 const PrintingPolicy &Policy) { 1748 printTo(OS, Args, Policy, false); 1749 } 1750 1751 std::string Qualifiers::getAsString() const { 1752 LangOptions LO; 1753 return getAsString(PrintingPolicy(LO)); 1754 } 1755 1756 // Appends qualifiers to the given string, separated by spaces. Will 1757 // prefix a space if the string is non-empty. Will not append a final 1758 // space. 1759 std::string Qualifiers::getAsString(const PrintingPolicy &Policy) const { 1760 SmallString<64> Buf; 1761 llvm::raw_svector_ostream StrOS(Buf); 1762 print(StrOS, Policy); 1763 return StrOS.str(); 1764 } 1765 1766 bool Qualifiers::isEmptyWhenPrinted(const PrintingPolicy &Policy) const { 1767 if (getCVRQualifiers()) 1768 return false; 1769 1770 if (getAddressSpace() != LangAS::Default) 1771 return false; 1772 1773 if (getObjCGCAttr()) 1774 return false; 1775 1776 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) 1777 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)) 1778 return false; 1779 1780 return true; 1781 } 1782 1783 std::string Qualifiers::getAddrSpaceAsString(LangAS AS) { 1784 switch (AS) { 1785 case LangAS::Default: 1786 return ""; 1787 case LangAS::opencl_global: 1788 return "__global"; 1789 case LangAS::opencl_local: 1790 return "__local"; 1791 case LangAS::opencl_private: 1792 return "__private"; 1793 case LangAS::opencl_constant: 1794 return "__constant"; 1795 case LangAS::opencl_generic: 1796 return "__generic"; 1797 case LangAS::cuda_device: 1798 return "__device__"; 1799 case LangAS::cuda_constant: 1800 return "__constant__"; 1801 case LangAS::cuda_shared: 1802 return "__shared__"; 1803 case LangAS::ptr32_sptr: 1804 return "__sptr __ptr32"; 1805 case LangAS::ptr32_uptr: 1806 return "__uptr __ptr32"; 1807 case LangAS::ptr64: 1808 return "__ptr64"; 1809 default: 1810 return std::to_string(toTargetAddressSpace(AS)); 1811 } 1812 } 1813 1814 // Appends qualifiers to the given string, separated by spaces. Will 1815 // prefix a space if the string is non-empty. Will not append a final 1816 // space. 1817 void Qualifiers::print(raw_ostream &OS, const PrintingPolicy& Policy, 1818 bool appendSpaceIfNonEmpty) const { 1819 bool addSpace = false; 1820 1821 unsigned quals = getCVRQualifiers(); 1822 if (quals) { 1823 AppendTypeQualList(OS, quals, Policy.Restrict); 1824 addSpace = true; 1825 } 1826 if (hasUnaligned()) { 1827 if (addSpace) 1828 OS << ' '; 1829 OS << "__unaligned"; 1830 addSpace = true; 1831 } 1832 auto ASStr = getAddrSpaceAsString(getAddressSpace()); 1833 if (!ASStr.empty()) { 1834 if (addSpace) 1835 OS << ' '; 1836 addSpace = true; 1837 // Wrap target address space into an attribute syntax 1838 if (isTargetAddressSpace(getAddressSpace())) 1839 OS << "__attribute__((address_space(" << ASStr << ")))"; 1840 else 1841 OS << ASStr; 1842 } 1843 1844 if (Qualifiers::GC gc = getObjCGCAttr()) { 1845 if (addSpace) 1846 OS << ' '; 1847 addSpace = true; 1848 if (gc == Qualifiers::Weak) 1849 OS << "__weak"; 1850 else 1851 OS << "__strong"; 1852 } 1853 if (Qualifiers::ObjCLifetime lifetime = getObjCLifetime()) { 1854 if (!(lifetime == Qualifiers::OCL_Strong && Policy.SuppressStrongLifetime)){ 1855 if (addSpace) 1856 OS << ' '; 1857 addSpace = true; 1858 } 1859 1860 switch (lifetime) { 1861 case Qualifiers::OCL_None: llvm_unreachable("none but true"); 1862 case Qualifiers::OCL_ExplicitNone: OS << "__unsafe_unretained"; break; 1863 case Qualifiers::OCL_Strong: 1864 if (!Policy.SuppressStrongLifetime) 1865 OS << "__strong"; 1866 break; 1867 1868 case Qualifiers::OCL_Weak: OS << "__weak"; break; 1869 case Qualifiers::OCL_Autoreleasing: OS << "__autoreleasing"; break; 1870 } 1871 } 1872 1873 if (appendSpaceIfNonEmpty && addSpace) 1874 OS << ' '; 1875 } 1876 1877 std::string QualType::getAsString() const { 1878 return getAsString(split(), LangOptions()); 1879 } 1880 1881 std::string QualType::getAsString(const PrintingPolicy &Policy) const { 1882 std::string S; 1883 getAsStringInternal(S, Policy); 1884 return S; 1885 } 1886 1887 std::string QualType::getAsString(const Type *ty, Qualifiers qs, 1888 const PrintingPolicy &Policy) { 1889 std::string buffer; 1890 getAsStringInternal(ty, qs, buffer, Policy); 1891 return buffer; 1892 } 1893 1894 void QualType::print(raw_ostream &OS, const PrintingPolicy &Policy, 1895 const Twine &PlaceHolder, unsigned Indentation) const { 1896 print(splitAccordingToPolicy(*this, Policy), OS, Policy, PlaceHolder, 1897 Indentation); 1898 } 1899 1900 void QualType::print(const Type *ty, Qualifiers qs, 1901 raw_ostream &OS, const PrintingPolicy &policy, 1902 const Twine &PlaceHolder, unsigned Indentation) { 1903 SmallString<128> PHBuf; 1904 StringRef PH = PlaceHolder.toStringRef(PHBuf); 1905 1906 TypePrinter(policy, Indentation).print(ty, qs, OS, PH); 1907 } 1908 1909 void QualType::getAsStringInternal(std::string &Str, 1910 const PrintingPolicy &Policy) const { 1911 return getAsStringInternal(splitAccordingToPolicy(*this, Policy), Str, 1912 Policy); 1913 } 1914 1915 void QualType::getAsStringInternal(const Type *ty, Qualifiers qs, 1916 std::string &buffer, 1917 const PrintingPolicy &policy) { 1918 SmallString<256> Buf; 1919 llvm::raw_svector_ostream StrOS(Buf); 1920 TypePrinter(policy).print(ty, qs, StrOS, buffer); 1921 std::string str = StrOS.str(); 1922 buffer.swap(str); 1923 } 1924