1//===- StmtPrinter.cpp - Printing implementation for Stmt ASTs ------------===// 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 file implements the Stmt::dumpPretty/Stmt::printPretty methods, which 10// pretty print the AST back out to C code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/Attr.h" 16#include "clang/AST/Decl.h" 17#include "clang/AST/DeclBase.h" 18#include "clang/AST/DeclCXX.h" 19#include "clang/AST/DeclObjC.h" 20#include "clang/AST/DeclOpenMP.h" 21#include "clang/AST/DeclTemplate.h" 22#include "clang/AST/Expr.h" 23#include "clang/AST/ExprCXX.h" 24#include "clang/AST/ExprObjC.h" 25#include "clang/AST/ExprOpenMP.h" 26#include "clang/AST/NestedNameSpecifier.h" 27#include "clang/AST/OpenMPClause.h" 28#include "clang/AST/PrettyPrinter.h" 29#include "clang/AST/Stmt.h" 30#include "clang/AST/StmtCXX.h" 31#include "clang/AST/StmtObjC.h" 32#include "clang/AST/StmtOpenMP.h" 33#include "clang/AST/StmtVisitor.h" 34#include "clang/AST/TemplateBase.h" 35#include "clang/AST/Type.h" 36#include "clang/Basic/CharInfo.h" 37#include "clang/Basic/ExpressionTraits.h" 38#include "clang/Basic/IdentifierTable.h" 39#include "clang/Basic/JsonSupport.h" 40#include "clang/Basic/LLVM.h" 41#include "clang/Basic/Lambda.h" 42#include "clang/Basic/OpenMPKinds.h" 43#include "clang/Basic/OperatorKinds.h" 44#include "clang/Basic/SourceLocation.h" 45#include "clang/Basic/TypeTraits.h" 46#include "clang/Lex/Lexer.h" 47#include "llvm/ADT/ArrayRef.h" 48#include "llvm/ADT/SmallString.h" 49#include "llvm/ADT/SmallVector.h" 50#include "llvm/ADT/StringExtras.h" 51#include "llvm/ADT/StringRef.h" 52#include "llvm/Support/Casting.h" 53#include "llvm/Support/Compiler.h" 54#include "llvm/Support/ErrorHandling.h" 55#include "llvm/Support/raw_ostream.h" 56#include <cassert> 57#include <optional> 58#include <string> 59 60using namespace clang; 61 62//===----------------------------------------------------------------------===// 63// StmtPrinter Visitor 64//===----------------------------------------------------------------------===// 65 66namespace { 67 68 class StmtPrinter : public StmtVisitor<StmtPrinter> { 69 raw_ostream &OS; 70 unsigned IndentLevel; 71 PrinterHelper* Helper; 72 PrintingPolicy Policy; 73 std::string NL; 74 const ASTContext *Context; 75 76 public: 77 StmtPrinter(raw_ostream &os, PrinterHelper *helper, 78 const PrintingPolicy &Policy, unsigned Indentation = 0, 79 StringRef NL = "\n", const ASTContext *Context = nullptr) 80 : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy), 81 NL(NL), Context(Context) {} 82 83 void PrintStmt(Stmt *S) { PrintStmt(S, Policy.Indentation); } 84 85 void PrintStmt(Stmt *S, int SubIndent) { 86 IndentLevel += SubIndent; 87 if (S && isa<Expr>(S)) { 88 // If this is an expr used in a stmt context, indent and newline it. 89 Indent(); 90 Visit(S); 91 OS << ";" << NL; 92 } else if (S) { 93 Visit(S); 94 } else { 95 Indent() << "<<<NULL STATEMENT>>>" << NL; 96 } 97 IndentLevel -= SubIndent; 98 } 99 100 void PrintInitStmt(Stmt *S, unsigned PrefixWidth) { 101 // FIXME: Cope better with odd prefix widths. 102 IndentLevel += (PrefixWidth + 1) / 2; 103 if (auto *DS = dyn_cast<DeclStmt>(S)) 104 PrintRawDeclStmt(DS); 105 else 106 PrintExpr(cast<Expr>(S)); 107 OS << "; "; 108 IndentLevel -= (PrefixWidth + 1) / 2; 109 } 110 111 void PrintControlledStmt(Stmt *S) { 112 if (auto *CS = dyn_cast<CompoundStmt>(S)) { 113 OS << " "; 114 PrintRawCompoundStmt(CS); 115 OS << NL; 116 } else { 117 OS << NL; 118 PrintStmt(S); 119 } 120 } 121 122 void PrintRawCompoundStmt(CompoundStmt *S); 123 void PrintRawDecl(Decl *D); 124 void PrintRawDeclStmt(const DeclStmt *S); 125 void PrintRawIfStmt(IfStmt *If); 126 void PrintRawCXXCatchStmt(CXXCatchStmt *Catch); 127 void PrintCallArgs(CallExpr *E); 128 void PrintRawSEHExceptHandler(SEHExceptStmt *S); 129 void PrintRawSEHFinallyStmt(SEHFinallyStmt *S); 130 void PrintOMPExecutableDirective(OMPExecutableDirective *S, 131 bool ForceNoStmt = false); 132 void PrintFPPragmas(CompoundStmt *S); 133 134 void PrintExpr(Expr *E) { 135 if (E) 136 Visit(E); 137 else 138 OS << "<null expr>"; 139 } 140 141 raw_ostream &Indent(int Delta = 0) { 142 for (int i = 0, e = IndentLevel+Delta; i < e; ++i) 143 OS << " "; 144 return OS; 145 } 146 147 void Visit(Stmt* S) { 148 if (Helper && Helper->handledStmt(S,OS)) 149 return; 150 else StmtVisitor<StmtPrinter>::Visit(S); 151 } 152 153 void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED { 154 Indent() << "<<unknown stmt type>>" << NL; 155 } 156 157 void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED { 158 OS << "<<unknown expr type>>"; 159 } 160 161 void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node); 162 163#define ABSTRACT_STMT(CLASS) 164#define STMT(CLASS, PARENT) \ 165 void Visit##CLASS(CLASS *Node); 166#include "clang/AST/StmtNodes.inc" 167 }; 168 169} // namespace 170 171//===----------------------------------------------------------------------===// 172// Stmt printing methods. 173//===----------------------------------------------------------------------===// 174 175/// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and 176/// with no newline after the }. 177void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) { 178 assert(Node && "Compound statement cannot be null"); 179 OS << "{" << NL; 180 PrintFPPragmas(Node); 181 for (auto *I : Node->body()) 182 PrintStmt(I); 183 184 Indent() << "}"; 185} 186 187void StmtPrinter::PrintFPPragmas(CompoundStmt *S) { 188 if (!S->hasStoredFPFeatures()) 189 return; 190 FPOptionsOverride FPO = S->getStoredFPFeatures(); 191 bool FEnvAccess = false; 192 if (FPO.hasAllowFEnvAccessOverride()) { 193 FEnvAccess = FPO.getAllowFEnvAccessOverride(); 194 Indent() << "#pragma STDC FENV_ACCESS " << (FEnvAccess ? "ON" : "OFF") 195 << NL; 196 } 197 if (FPO.hasSpecifiedExceptionModeOverride()) { 198 LangOptions::FPExceptionModeKind EM = 199 FPO.getSpecifiedExceptionModeOverride(); 200 if (!FEnvAccess || EM != LangOptions::FPE_Strict) { 201 Indent() << "#pragma clang fp exceptions("; 202 switch (FPO.getSpecifiedExceptionModeOverride()) { 203 default: 204 break; 205 case LangOptions::FPE_Ignore: 206 OS << "ignore"; 207 break; 208 case LangOptions::FPE_MayTrap: 209 OS << "maytrap"; 210 break; 211 case LangOptions::FPE_Strict: 212 OS << "strict"; 213 break; 214 } 215 OS << ")\n"; 216 } 217 } 218 if (FPO.hasConstRoundingModeOverride()) { 219 LangOptions::RoundingMode RM = FPO.getConstRoundingModeOverride(); 220 Indent() << "#pragma STDC FENV_ROUND "; 221 switch (RM) { 222 case llvm::RoundingMode::TowardZero: 223 OS << "FE_TOWARDZERO"; 224 break; 225 case llvm::RoundingMode::NearestTiesToEven: 226 OS << "FE_TONEAREST"; 227 break; 228 case llvm::RoundingMode::TowardPositive: 229 OS << "FE_UPWARD"; 230 break; 231 case llvm::RoundingMode::TowardNegative: 232 OS << "FE_DOWNWARD"; 233 break; 234 case llvm::RoundingMode::NearestTiesToAway: 235 OS << "FE_TONEARESTFROMZERO"; 236 break; 237 case llvm::RoundingMode::Dynamic: 238 OS << "FE_DYNAMIC"; 239 break; 240 default: 241 llvm_unreachable("Invalid rounding mode"); 242 } 243 OS << NL; 244 } 245} 246 247void StmtPrinter::PrintRawDecl(Decl *D) { 248 D->print(OS, Policy, IndentLevel); 249} 250 251void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) { 252 SmallVector<Decl *, 2> Decls(S->decls()); 253 Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel); 254} 255 256void StmtPrinter::VisitNullStmt(NullStmt *Node) { 257 Indent() << ";" << NL; 258} 259 260void StmtPrinter::VisitDeclStmt(DeclStmt *Node) { 261 Indent(); 262 PrintRawDeclStmt(Node); 263 OS << ";" << NL; 264} 265 266void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) { 267 Indent(); 268 PrintRawCompoundStmt(Node); 269 OS << "" << NL; 270} 271 272void StmtPrinter::VisitCaseStmt(CaseStmt *Node) { 273 Indent(-1) << "case "; 274 PrintExpr(Node->getLHS()); 275 if (Node->getRHS()) { 276 OS << " ... "; 277 PrintExpr(Node->getRHS()); 278 } 279 OS << ":" << NL; 280 281 PrintStmt(Node->getSubStmt(), 0); 282} 283 284void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) { 285 Indent(-1) << "default:" << NL; 286 PrintStmt(Node->getSubStmt(), 0); 287} 288 289void StmtPrinter::VisitLabelStmt(LabelStmt *Node) { 290 Indent(-1) << Node->getName() << ":" << NL; 291 PrintStmt(Node->getSubStmt(), 0); 292} 293 294void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) { 295 for (const auto *Attr : Node->getAttrs()) { 296 Attr->printPretty(OS, Policy); 297 } 298 299 PrintStmt(Node->getSubStmt(), 0); 300} 301 302void StmtPrinter::PrintRawIfStmt(IfStmt *If) { 303 if (If->isConsteval()) { 304 OS << "if "; 305 if (If->isNegatedConsteval()) 306 OS << "!"; 307 OS << "consteval"; 308 OS << NL; 309 PrintStmt(If->getThen()); 310 if (Stmt *Else = If->getElse()) { 311 Indent(); 312 OS << "else"; 313 PrintStmt(Else); 314 OS << NL; 315 } 316 return; 317 } 318 319 OS << "if ("; 320 if (If->getInit()) 321 PrintInitStmt(If->getInit(), 4); 322 if (const DeclStmt *DS = If->getConditionVariableDeclStmt()) 323 PrintRawDeclStmt(DS); 324 else 325 PrintExpr(If->getCond()); 326 OS << ')'; 327 328 if (auto *CS = dyn_cast<CompoundStmt>(If->getThen())) { 329 OS << ' '; 330 PrintRawCompoundStmt(CS); 331 OS << (If->getElse() ? " " : NL); 332 } else { 333 OS << NL; 334 PrintStmt(If->getThen()); 335 if (If->getElse()) Indent(); 336 } 337 338 if (Stmt *Else = If->getElse()) { 339 OS << "else"; 340 341 if (auto *CS = dyn_cast<CompoundStmt>(Else)) { 342 OS << ' '; 343 PrintRawCompoundStmt(CS); 344 OS << NL; 345 } else if (auto *ElseIf = dyn_cast<IfStmt>(Else)) { 346 OS << ' '; 347 PrintRawIfStmt(ElseIf); 348 } else { 349 OS << NL; 350 PrintStmt(If->getElse()); 351 } 352 } 353} 354 355void StmtPrinter::VisitIfStmt(IfStmt *If) { 356 Indent(); 357 PrintRawIfStmt(If); 358} 359 360void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) { 361 Indent() << "switch ("; 362 if (Node->getInit()) 363 PrintInitStmt(Node->getInit(), 8); 364 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt()) 365 PrintRawDeclStmt(DS); 366 else 367 PrintExpr(Node->getCond()); 368 OS << ")"; 369 PrintControlledStmt(Node->getBody()); 370} 371 372void StmtPrinter::VisitWhileStmt(WhileStmt *Node) { 373 Indent() << "while ("; 374 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt()) 375 PrintRawDeclStmt(DS); 376 else 377 PrintExpr(Node->getCond()); 378 OS << ")" << NL; 379 PrintStmt(Node->getBody()); 380} 381 382void StmtPrinter::VisitDoStmt(DoStmt *Node) { 383 Indent() << "do "; 384 if (auto *CS = dyn_cast<CompoundStmt>(Node->getBody())) { 385 PrintRawCompoundStmt(CS); 386 OS << " "; 387 } else { 388 OS << NL; 389 PrintStmt(Node->getBody()); 390 Indent(); 391 } 392 393 OS << "while ("; 394 PrintExpr(Node->getCond()); 395 OS << ");" << NL; 396} 397 398void StmtPrinter::VisitForStmt(ForStmt *Node) { 399 Indent() << "for ("; 400 if (Node->getInit()) 401 PrintInitStmt(Node->getInit(), 5); 402 else 403 OS << (Node->getCond() ? "; " : ";"); 404 if (const DeclStmt *DS = Node->getConditionVariableDeclStmt()) 405 PrintRawDeclStmt(DS); 406 else if (Node->getCond()) 407 PrintExpr(Node->getCond()); 408 OS << ";"; 409 if (Node->getInc()) { 410 OS << " "; 411 PrintExpr(Node->getInc()); 412 } 413 OS << ")"; 414 PrintControlledStmt(Node->getBody()); 415} 416 417void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) { 418 Indent() << "for ("; 419 if (auto *DS = dyn_cast<DeclStmt>(Node->getElement())) 420 PrintRawDeclStmt(DS); 421 else 422 PrintExpr(cast<Expr>(Node->getElement())); 423 OS << " in "; 424 PrintExpr(Node->getCollection()); 425 OS << ")"; 426 PrintControlledStmt(Node->getBody()); 427} 428 429void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) { 430 Indent() << "for ("; 431 if (Node->getInit()) 432 PrintInitStmt(Node->getInit(), 5); 433 PrintingPolicy SubPolicy(Policy); 434 SubPolicy.SuppressInitializers = true; 435 Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel); 436 OS << " : "; 437 PrintExpr(Node->getRangeInit()); 438 OS << ")"; 439 PrintControlledStmt(Node->getBody()); 440} 441 442void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) { 443 Indent(); 444 if (Node->isIfExists()) 445 OS << "__if_exists ("; 446 else 447 OS << "__if_not_exists ("; 448 449 if (NestedNameSpecifier *Qualifier 450 = Node->getQualifierLoc().getNestedNameSpecifier()) 451 Qualifier->print(OS, Policy); 452 453 OS << Node->getNameInfo() << ") "; 454 455 PrintRawCompoundStmt(Node->getSubStmt()); 456} 457 458void StmtPrinter::VisitGotoStmt(GotoStmt *Node) { 459 Indent() << "goto " << Node->getLabel()->getName() << ";"; 460 if (Policy.IncludeNewlines) OS << NL; 461} 462 463void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) { 464 Indent() << "goto *"; 465 PrintExpr(Node->getTarget()); 466 OS << ";"; 467 if (Policy.IncludeNewlines) OS << NL; 468} 469 470void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) { 471 Indent() << "continue;"; 472 if (Policy.IncludeNewlines) OS << NL; 473} 474 475void StmtPrinter::VisitBreakStmt(BreakStmt *Node) { 476 Indent() << "break;"; 477 if (Policy.IncludeNewlines) OS << NL; 478} 479 480void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) { 481 Indent() << "return"; 482 if (Node->getRetValue()) { 483 OS << " "; 484 PrintExpr(Node->getRetValue()); 485 } 486 OS << ";"; 487 if (Policy.IncludeNewlines) OS << NL; 488} 489 490void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) { 491 Indent() << "asm "; 492 493 if (Node->isVolatile()) 494 OS << "volatile "; 495 496 if (Node->isAsmGoto()) 497 OS << "goto "; 498 499 OS << "("; 500 VisitStringLiteral(Node->getAsmString()); 501 502 // Outputs 503 if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 || 504 Node->getNumClobbers() != 0 || Node->getNumLabels() != 0) 505 OS << " : "; 506 507 for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) { 508 if (i != 0) 509 OS << ", "; 510 511 if (!Node->getOutputName(i).empty()) { 512 OS << '['; 513 OS << Node->getOutputName(i); 514 OS << "] "; 515 } 516 517 VisitStringLiteral(Node->getOutputConstraintLiteral(i)); 518 OS << " ("; 519 Visit(Node->getOutputExpr(i)); 520 OS << ")"; 521 } 522 523 // Inputs 524 if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0 || 525 Node->getNumLabels() != 0) 526 OS << " : "; 527 528 for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) { 529 if (i != 0) 530 OS << ", "; 531 532 if (!Node->getInputName(i).empty()) { 533 OS << '['; 534 OS << Node->getInputName(i); 535 OS << "] "; 536 } 537 538 VisitStringLiteral(Node->getInputConstraintLiteral(i)); 539 OS << " ("; 540 Visit(Node->getInputExpr(i)); 541 OS << ")"; 542 } 543 544 // Clobbers 545 if (Node->getNumClobbers() != 0 || Node->getNumLabels()) 546 OS << " : "; 547 548 for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) { 549 if (i != 0) 550 OS << ", "; 551 552 VisitStringLiteral(Node->getClobberStringLiteral(i)); 553 } 554 555 // Labels 556 if (Node->getNumLabels() != 0) 557 OS << " : "; 558 559 for (unsigned i = 0, e = Node->getNumLabels(); i != e; ++i) { 560 if (i != 0) 561 OS << ", "; 562 OS << Node->getLabelName(i); 563 } 564 565 OS << ");"; 566 if (Policy.IncludeNewlines) OS << NL; 567} 568 569void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) { 570 // FIXME: Implement MS style inline asm statement printer. 571 Indent() << "__asm "; 572 if (Node->hasBraces()) 573 OS << "{" << NL; 574 OS << Node->getAsmString() << NL; 575 if (Node->hasBraces()) 576 Indent() << "}" << NL; 577} 578 579void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) { 580 PrintStmt(Node->getCapturedDecl()->getBody()); 581} 582 583void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) { 584 Indent() << "@try"; 585 if (auto *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) { 586 PrintRawCompoundStmt(TS); 587 OS << NL; 588 } 589 590 for (ObjCAtCatchStmt *catchStmt : Node->catch_stmts()) { 591 Indent() << "@catch("; 592 if (Decl *DS = catchStmt->getCatchParamDecl()) 593 PrintRawDecl(DS); 594 OS << ")"; 595 if (auto *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) { 596 PrintRawCompoundStmt(CS); 597 OS << NL; 598 } 599 } 600 601 if (auto *FS = static_cast<ObjCAtFinallyStmt *>(Node->getFinallyStmt())) { 602 Indent() << "@finally"; 603 if (auto *CS = dyn_cast<CompoundStmt>(FS->getFinallyBody())) { 604 PrintRawCompoundStmt(CS); 605 OS << NL; 606 } 607 } 608} 609 610void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) { 611} 612 613void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) { 614 Indent() << "@catch (...) { /* todo */ } " << NL; 615} 616 617void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) { 618 Indent() << "@throw"; 619 if (Node->getThrowExpr()) { 620 OS << " "; 621 PrintExpr(Node->getThrowExpr()); 622 } 623 OS << ";" << NL; 624} 625 626void StmtPrinter::VisitObjCAvailabilityCheckExpr( 627 ObjCAvailabilityCheckExpr *Node) { 628 OS << "@available(...)"; 629} 630 631void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) { 632 Indent() << "@synchronized ("; 633 PrintExpr(Node->getSynchExpr()); 634 OS << ")"; 635 PrintRawCompoundStmt(Node->getSynchBody()); 636 OS << NL; 637} 638 639void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) { 640 Indent() << "@autoreleasepool"; 641 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getSubStmt())); 642 OS << NL; 643} 644 645void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) { 646 OS << "catch ("; 647 if (Decl *ExDecl = Node->getExceptionDecl()) 648 PrintRawDecl(ExDecl); 649 else 650 OS << "..."; 651 OS << ") "; 652 PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock())); 653} 654 655void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) { 656 Indent(); 657 PrintRawCXXCatchStmt(Node); 658 OS << NL; 659} 660 661void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) { 662 Indent() << "try "; 663 PrintRawCompoundStmt(Node->getTryBlock()); 664 for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) { 665 OS << " "; 666 PrintRawCXXCatchStmt(Node->getHandler(i)); 667 } 668 OS << NL; 669} 670 671void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) { 672 Indent() << (Node->getIsCXXTry() ? "try " : "__try "); 673 PrintRawCompoundStmt(Node->getTryBlock()); 674 SEHExceptStmt *E = Node->getExceptHandler(); 675 SEHFinallyStmt *F = Node->getFinallyHandler(); 676 if(E) 677 PrintRawSEHExceptHandler(E); 678 else { 679 assert(F && "Must have a finally block..."); 680 PrintRawSEHFinallyStmt(F); 681 } 682 OS << NL; 683} 684 685void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) { 686 OS << "__finally "; 687 PrintRawCompoundStmt(Node->getBlock()); 688 OS << NL; 689} 690 691void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) { 692 OS << "__except ("; 693 VisitExpr(Node->getFilterExpr()); 694 OS << ")" << NL; 695 PrintRawCompoundStmt(Node->getBlock()); 696 OS << NL; 697} 698 699void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) { 700 Indent(); 701 PrintRawSEHExceptHandler(Node); 702 OS << NL; 703} 704 705void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) { 706 Indent(); 707 PrintRawSEHFinallyStmt(Node); 708 OS << NL; 709} 710 711void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) { 712 Indent() << "__leave;"; 713 if (Policy.IncludeNewlines) OS << NL; 714} 715 716//===----------------------------------------------------------------------===// 717// OpenMP directives printing methods 718//===----------------------------------------------------------------------===// 719 720void StmtPrinter::VisitOMPCanonicalLoop(OMPCanonicalLoop *Node) { 721 PrintStmt(Node->getLoopStmt()); 722} 723 724void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S, 725 bool ForceNoStmt) { 726 OMPClausePrinter Printer(OS, Policy); 727 ArrayRef<OMPClause *> Clauses = S->clauses(); 728 for (auto *Clause : Clauses) 729 if (Clause && !Clause->isImplicit()) { 730 OS << ' '; 731 Printer.Visit(Clause); 732 } 733 OS << NL; 734 if (!ForceNoStmt && S->hasAssociatedStmt()) 735 PrintStmt(S->getRawStmt()); 736} 737 738void StmtPrinter::VisitOMPMetaDirective(OMPMetaDirective *Node) { 739 Indent() << "#pragma omp metadirective"; 740 PrintOMPExecutableDirective(Node); 741} 742 743void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) { 744 Indent() << "#pragma omp parallel"; 745 PrintOMPExecutableDirective(Node); 746} 747 748void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) { 749 Indent() << "#pragma omp simd"; 750 PrintOMPExecutableDirective(Node); 751} 752 753void StmtPrinter::VisitOMPTileDirective(OMPTileDirective *Node) { 754 Indent() << "#pragma omp tile"; 755 PrintOMPExecutableDirective(Node); 756} 757 758void StmtPrinter::VisitOMPUnrollDirective(OMPUnrollDirective *Node) { 759 Indent() << "#pragma omp unroll"; 760 PrintOMPExecutableDirective(Node); 761} 762 763void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) { 764 Indent() << "#pragma omp for"; 765 PrintOMPExecutableDirective(Node); 766} 767 768void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) { 769 Indent() << "#pragma omp for simd"; 770 PrintOMPExecutableDirective(Node); 771} 772 773void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) { 774 Indent() << "#pragma omp sections"; 775 PrintOMPExecutableDirective(Node); 776} 777 778void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) { 779 Indent() << "#pragma omp section"; 780 PrintOMPExecutableDirective(Node); 781} 782 783void StmtPrinter::VisitOMPScopeDirective(OMPScopeDirective *Node) { 784 Indent() << "#pragma omp scope"; 785 PrintOMPExecutableDirective(Node); 786} 787 788void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) { 789 Indent() << "#pragma omp single"; 790 PrintOMPExecutableDirective(Node); 791} 792 793void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) { 794 Indent() << "#pragma omp master"; 795 PrintOMPExecutableDirective(Node); 796} 797 798void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) { 799 Indent() << "#pragma omp critical"; 800 if (Node->getDirectiveName().getName()) { 801 OS << " ("; 802 Node->getDirectiveName().printName(OS, Policy); 803 OS << ")"; 804 } 805 PrintOMPExecutableDirective(Node); 806} 807 808void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) { 809 Indent() << "#pragma omp parallel for"; 810 PrintOMPExecutableDirective(Node); 811} 812 813void StmtPrinter::VisitOMPParallelForSimdDirective( 814 OMPParallelForSimdDirective *Node) { 815 Indent() << "#pragma omp parallel for simd"; 816 PrintOMPExecutableDirective(Node); 817} 818 819void StmtPrinter::VisitOMPParallelMasterDirective( 820 OMPParallelMasterDirective *Node) { 821 Indent() << "#pragma omp parallel master"; 822 PrintOMPExecutableDirective(Node); 823} 824 825void StmtPrinter::VisitOMPParallelMaskedDirective( 826 OMPParallelMaskedDirective *Node) { 827 Indent() << "#pragma omp parallel masked"; 828 PrintOMPExecutableDirective(Node); 829} 830 831void StmtPrinter::VisitOMPParallelSectionsDirective( 832 OMPParallelSectionsDirective *Node) { 833 Indent() << "#pragma omp parallel sections"; 834 PrintOMPExecutableDirective(Node); 835} 836 837void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) { 838 Indent() << "#pragma omp task"; 839 PrintOMPExecutableDirective(Node); 840} 841 842void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) { 843 Indent() << "#pragma omp taskyield"; 844 PrintOMPExecutableDirective(Node); 845} 846 847void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) { 848 Indent() << "#pragma omp barrier"; 849 PrintOMPExecutableDirective(Node); 850} 851 852void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) { 853 Indent() << "#pragma omp taskwait"; 854 PrintOMPExecutableDirective(Node); 855} 856 857void StmtPrinter::VisitOMPErrorDirective(OMPErrorDirective *Node) { 858 Indent() << "#pragma omp error"; 859 PrintOMPExecutableDirective(Node); 860} 861 862void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) { 863 Indent() << "#pragma omp taskgroup"; 864 PrintOMPExecutableDirective(Node); 865} 866 867void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) { 868 Indent() << "#pragma omp flush"; 869 PrintOMPExecutableDirective(Node); 870} 871 872void StmtPrinter::VisitOMPDepobjDirective(OMPDepobjDirective *Node) { 873 Indent() << "#pragma omp depobj"; 874 PrintOMPExecutableDirective(Node); 875} 876 877void StmtPrinter::VisitOMPScanDirective(OMPScanDirective *Node) { 878 Indent() << "#pragma omp scan"; 879 PrintOMPExecutableDirective(Node); 880} 881 882void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) { 883 Indent() << "#pragma omp ordered"; 884 PrintOMPExecutableDirective(Node, Node->hasClausesOfKind<OMPDependClause>()); 885} 886 887void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) { 888 Indent() << "#pragma omp atomic"; 889 PrintOMPExecutableDirective(Node); 890} 891 892void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) { 893 Indent() << "#pragma omp target"; 894 PrintOMPExecutableDirective(Node); 895} 896 897void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) { 898 Indent() << "#pragma omp target data"; 899 PrintOMPExecutableDirective(Node); 900} 901 902void StmtPrinter::VisitOMPTargetEnterDataDirective( 903 OMPTargetEnterDataDirective *Node) { 904 Indent() << "#pragma omp target enter data"; 905 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true); 906} 907 908void StmtPrinter::VisitOMPTargetExitDataDirective( 909 OMPTargetExitDataDirective *Node) { 910 Indent() << "#pragma omp target exit data"; 911 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true); 912} 913 914void StmtPrinter::VisitOMPTargetParallelDirective( 915 OMPTargetParallelDirective *Node) { 916 Indent() << "#pragma omp target parallel"; 917 PrintOMPExecutableDirective(Node); 918} 919 920void StmtPrinter::VisitOMPTargetParallelForDirective( 921 OMPTargetParallelForDirective *Node) { 922 Indent() << "#pragma omp target parallel for"; 923 PrintOMPExecutableDirective(Node); 924} 925 926void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) { 927 Indent() << "#pragma omp teams"; 928 PrintOMPExecutableDirective(Node); 929} 930 931void StmtPrinter::VisitOMPCancellationPointDirective( 932 OMPCancellationPointDirective *Node) { 933 Indent() << "#pragma omp cancellation point " 934 << getOpenMPDirectiveName(Node->getCancelRegion()); 935 PrintOMPExecutableDirective(Node); 936} 937 938void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) { 939 Indent() << "#pragma omp cancel " 940 << getOpenMPDirectiveName(Node->getCancelRegion()); 941 PrintOMPExecutableDirective(Node); 942} 943 944void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) { 945 Indent() << "#pragma omp taskloop"; 946 PrintOMPExecutableDirective(Node); 947} 948 949void StmtPrinter::VisitOMPTaskLoopSimdDirective( 950 OMPTaskLoopSimdDirective *Node) { 951 Indent() << "#pragma omp taskloop simd"; 952 PrintOMPExecutableDirective(Node); 953} 954 955void StmtPrinter::VisitOMPMasterTaskLoopDirective( 956 OMPMasterTaskLoopDirective *Node) { 957 Indent() << "#pragma omp master taskloop"; 958 PrintOMPExecutableDirective(Node); 959} 960 961void StmtPrinter::VisitOMPMaskedTaskLoopDirective( 962 OMPMaskedTaskLoopDirective *Node) { 963 Indent() << "#pragma omp masked taskloop"; 964 PrintOMPExecutableDirective(Node); 965} 966 967void StmtPrinter::VisitOMPMasterTaskLoopSimdDirective( 968 OMPMasterTaskLoopSimdDirective *Node) { 969 Indent() << "#pragma omp master taskloop simd"; 970 PrintOMPExecutableDirective(Node); 971} 972 973void StmtPrinter::VisitOMPMaskedTaskLoopSimdDirective( 974 OMPMaskedTaskLoopSimdDirective *Node) { 975 Indent() << "#pragma omp masked taskloop simd"; 976 PrintOMPExecutableDirective(Node); 977} 978 979void StmtPrinter::VisitOMPParallelMasterTaskLoopDirective( 980 OMPParallelMasterTaskLoopDirective *Node) { 981 Indent() << "#pragma omp parallel master taskloop"; 982 PrintOMPExecutableDirective(Node); 983} 984 985void StmtPrinter::VisitOMPParallelMaskedTaskLoopDirective( 986 OMPParallelMaskedTaskLoopDirective *Node) { 987 Indent() << "#pragma omp parallel masked taskloop"; 988 PrintOMPExecutableDirective(Node); 989} 990 991void StmtPrinter::VisitOMPParallelMasterTaskLoopSimdDirective( 992 OMPParallelMasterTaskLoopSimdDirective *Node) { 993 Indent() << "#pragma omp parallel master taskloop simd"; 994 PrintOMPExecutableDirective(Node); 995} 996 997void StmtPrinter::VisitOMPParallelMaskedTaskLoopSimdDirective( 998 OMPParallelMaskedTaskLoopSimdDirective *Node) { 999 Indent() << "#pragma omp parallel masked taskloop simd"; 1000 PrintOMPExecutableDirective(Node); 1001} 1002 1003void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) { 1004 Indent() << "#pragma omp distribute"; 1005 PrintOMPExecutableDirective(Node); 1006} 1007 1008void StmtPrinter::VisitOMPTargetUpdateDirective( 1009 OMPTargetUpdateDirective *Node) { 1010 Indent() << "#pragma omp target update"; 1011 PrintOMPExecutableDirective(Node, /*ForceNoStmt=*/true); 1012} 1013 1014void StmtPrinter::VisitOMPDistributeParallelForDirective( 1015 OMPDistributeParallelForDirective *Node) { 1016 Indent() << "#pragma omp distribute parallel for"; 1017 PrintOMPExecutableDirective(Node); 1018} 1019 1020void StmtPrinter::VisitOMPDistributeParallelForSimdDirective( 1021 OMPDistributeParallelForSimdDirective *Node) { 1022 Indent() << "#pragma omp distribute parallel for simd"; 1023 PrintOMPExecutableDirective(Node); 1024} 1025 1026void StmtPrinter::VisitOMPDistributeSimdDirective( 1027 OMPDistributeSimdDirective *Node) { 1028 Indent() << "#pragma omp distribute simd"; 1029 PrintOMPExecutableDirective(Node); 1030} 1031 1032void StmtPrinter::VisitOMPTargetParallelForSimdDirective( 1033 OMPTargetParallelForSimdDirective *Node) { 1034 Indent() << "#pragma omp target parallel for simd"; 1035 PrintOMPExecutableDirective(Node); 1036} 1037 1038void StmtPrinter::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *Node) { 1039 Indent() << "#pragma omp target simd"; 1040 PrintOMPExecutableDirective(Node); 1041} 1042 1043void StmtPrinter::VisitOMPTeamsDistributeDirective( 1044 OMPTeamsDistributeDirective *Node) { 1045 Indent() << "#pragma omp teams distribute"; 1046 PrintOMPExecutableDirective(Node); 1047} 1048 1049void StmtPrinter::VisitOMPTeamsDistributeSimdDirective( 1050 OMPTeamsDistributeSimdDirective *Node) { 1051 Indent() << "#pragma omp teams distribute simd"; 1052 PrintOMPExecutableDirective(Node); 1053} 1054 1055void StmtPrinter::VisitOMPTeamsDistributeParallelForSimdDirective( 1056 OMPTeamsDistributeParallelForSimdDirective *Node) { 1057 Indent() << "#pragma omp teams distribute parallel for simd"; 1058 PrintOMPExecutableDirective(Node); 1059} 1060 1061void StmtPrinter::VisitOMPTeamsDistributeParallelForDirective( 1062 OMPTeamsDistributeParallelForDirective *Node) { 1063 Indent() << "#pragma omp teams distribute parallel for"; 1064 PrintOMPExecutableDirective(Node); 1065} 1066 1067void StmtPrinter::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *Node) { 1068 Indent() << "#pragma omp target teams"; 1069 PrintOMPExecutableDirective(Node); 1070} 1071 1072void StmtPrinter::VisitOMPTargetTeamsDistributeDirective( 1073 OMPTargetTeamsDistributeDirective *Node) { 1074 Indent() << "#pragma omp target teams distribute"; 1075 PrintOMPExecutableDirective(Node); 1076} 1077 1078void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForDirective( 1079 OMPTargetTeamsDistributeParallelForDirective *Node) { 1080 Indent() << "#pragma omp target teams distribute parallel for"; 1081 PrintOMPExecutableDirective(Node); 1082} 1083 1084void StmtPrinter::VisitOMPTargetTeamsDistributeParallelForSimdDirective( 1085 OMPTargetTeamsDistributeParallelForSimdDirective *Node) { 1086 Indent() << "#pragma omp target teams distribute parallel for simd"; 1087 PrintOMPExecutableDirective(Node); 1088} 1089 1090void StmtPrinter::VisitOMPTargetTeamsDistributeSimdDirective( 1091 OMPTargetTeamsDistributeSimdDirective *Node) { 1092 Indent() << "#pragma omp target teams distribute simd"; 1093 PrintOMPExecutableDirective(Node); 1094} 1095 1096void StmtPrinter::VisitOMPInteropDirective(OMPInteropDirective *Node) { 1097 Indent() << "#pragma omp interop"; 1098 PrintOMPExecutableDirective(Node); 1099} 1100 1101void StmtPrinter::VisitOMPDispatchDirective(OMPDispatchDirective *Node) { 1102 Indent() << "#pragma omp dispatch"; 1103 PrintOMPExecutableDirective(Node); 1104} 1105 1106void StmtPrinter::VisitOMPMaskedDirective(OMPMaskedDirective *Node) { 1107 Indent() << "#pragma omp masked"; 1108 PrintOMPExecutableDirective(Node); 1109} 1110 1111void StmtPrinter::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *Node) { 1112 Indent() << "#pragma omp loop"; 1113 PrintOMPExecutableDirective(Node); 1114} 1115 1116void StmtPrinter::VisitOMPTeamsGenericLoopDirective( 1117 OMPTeamsGenericLoopDirective *Node) { 1118 Indent() << "#pragma omp teams loop"; 1119 PrintOMPExecutableDirective(Node); 1120} 1121 1122void StmtPrinter::VisitOMPTargetTeamsGenericLoopDirective( 1123 OMPTargetTeamsGenericLoopDirective *Node) { 1124 Indent() << "#pragma omp target teams loop"; 1125 PrintOMPExecutableDirective(Node); 1126} 1127 1128void StmtPrinter::VisitOMPParallelGenericLoopDirective( 1129 OMPParallelGenericLoopDirective *Node) { 1130 Indent() << "#pragma omp parallel loop"; 1131 PrintOMPExecutableDirective(Node); 1132} 1133 1134void StmtPrinter::VisitOMPTargetParallelGenericLoopDirective( 1135 OMPTargetParallelGenericLoopDirective *Node) { 1136 Indent() << "#pragma omp target parallel loop"; 1137 PrintOMPExecutableDirective(Node); 1138} 1139 1140//===----------------------------------------------------------------------===// 1141// Expr printing methods. 1142//===----------------------------------------------------------------------===// 1143 1144void StmtPrinter::VisitSourceLocExpr(SourceLocExpr *Node) { 1145 OS << Node->getBuiltinStr() << "()"; 1146} 1147 1148void StmtPrinter::VisitConstantExpr(ConstantExpr *Node) { 1149 PrintExpr(Node->getSubExpr()); 1150} 1151 1152void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) { 1153 if (const auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) { 1154 OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy); 1155 return; 1156 } 1157 if (const auto *TPOD = dyn_cast<TemplateParamObjectDecl>(Node->getDecl())) { 1158 TPOD->printAsExpr(OS, Policy); 1159 return; 1160 } 1161 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 1162 Qualifier->print(OS, Policy); 1163 if (Node->hasTemplateKeyword()) 1164 OS << "template "; 1165 if (Policy.CleanUglifiedParameters && 1166 isa<ParmVarDecl, NonTypeTemplateParmDecl>(Node->getDecl()) && 1167 Node->getDecl()->getIdentifier()) 1168 OS << Node->getDecl()->getIdentifier()->deuglifiedName(); 1169 else 1170 Node->getNameInfo().printName(OS, Policy); 1171 if (Node->hasExplicitTemplateArgs()) { 1172 const TemplateParameterList *TPL = nullptr; 1173 if (!Node->hadMultipleCandidates()) 1174 if (auto *TD = dyn_cast<TemplateDecl>(Node->getDecl())) 1175 TPL = TD->getTemplateParameters(); 1176 printTemplateArgumentList(OS, Node->template_arguments(), Policy, TPL); 1177 } 1178} 1179 1180void StmtPrinter::VisitDependentScopeDeclRefExpr( 1181 DependentScopeDeclRefExpr *Node) { 1182 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 1183 Qualifier->print(OS, Policy); 1184 if (Node->hasTemplateKeyword()) 1185 OS << "template "; 1186 OS << Node->getNameInfo(); 1187 if (Node->hasExplicitTemplateArgs()) 1188 printTemplateArgumentList(OS, Node->template_arguments(), Policy); 1189} 1190 1191void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) { 1192 if (Node->getQualifier()) 1193 Node->getQualifier()->print(OS, Policy); 1194 if (Node->hasTemplateKeyword()) 1195 OS << "template "; 1196 OS << Node->getNameInfo(); 1197 if (Node->hasExplicitTemplateArgs()) 1198 printTemplateArgumentList(OS, Node->template_arguments(), Policy); 1199} 1200 1201static bool isImplicitSelf(const Expr *E) { 1202 if (const auto *DRE = dyn_cast<DeclRefExpr>(E)) { 1203 if (const auto *PD = dyn_cast<ImplicitParamDecl>(DRE->getDecl())) { 1204 if (PD->getParameterKind() == ImplicitParamKind::ObjCSelf && 1205 DRE->getBeginLoc().isInvalid()) 1206 return true; 1207 } 1208 } 1209 return false; 1210} 1211 1212void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) { 1213 if (Node->getBase()) { 1214 if (!Policy.SuppressImplicitBase || 1215 !isImplicitSelf(Node->getBase()->IgnoreImpCasts())) { 1216 PrintExpr(Node->getBase()); 1217 OS << (Node->isArrow() ? "->" : "."); 1218 } 1219 } 1220 OS << *Node->getDecl(); 1221} 1222 1223void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) { 1224 if (Node->isSuperReceiver()) 1225 OS << "super."; 1226 else if (Node->isObjectReceiver() && Node->getBase()) { 1227 PrintExpr(Node->getBase()); 1228 OS << "."; 1229 } else if (Node->isClassReceiver() && Node->getClassReceiver()) { 1230 OS << Node->getClassReceiver()->getName() << "."; 1231 } 1232 1233 if (Node->isImplicitProperty()) { 1234 if (const auto *Getter = Node->getImplicitPropertyGetter()) 1235 Getter->getSelector().print(OS); 1236 else 1237 OS << SelectorTable::getPropertyNameFromSetterSelector( 1238 Node->getImplicitPropertySetter()->getSelector()); 1239 } else 1240 OS << Node->getExplicitProperty()->getName(); 1241} 1242 1243void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) { 1244 PrintExpr(Node->getBaseExpr()); 1245 OS << "["; 1246 PrintExpr(Node->getKeyExpr()); 1247 OS << "]"; 1248} 1249 1250void StmtPrinter::VisitSYCLUniqueStableNameExpr( 1251 SYCLUniqueStableNameExpr *Node) { 1252 OS << "__builtin_sycl_unique_stable_name("; 1253 Node->getTypeSourceInfo()->getType().print(OS, Policy); 1254 OS << ")"; 1255} 1256 1257void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) { 1258 OS << PredefinedExpr::getIdentKindName(Node->getIdentKind()); 1259} 1260 1261void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) { 1262 CharacterLiteral::print(Node->getValue(), Node->getKind(), OS); 1263} 1264 1265/// Prints the given expression using the original source text. Returns true on 1266/// success, false otherwise. 1267static bool printExprAsWritten(raw_ostream &OS, Expr *E, 1268 const ASTContext *Context) { 1269 if (!Context) 1270 return false; 1271 bool Invalid = false; 1272 StringRef Source = Lexer::getSourceText( 1273 CharSourceRange::getTokenRange(E->getSourceRange()), 1274 Context->getSourceManager(), Context->getLangOpts(), &Invalid); 1275 if (!Invalid) { 1276 OS << Source; 1277 return true; 1278 } 1279 return false; 1280} 1281 1282void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) { 1283 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context)) 1284 return; 1285 bool isSigned = Node->getType()->isSignedIntegerType(); 1286 OS << toString(Node->getValue(), 10, isSigned); 1287 1288 if (isa<BitIntType>(Node->getType())) { 1289 OS << (isSigned ? "wb" : "uwb"); 1290 return; 1291 } 1292 1293 // Emit suffixes. Integer literals are always a builtin integer type. 1294 switch (Node->getType()->castAs<BuiltinType>()->getKind()) { 1295 default: llvm_unreachable("Unexpected type for integer literal!"); 1296 case BuiltinType::Char_S: 1297 case BuiltinType::Char_U: OS << "i8"; break; 1298 case BuiltinType::UChar: OS << "Ui8"; break; 1299 case BuiltinType::SChar: OS << "i8"; break; 1300 case BuiltinType::Short: OS << "i16"; break; 1301 case BuiltinType::UShort: OS << "Ui16"; break; 1302 case BuiltinType::Int: break; // no suffix. 1303 case BuiltinType::UInt: OS << 'U'; break; 1304 case BuiltinType::Long: OS << 'L'; break; 1305 case BuiltinType::ULong: OS << "UL"; break; 1306 case BuiltinType::LongLong: OS << "LL"; break; 1307 case BuiltinType::ULongLong: OS << "ULL"; break; 1308 case BuiltinType::Int128: 1309 break; // no suffix. 1310 case BuiltinType::UInt128: 1311 break; // no suffix. 1312 case BuiltinType::WChar_S: 1313 case BuiltinType::WChar_U: 1314 break; // no suffix 1315 } 1316} 1317 1318void StmtPrinter::VisitFixedPointLiteral(FixedPointLiteral *Node) { 1319 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context)) 1320 return; 1321 OS << Node->getValueAsString(/*Radix=*/10); 1322 1323 switch (Node->getType()->castAs<BuiltinType>()->getKind()) { 1324 default: llvm_unreachable("Unexpected type for fixed point literal!"); 1325 case BuiltinType::ShortFract: OS << "hr"; break; 1326 case BuiltinType::ShortAccum: OS << "hk"; break; 1327 case BuiltinType::UShortFract: OS << "uhr"; break; 1328 case BuiltinType::UShortAccum: OS << "uhk"; break; 1329 case BuiltinType::Fract: OS << "r"; break; 1330 case BuiltinType::Accum: OS << "k"; break; 1331 case BuiltinType::UFract: OS << "ur"; break; 1332 case BuiltinType::UAccum: OS << "uk"; break; 1333 case BuiltinType::LongFract: OS << "lr"; break; 1334 case BuiltinType::LongAccum: OS << "lk"; break; 1335 case BuiltinType::ULongFract: OS << "ulr"; break; 1336 case BuiltinType::ULongAccum: OS << "ulk"; break; 1337 } 1338} 1339 1340static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node, 1341 bool PrintSuffix) { 1342 SmallString<16> Str; 1343 Node->getValue().toString(Str); 1344 OS << Str; 1345 if (Str.find_first_not_of("-0123456789") == StringRef::npos) 1346 OS << '.'; // Trailing dot in order to separate from ints. 1347 1348 if (!PrintSuffix) 1349 return; 1350 1351 // Emit suffixes. Float literals are always a builtin float type. 1352 switch (Node->getType()->castAs<BuiltinType>()->getKind()) { 1353 default: llvm_unreachable("Unexpected type for float literal!"); 1354 case BuiltinType::Half: break; // FIXME: suffix? 1355 case BuiltinType::Ibm128: break; // FIXME: No suffix for ibm128 literal 1356 case BuiltinType::Double: break; // no suffix. 1357 case BuiltinType::Float16: OS << "F16"; break; 1358 case BuiltinType::Float: OS << 'F'; break; 1359 case BuiltinType::LongDouble: OS << 'L'; break; 1360 case BuiltinType::Float128: OS << 'Q'; break; 1361 } 1362} 1363 1364void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) { 1365 if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context)) 1366 return; 1367 PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true); 1368} 1369 1370void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) { 1371 PrintExpr(Node->getSubExpr()); 1372 OS << "i"; 1373} 1374 1375void StmtPrinter::VisitStringLiteral(StringLiteral *Str) { 1376 Str->outputString(OS); 1377} 1378 1379void StmtPrinter::VisitParenExpr(ParenExpr *Node) { 1380 OS << "("; 1381 PrintExpr(Node->getSubExpr()); 1382 OS << ")"; 1383} 1384 1385void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) { 1386 if (!Node->isPostfix()) { 1387 OS << UnaryOperator::getOpcodeStr(Node->getOpcode()); 1388 1389 // Print a space if this is an "identifier operator" like __real, or if 1390 // it might be concatenated incorrectly like '+'. 1391 switch (Node->getOpcode()) { 1392 default: break; 1393 case UO_Real: 1394 case UO_Imag: 1395 case UO_Extension: 1396 OS << ' '; 1397 break; 1398 case UO_Plus: 1399 case UO_Minus: 1400 if (isa<UnaryOperator>(Node->getSubExpr())) 1401 OS << ' '; 1402 break; 1403 } 1404 } 1405 PrintExpr(Node->getSubExpr()); 1406 1407 if (Node->isPostfix()) 1408 OS << UnaryOperator::getOpcodeStr(Node->getOpcode()); 1409} 1410 1411void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) { 1412 OS << "__builtin_offsetof("; 1413 Node->getTypeSourceInfo()->getType().print(OS, Policy); 1414 OS << ", "; 1415 bool PrintedSomething = false; 1416 for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) { 1417 OffsetOfNode ON = Node->getComponent(i); 1418 if (ON.getKind() == OffsetOfNode::Array) { 1419 // Array node 1420 OS << "["; 1421 PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex())); 1422 OS << "]"; 1423 PrintedSomething = true; 1424 continue; 1425 } 1426 1427 // Skip implicit base indirections. 1428 if (ON.getKind() == OffsetOfNode::Base) 1429 continue; 1430 1431 // Field or identifier node. 1432 IdentifierInfo *Id = ON.getFieldName(); 1433 if (!Id) 1434 continue; 1435 1436 if (PrintedSomething) 1437 OS << "."; 1438 else 1439 PrintedSomething = true; 1440 OS << Id->getName(); 1441 } 1442 OS << ")"; 1443} 1444 1445void StmtPrinter::VisitUnaryExprOrTypeTraitExpr( 1446 UnaryExprOrTypeTraitExpr *Node) { 1447 const char *Spelling = getTraitSpelling(Node->getKind()); 1448 if (Node->getKind() == UETT_AlignOf) { 1449 if (Policy.Alignof) 1450 Spelling = "alignof"; 1451 else if (Policy.UnderscoreAlignof) 1452 Spelling = "_Alignof"; 1453 else 1454 Spelling = "__alignof"; 1455 } 1456 1457 OS << Spelling; 1458 1459 if (Node->isArgumentType()) { 1460 OS << '('; 1461 Node->getArgumentType().print(OS, Policy); 1462 OS << ')'; 1463 } else { 1464 OS << " "; 1465 PrintExpr(Node->getArgumentExpr()); 1466 } 1467} 1468 1469void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) { 1470 OS << "_Generic("; 1471 if (Node->isExprPredicate()) 1472 PrintExpr(Node->getControllingExpr()); 1473 else 1474 Node->getControllingType()->getType().print(OS, Policy); 1475 1476 for (const GenericSelectionExpr::Association &Assoc : Node->associations()) { 1477 OS << ", "; 1478 QualType T = Assoc.getType(); 1479 if (T.isNull()) 1480 OS << "default"; 1481 else 1482 T.print(OS, Policy); 1483 OS << ": "; 1484 PrintExpr(Assoc.getAssociationExpr()); 1485 } 1486 OS << ")"; 1487} 1488 1489void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) { 1490 PrintExpr(Node->getLHS()); 1491 OS << "["; 1492 PrintExpr(Node->getRHS()); 1493 OS << "]"; 1494} 1495 1496void StmtPrinter::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *Node) { 1497 PrintExpr(Node->getBase()); 1498 OS << "["; 1499 PrintExpr(Node->getRowIdx()); 1500 OS << "]"; 1501 OS << "["; 1502 PrintExpr(Node->getColumnIdx()); 1503 OS << "]"; 1504} 1505 1506void StmtPrinter::VisitOMPArraySectionExpr(OMPArraySectionExpr *Node) { 1507 PrintExpr(Node->getBase()); 1508 OS << "["; 1509 if (Node->getLowerBound()) 1510 PrintExpr(Node->getLowerBound()); 1511 if (Node->getColonLocFirst().isValid()) { 1512 OS << ":"; 1513 if (Node->getLength()) 1514 PrintExpr(Node->getLength()); 1515 } 1516 if (Node->getColonLocSecond().isValid()) { 1517 OS << ":"; 1518 if (Node->getStride()) 1519 PrintExpr(Node->getStride()); 1520 } 1521 OS << "]"; 1522} 1523 1524void StmtPrinter::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *Node) { 1525 OS << "("; 1526 for (Expr *E : Node->getDimensions()) { 1527 OS << "["; 1528 PrintExpr(E); 1529 OS << "]"; 1530 } 1531 OS << ")"; 1532 PrintExpr(Node->getBase()); 1533} 1534 1535void StmtPrinter::VisitOMPIteratorExpr(OMPIteratorExpr *Node) { 1536 OS << "iterator("; 1537 for (unsigned I = 0, E = Node->numOfIterators(); I < E; ++I) { 1538 auto *VD = cast<ValueDecl>(Node->getIteratorDecl(I)); 1539 VD->getType().print(OS, Policy); 1540 const OMPIteratorExpr::IteratorRange Range = Node->getIteratorRange(I); 1541 OS << " " << VD->getName() << " = "; 1542 PrintExpr(Range.Begin); 1543 OS << ":"; 1544 PrintExpr(Range.End); 1545 if (Range.Step) { 1546 OS << ":"; 1547 PrintExpr(Range.Step); 1548 } 1549 if (I < E - 1) 1550 OS << ", "; 1551 } 1552 OS << ")"; 1553} 1554 1555void StmtPrinter::PrintCallArgs(CallExpr *Call) { 1556 for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) { 1557 if (isa<CXXDefaultArgExpr>(Call->getArg(i))) { 1558 // Don't print any defaulted arguments 1559 break; 1560 } 1561 1562 if (i) OS << ", "; 1563 PrintExpr(Call->getArg(i)); 1564 } 1565} 1566 1567void StmtPrinter::VisitCallExpr(CallExpr *Call) { 1568 PrintExpr(Call->getCallee()); 1569 OS << "("; 1570 PrintCallArgs(Call); 1571 OS << ")"; 1572} 1573 1574static bool isImplicitThis(const Expr *E) { 1575 if (const auto *TE = dyn_cast<CXXThisExpr>(E)) 1576 return TE->isImplicit(); 1577 return false; 1578} 1579 1580void StmtPrinter::VisitMemberExpr(MemberExpr *Node) { 1581 if (!Policy.SuppressImplicitBase || !isImplicitThis(Node->getBase())) { 1582 PrintExpr(Node->getBase()); 1583 1584 auto *ParentMember = dyn_cast<MemberExpr>(Node->getBase()); 1585 FieldDecl *ParentDecl = 1586 ParentMember ? dyn_cast<FieldDecl>(ParentMember->getMemberDecl()) 1587 : nullptr; 1588 1589 if (!ParentDecl || !ParentDecl->isAnonymousStructOrUnion()) 1590 OS << (Node->isArrow() ? "->" : "."); 1591 } 1592 1593 if (auto *FD = dyn_cast<FieldDecl>(Node->getMemberDecl())) 1594 if (FD->isAnonymousStructOrUnion()) 1595 return; 1596 1597 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 1598 Qualifier->print(OS, Policy); 1599 if (Node->hasTemplateKeyword()) 1600 OS << "template "; 1601 OS << Node->getMemberNameInfo(); 1602 const TemplateParameterList *TPL = nullptr; 1603 if (auto *FD = dyn_cast<FunctionDecl>(Node->getMemberDecl())) { 1604 if (!Node->hadMultipleCandidates()) 1605 if (auto *FTD = FD->getPrimaryTemplate()) 1606 TPL = FTD->getTemplateParameters(); 1607 } else if (auto *VTSD = 1608 dyn_cast<VarTemplateSpecializationDecl>(Node->getMemberDecl())) 1609 TPL = VTSD->getSpecializedTemplate()->getTemplateParameters(); 1610 if (Node->hasExplicitTemplateArgs()) 1611 printTemplateArgumentList(OS, Node->template_arguments(), Policy, TPL); 1612} 1613 1614void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) { 1615 PrintExpr(Node->getBase()); 1616 OS << (Node->isArrow() ? "->isa" : ".isa"); 1617} 1618 1619void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) { 1620 PrintExpr(Node->getBase()); 1621 OS << "."; 1622 OS << Node->getAccessor().getName(); 1623} 1624 1625void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) { 1626 OS << '('; 1627 Node->getTypeAsWritten().print(OS, Policy); 1628 OS << ')'; 1629 PrintExpr(Node->getSubExpr()); 1630} 1631 1632void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) { 1633 OS << '('; 1634 Node->getType().print(OS, Policy); 1635 OS << ')'; 1636 PrintExpr(Node->getInitializer()); 1637} 1638 1639void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) { 1640 // No need to print anything, simply forward to the subexpression. 1641 PrintExpr(Node->getSubExpr()); 1642} 1643 1644void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) { 1645 PrintExpr(Node->getLHS()); 1646 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " "; 1647 PrintExpr(Node->getRHS()); 1648} 1649 1650void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) { 1651 PrintExpr(Node->getLHS()); 1652 OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " "; 1653 PrintExpr(Node->getRHS()); 1654} 1655 1656void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) { 1657 PrintExpr(Node->getCond()); 1658 OS << " ? "; 1659 PrintExpr(Node->getLHS()); 1660 OS << " : "; 1661 PrintExpr(Node->getRHS()); 1662} 1663 1664// GNU extensions. 1665 1666void 1667StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) { 1668 PrintExpr(Node->getCommon()); 1669 OS << " ?: "; 1670 PrintExpr(Node->getFalseExpr()); 1671} 1672 1673void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) { 1674 OS << "&&" << Node->getLabel()->getName(); 1675} 1676 1677void StmtPrinter::VisitStmtExpr(StmtExpr *E) { 1678 OS << "("; 1679 PrintRawCompoundStmt(E->getSubStmt()); 1680 OS << ")"; 1681} 1682 1683void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) { 1684 OS << "__builtin_choose_expr("; 1685 PrintExpr(Node->getCond()); 1686 OS << ", "; 1687 PrintExpr(Node->getLHS()); 1688 OS << ", "; 1689 PrintExpr(Node->getRHS()); 1690 OS << ")"; 1691} 1692 1693void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) { 1694 OS << "__null"; 1695} 1696 1697void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) { 1698 OS << "__builtin_shufflevector("; 1699 for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) { 1700 if (i) OS << ", "; 1701 PrintExpr(Node->getExpr(i)); 1702 } 1703 OS << ")"; 1704} 1705 1706void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) { 1707 OS << "__builtin_convertvector("; 1708 PrintExpr(Node->getSrcExpr()); 1709 OS << ", "; 1710 Node->getType().print(OS, Policy); 1711 OS << ")"; 1712} 1713 1714void StmtPrinter::VisitInitListExpr(InitListExpr* Node) { 1715 if (Node->getSyntacticForm()) { 1716 Visit(Node->getSyntacticForm()); 1717 return; 1718 } 1719 1720 OS << "{"; 1721 for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) { 1722 if (i) OS << ", "; 1723 if (Node->getInit(i)) 1724 PrintExpr(Node->getInit(i)); 1725 else 1726 OS << "{}"; 1727 } 1728 OS << "}"; 1729} 1730 1731void StmtPrinter::VisitArrayInitLoopExpr(ArrayInitLoopExpr *Node) { 1732 // There's no way to express this expression in any of our supported 1733 // languages, so just emit something terse and (hopefully) clear. 1734 OS << "{"; 1735 PrintExpr(Node->getSubExpr()); 1736 OS << "}"; 1737} 1738 1739void StmtPrinter::VisitArrayInitIndexExpr(ArrayInitIndexExpr *Node) { 1740 OS << "*"; 1741} 1742 1743void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) { 1744 OS << "("; 1745 for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) { 1746 if (i) OS << ", "; 1747 PrintExpr(Node->getExpr(i)); 1748 } 1749 OS << ")"; 1750} 1751 1752void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) { 1753 bool NeedsEquals = true; 1754 for (const DesignatedInitExpr::Designator &D : Node->designators()) { 1755 if (D.isFieldDesignator()) { 1756 if (D.getDotLoc().isInvalid()) { 1757 if (const IdentifierInfo *II = D.getFieldName()) { 1758 OS << II->getName() << ":"; 1759 NeedsEquals = false; 1760 } 1761 } else { 1762 OS << "." << D.getFieldName()->getName(); 1763 } 1764 } else { 1765 OS << "["; 1766 if (D.isArrayDesignator()) { 1767 PrintExpr(Node->getArrayIndex(D)); 1768 } else { 1769 PrintExpr(Node->getArrayRangeStart(D)); 1770 OS << " ... "; 1771 PrintExpr(Node->getArrayRangeEnd(D)); 1772 } 1773 OS << "]"; 1774 } 1775 } 1776 1777 if (NeedsEquals) 1778 OS << " = "; 1779 else 1780 OS << " "; 1781 PrintExpr(Node->getInit()); 1782} 1783 1784void StmtPrinter::VisitDesignatedInitUpdateExpr( 1785 DesignatedInitUpdateExpr *Node) { 1786 OS << "{"; 1787 OS << "/*base*/"; 1788 PrintExpr(Node->getBase()); 1789 OS << ", "; 1790 1791 OS << "/*updater*/"; 1792 PrintExpr(Node->getUpdater()); 1793 OS << "}"; 1794} 1795 1796void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) { 1797 OS << "/*no init*/"; 1798} 1799 1800void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) { 1801 if (Node->getType()->getAsCXXRecordDecl()) { 1802 OS << "/*implicit*/"; 1803 Node->getType().print(OS, Policy); 1804 OS << "()"; 1805 } else { 1806 OS << "/*implicit*/("; 1807 Node->getType().print(OS, Policy); 1808 OS << ')'; 1809 if (Node->getType()->isRecordType()) 1810 OS << "{}"; 1811 else 1812 OS << 0; 1813 } 1814} 1815 1816void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) { 1817 OS << "__builtin_va_arg("; 1818 PrintExpr(Node->getSubExpr()); 1819 OS << ", "; 1820 Node->getType().print(OS, Policy); 1821 OS << ")"; 1822} 1823 1824void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) { 1825 PrintExpr(Node->getSyntacticForm()); 1826} 1827 1828void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) { 1829 const char *Name = nullptr; 1830 switch (Node->getOp()) { 1831#define BUILTIN(ID, TYPE, ATTRS) 1832#define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \ 1833 case AtomicExpr::AO ## ID: \ 1834 Name = #ID "("; \ 1835 break; 1836#include "clang/Basic/Builtins.def" 1837 } 1838 OS << Name; 1839 1840 // AtomicExpr stores its subexpressions in a permuted order. 1841 PrintExpr(Node->getPtr()); 1842 if (Node->getOp() != AtomicExpr::AO__c11_atomic_load && 1843 Node->getOp() != AtomicExpr::AO__atomic_load_n && 1844 Node->getOp() != AtomicExpr::AO__scoped_atomic_load_n && 1845 Node->getOp() != AtomicExpr::AO__opencl_atomic_load && 1846 Node->getOp() != AtomicExpr::AO__hip_atomic_load) { 1847 OS << ", "; 1848 PrintExpr(Node->getVal1()); 1849 } 1850 if (Node->getOp() == AtomicExpr::AO__atomic_exchange || 1851 Node->isCmpXChg()) { 1852 OS << ", "; 1853 PrintExpr(Node->getVal2()); 1854 } 1855 if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange || 1856 Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) { 1857 OS << ", "; 1858 PrintExpr(Node->getWeak()); 1859 } 1860 if (Node->getOp() != AtomicExpr::AO__c11_atomic_init && 1861 Node->getOp() != AtomicExpr::AO__opencl_atomic_init) { 1862 OS << ", "; 1863 PrintExpr(Node->getOrder()); 1864 } 1865 if (Node->isCmpXChg()) { 1866 OS << ", "; 1867 PrintExpr(Node->getOrderFail()); 1868 } 1869 OS << ")"; 1870} 1871 1872// C++ 1873void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) { 1874 OverloadedOperatorKind Kind = Node->getOperator(); 1875 if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) { 1876 if (Node->getNumArgs() == 1) { 1877 OS << getOperatorSpelling(Kind) << ' '; 1878 PrintExpr(Node->getArg(0)); 1879 } else { 1880 PrintExpr(Node->getArg(0)); 1881 OS << ' ' << getOperatorSpelling(Kind); 1882 } 1883 } else if (Kind == OO_Arrow) { 1884 PrintExpr(Node->getArg(0)); 1885 } else if (Kind == OO_Call || Kind == OO_Subscript) { 1886 PrintExpr(Node->getArg(0)); 1887 OS << (Kind == OO_Call ? '(' : '['); 1888 for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) { 1889 if (ArgIdx > 1) 1890 OS << ", "; 1891 if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx))) 1892 PrintExpr(Node->getArg(ArgIdx)); 1893 } 1894 OS << (Kind == OO_Call ? ')' : ']'); 1895 } else if (Node->getNumArgs() == 1) { 1896 OS << getOperatorSpelling(Kind) << ' '; 1897 PrintExpr(Node->getArg(0)); 1898 } else if (Node->getNumArgs() == 2) { 1899 PrintExpr(Node->getArg(0)); 1900 OS << ' ' << getOperatorSpelling(Kind) << ' '; 1901 PrintExpr(Node->getArg(1)); 1902 } else { 1903 llvm_unreachable("unknown overloaded operator"); 1904 } 1905} 1906 1907void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) { 1908 // If we have a conversion operator call only print the argument. 1909 CXXMethodDecl *MD = Node->getMethodDecl(); 1910 if (MD && isa<CXXConversionDecl>(MD)) { 1911 PrintExpr(Node->getImplicitObjectArgument()); 1912 return; 1913 } 1914 VisitCallExpr(cast<CallExpr>(Node)); 1915} 1916 1917void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) { 1918 PrintExpr(Node->getCallee()); 1919 OS << "<<<"; 1920 PrintCallArgs(Node->getConfig()); 1921 OS << ">>>("; 1922 PrintCallArgs(Node); 1923 OS << ")"; 1924} 1925 1926void StmtPrinter::VisitCXXRewrittenBinaryOperator( 1927 CXXRewrittenBinaryOperator *Node) { 1928 CXXRewrittenBinaryOperator::DecomposedForm Decomposed = 1929 Node->getDecomposedForm(); 1930 PrintExpr(const_cast<Expr*>(Decomposed.LHS)); 1931 OS << ' ' << BinaryOperator::getOpcodeStr(Decomposed.Opcode) << ' '; 1932 PrintExpr(const_cast<Expr*>(Decomposed.RHS)); 1933} 1934 1935void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) { 1936 OS << Node->getCastName() << '<'; 1937 Node->getTypeAsWritten().print(OS, Policy); 1938 OS << ">("; 1939 PrintExpr(Node->getSubExpr()); 1940 OS << ")"; 1941} 1942 1943void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) { 1944 VisitCXXNamedCastExpr(Node); 1945} 1946 1947void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) { 1948 VisitCXXNamedCastExpr(Node); 1949} 1950 1951void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) { 1952 VisitCXXNamedCastExpr(Node); 1953} 1954 1955void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) { 1956 VisitCXXNamedCastExpr(Node); 1957} 1958 1959void StmtPrinter::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *Node) { 1960 OS << "__builtin_bit_cast("; 1961 Node->getTypeInfoAsWritten()->getType().print(OS, Policy); 1962 OS << ", "; 1963 PrintExpr(Node->getSubExpr()); 1964 OS << ")"; 1965} 1966 1967void StmtPrinter::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *Node) { 1968 VisitCXXNamedCastExpr(Node); 1969} 1970 1971void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) { 1972 OS << "typeid("; 1973 if (Node->isTypeOperand()) { 1974 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy); 1975 } else { 1976 PrintExpr(Node->getExprOperand()); 1977 } 1978 OS << ")"; 1979} 1980 1981void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) { 1982 OS << "__uuidof("; 1983 if (Node->isTypeOperand()) { 1984 Node->getTypeOperandSourceInfo()->getType().print(OS, Policy); 1985 } else { 1986 PrintExpr(Node->getExprOperand()); 1987 } 1988 OS << ")"; 1989} 1990 1991void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) { 1992 PrintExpr(Node->getBaseExpr()); 1993 if (Node->isArrow()) 1994 OS << "->"; 1995 else 1996 OS << "."; 1997 if (NestedNameSpecifier *Qualifier = 1998 Node->getQualifierLoc().getNestedNameSpecifier()) 1999 Qualifier->print(OS, Policy); 2000 OS << Node->getPropertyDecl()->getDeclName(); 2001} 2002 2003void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) { 2004 PrintExpr(Node->getBase()); 2005 OS << "["; 2006 PrintExpr(Node->getIdx()); 2007 OS << "]"; 2008} 2009 2010void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) { 2011 switch (Node->getLiteralOperatorKind()) { 2012 case UserDefinedLiteral::LOK_Raw: 2013 OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString(); 2014 break; 2015 case UserDefinedLiteral::LOK_Template: { 2016 const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts()); 2017 const TemplateArgumentList *Args = 2018 cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs(); 2019 assert(Args); 2020 2021 if (Args->size() != 1 || Args->get(0).getKind() != TemplateArgument::Pack) { 2022 const TemplateParameterList *TPL = nullptr; 2023 if (!DRE->hadMultipleCandidates()) 2024 if (const auto *TD = dyn_cast<TemplateDecl>(DRE->getDecl())) 2025 TPL = TD->getTemplateParameters(); 2026 OS << "operator\"\"" << Node->getUDSuffix()->getName(); 2027 printTemplateArgumentList(OS, Args->asArray(), Policy, TPL); 2028 OS << "()"; 2029 return; 2030 } 2031 2032 const TemplateArgument &Pack = Args->get(0); 2033 for (const auto &P : Pack.pack_elements()) { 2034 char C = (char)P.getAsIntegral().getZExtValue(); 2035 OS << C; 2036 } 2037 break; 2038 } 2039 case UserDefinedLiteral::LOK_Integer: { 2040 // Print integer literal without suffix. 2041 const auto *Int = cast<IntegerLiteral>(Node->getCookedLiteral()); 2042 OS << toString(Int->getValue(), 10, /*isSigned*/false); 2043 break; 2044 } 2045 case UserDefinedLiteral::LOK_Floating: { 2046 // Print floating literal without suffix. 2047 auto *Float = cast<FloatingLiteral>(Node->getCookedLiteral()); 2048 PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false); 2049 break; 2050 } 2051 case UserDefinedLiteral::LOK_String: 2052 case UserDefinedLiteral::LOK_Character: 2053 PrintExpr(Node->getCookedLiteral()); 2054 break; 2055 } 2056 OS << Node->getUDSuffix()->getName(); 2057} 2058 2059void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) { 2060 OS << (Node->getValue() ? "true" : "false"); 2061} 2062 2063void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) { 2064 OS << "nullptr"; 2065} 2066 2067void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) { 2068 OS << "this"; 2069} 2070 2071void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) { 2072 if (!Node->getSubExpr()) 2073 OS << "throw"; 2074 else { 2075 OS << "throw "; 2076 PrintExpr(Node->getSubExpr()); 2077 } 2078} 2079 2080void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) { 2081 // Nothing to print: we picked up the default argument. 2082} 2083 2084void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) { 2085 // Nothing to print: we picked up the default initializer. 2086} 2087 2088void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) { 2089 auto TargetType = Node->getType(); 2090 auto *Auto = TargetType->getContainedDeducedType(); 2091 bool Bare = Auto && Auto->isDeduced(); 2092 2093 // Parenthesize deduced casts. 2094 if (Bare) 2095 OS << '('; 2096 TargetType.print(OS, Policy); 2097 if (Bare) 2098 OS << ')'; 2099 2100 // No extra braces surrounding the inner construct. 2101 if (!Node->isListInitialization()) 2102 OS << '('; 2103 PrintExpr(Node->getSubExpr()); 2104 if (!Node->isListInitialization()) 2105 OS << ')'; 2106} 2107 2108void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) { 2109 PrintExpr(Node->getSubExpr()); 2110} 2111 2112void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) { 2113 Node->getType().print(OS, Policy); 2114 if (Node->isStdInitListInitialization()) 2115 /* Nothing to do; braces are part of creating the std::initializer_list. */; 2116 else if (Node->isListInitialization()) 2117 OS << "{"; 2118 else 2119 OS << "("; 2120 for (CXXTemporaryObjectExpr::arg_iterator Arg = Node->arg_begin(), 2121 ArgEnd = Node->arg_end(); 2122 Arg != ArgEnd; ++Arg) { 2123 if ((*Arg)->isDefaultArgument()) 2124 break; 2125 if (Arg != Node->arg_begin()) 2126 OS << ", "; 2127 PrintExpr(*Arg); 2128 } 2129 if (Node->isStdInitListInitialization()) 2130 /* See above. */; 2131 else if (Node->isListInitialization()) 2132 OS << "}"; 2133 else 2134 OS << ")"; 2135} 2136 2137void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) { 2138 OS << '['; 2139 bool NeedComma = false; 2140 switch (Node->getCaptureDefault()) { 2141 case LCD_None: 2142 break; 2143 2144 case LCD_ByCopy: 2145 OS << '='; 2146 NeedComma = true; 2147 break; 2148 2149 case LCD_ByRef: 2150 OS << '&'; 2151 NeedComma = true; 2152 break; 2153 } 2154 for (LambdaExpr::capture_iterator C = Node->explicit_capture_begin(), 2155 CEnd = Node->explicit_capture_end(); 2156 C != CEnd; 2157 ++C) { 2158 if (C->capturesVLAType()) 2159 continue; 2160 2161 if (NeedComma) 2162 OS << ", "; 2163 NeedComma = true; 2164 2165 switch (C->getCaptureKind()) { 2166 case LCK_This: 2167 OS << "this"; 2168 break; 2169 2170 case LCK_StarThis: 2171 OS << "*this"; 2172 break; 2173 2174 case LCK_ByRef: 2175 if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C)) 2176 OS << '&'; 2177 OS << C->getCapturedVar()->getName(); 2178 break; 2179 2180 case LCK_ByCopy: 2181 OS << C->getCapturedVar()->getName(); 2182 break; 2183 2184 case LCK_VLAType: 2185 llvm_unreachable("VLA type in explicit captures."); 2186 } 2187 2188 if (C->isPackExpansion()) 2189 OS << "..."; 2190 2191 if (Node->isInitCapture(C)) { 2192 // Init captures are always VarDecl. 2193 auto *D = cast<VarDecl>(C->getCapturedVar()); 2194 2195 llvm::StringRef Pre; 2196 llvm::StringRef Post; 2197 if (D->getInitStyle() == VarDecl::CallInit && 2198 !isa<ParenListExpr>(D->getInit())) { 2199 Pre = "("; 2200 Post = ")"; 2201 } else if (D->getInitStyle() == VarDecl::CInit) { 2202 Pre = " = "; 2203 } 2204 2205 OS << Pre; 2206 PrintExpr(D->getInit()); 2207 OS << Post; 2208 } 2209 } 2210 OS << ']'; 2211 2212 if (!Node->getExplicitTemplateParameters().empty()) { 2213 Node->getTemplateParameterList()->print( 2214 OS, Node->getLambdaClass()->getASTContext(), 2215 /*OmitTemplateKW*/true); 2216 } 2217 2218 if (Node->hasExplicitParameters()) { 2219 OS << '('; 2220 CXXMethodDecl *Method = Node->getCallOperator(); 2221 NeedComma = false; 2222 for (const auto *P : Method->parameters()) { 2223 if (NeedComma) { 2224 OS << ", "; 2225 } else { 2226 NeedComma = true; 2227 } 2228 std::string ParamStr = 2229 (Policy.CleanUglifiedParameters && P->getIdentifier()) 2230 ? P->getIdentifier()->deuglifiedName().str() 2231 : P->getNameAsString(); 2232 P->getOriginalType().print(OS, Policy, ParamStr); 2233 } 2234 if (Method->isVariadic()) { 2235 if (NeedComma) 2236 OS << ", "; 2237 OS << "..."; 2238 } 2239 OS << ')'; 2240 2241 if (Node->isMutable()) 2242 OS << " mutable"; 2243 2244 auto *Proto = Method->getType()->castAs<FunctionProtoType>(); 2245 Proto->printExceptionSpecification(OS, Policy); 2246 2247 // FIXME: Attributes 2248 2249 // Print the trailing return type if it was specified in the source. 2250 if (Node->hasExplicitResultType()) { 2251 OS << " -> "; 2252 Proto->getReturnType().print(OS, Policy); 2253 } 2254 } 2255 2256 // Print the body. 2257 OS << ' '; 2258 if (Policy.TerseOutput) 2259 OS << "{}"; 2260 else 2261 PrintRawCompoundStmt(Node->getCompoundStmtBody()); 2262} 2263 2264void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) { 2265 if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo()) 2266 TSInfo->getType().print(OS, Policy); 2267 else 2268 Node->getType().print(OS, Policy); 2269 OS << "()"; 2270} 2271 2272void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) { 2273 if (E->isGlobalNew()) 2274 OS << "::"; 2275 OS << "new "; 2276 unsigned NumPlace = E->getNumPlacementArgs(); 2277 if (NumPlace > 0 && !isa<CXXDefaultArgExpr>(E->getPlacementArg(0))) { 2278 OS << "("; 2279 PrintExpr(E->getPlacementArg(0)); 2280 for (unsigned i = 1; i < NumPlace; ++i) { 2281 if (isa<CXXDefaultArgExpr>(E->getPlacementArg(i))) 2282 break; 2283 OS << ", "; 2284 PrintExpr(E->getPlacementArg(i)); 2285 } 2286 OS << ") "; 2287 } 2288 if (E->isParenTypeId()) 2289 OS << "("; 2290 std::string TypeS; 2291 if (E->isArray()) { 2292 llvm::raw_string_ostream s(TypeS); 2293 s << '['; 2294 if (std::optional<Expr *> Size = E->getArraySize()) 2295 (*Size)->printPretty(s, Helper, Policy); 2296 s << ']'; 2297 } 2298 E->getAllocatedType().print(OS, Policy, TypeS); 2299 if (E->isParenTypeId()) 2300 OS << ")"; 2301 2302 CXXNewInitializationStyle InitStyle = E->getInitializationStyle(); 2303 if (InitStyle != CXXNewInitializationStyle::None) { 2304 bool Bare = InitStyle == CXXNewInitializationStyle::Parens && 2305 !isa<ParenListExpr>(E->getInitializer()); 2306 if (Bare) 2307 OS << "("; 2308 PrintExpr(E->getInitializer()); 2309 if (Bare) 2310 OS << ")"; 2311 } 2312} 2313 2314void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) { 2315 if (E->isGlobalDelete()) 2316 OS << "::"; 2317 OS << "delete "; 2318 if (E->isArrayForm()) 2319 OS << "[] "; 2320 PrintExpr(E->getArgument()); 2321} 2322 2323void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) { 2324 PrintExpr(E->getBase()); 2325 if (E->isArrow()) 2326 OS << "->"; 2327 else 2328 OS << '.'; 2329 if (E->getQualifier()) 2330 E->getQualifier()->print(OS, Policy); 2331 OS << "~"; 2332 2333 if (IdentifierInfo *II = E->getDestroyedTypeIdentifier()) 2334 OS << II->getName(); 2335 else 2336 E->getDestroyedType().print(OS, Policy); 2337} 2338 2339void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) { 2340 if (E->isListInitialization() && !E->isStdInitListInitialization()) 2341 OS << "{"; 2342 2343 for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) { 2344 if (isa<CXXDefaultArgExpr>(E->getArg(i))) { 2345 // Don't print any defaulted arguments 2346 break; 2347 } 2348 2349 if (i) OS << ", "; 2350 PrintExpr(E->getArg(i)); 2351 } 2352 2353 if (E->isListInitialization() && !E->isStdInitListInitialization()) 2354 OS << "}"; 2355} 2356 2357void StmtPrinter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) { 2358 // Parens are printed by the surrounding context. 2359 OS << "<forwarded>"; 2360} 2361 2362void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) { 2363 PrintExpr(E->getSubExpr()); 2364} 2365 2366void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) { 2367 // Just forward to the subexpression. 2368 PrintExpr(E->getSubExpr()); 2369} 2370 2371void StmtPrinter::VisitCXXUnresolvedConstructExpr( 2372 CXXUnresolvedConstructExpr *Node) { 2373 Node->getTypeAsWritten().print(OS, Policy); 2374 if (!Node->isListInitialization()) 2375 OS << '('; 2376 for (auto Arg = Node->arg_begin(), ArgEnd = Node->arg_end(); Arg != ArgEnd; 2377 ++Arg) { 2378 if (Arg != Node->arg_begin()) 2379 OS << ", "; 2380 PrintExpr(*Arg); 2381 } 2382 if (!Node->isListInitialization()) 2383 OS << ')'; 2384} 2385 2386void StmtPrinter::VisitCXXDependentScopeMemberExpr( 2387 CXXDependentScopeMemberExpr *Node) { 2388 if (!Node->isImplicitAccess()) { 2389 PrintExpr(Node->getBase()); 2390 OS << (Node->isArrow() ? "->" : "."); 2391 } 2392 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 2393 Qualifier->print(OS, Policy); 2394 if (Node->hasTemplateKeyword()) 2395 OS << "template "; 2396 OS << Node->getMemberNameInfo(); 2397 if (Node->hasExplicitTemplateArgs()) 2398 printTemplateArgumentList(OS, Node->template_arguments(), Policy); 2399} 2400 2401void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) { 2402 if (!Node->isImplicitAccess()) { 2403 PrintExpr(Node->getBase()); 2404 OS << (Node->isArrow() ? "->" : "."); 2405 } 2406 if (NestedNameSpecifier *Qualifier = Node->getQualifier()) 2407 Qualifier->print(OS, Policy); 2408 if (Node->hasTemplateKeyword()) 2409 OS << "template "; 2410 OS << Node->getMemberNameInfo(); 2411 if (Node->hasExplicitTemplateArgs()) 2412 printTemplateArgumentList(OS, Node->template_arguments(), Policy); 2413} 2414 2415void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) { 2416 OS << getTraitSpelling(E->getTrait()) << "("; 2417 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) { 2418 if (I > 0) 2419 OS << ", "; 2420 E->getArg(I)->getType().print(OS, Policy); 2421 } 2422 OS << ")"; 2423} 2424 2425void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) { 2426 OS << getTraitSpelling(E->getTrait()) << '('; 2427 E->getQueriedType().print(OS, Policy); 2428 OS << ')'; 2429} 2430 2431void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) { 2432 OS << getTraitSpelling(E->getTrait()) << '('; 2433 PrintExpr(E->getQueriedExpression()); 2434 OS << ')'; 2435} 2436 2437void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) { 2438 OS << "noexcept("; 2439 PrintExpr(E->getOperand()); 2440 OS << ")"; 2441} 2442 2443void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) { 2444 PrintExpr(E->getPattern()); 2445 OS << "..."; 2446} 2447 2448void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) { 2449 OS << "sizeof...(" << *E->getPack() << ")"; 2450} 2451 2452void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr( 2453 SubstNonTypeTemplateParmPackExpr *Node) { 2454 OS << *Node->getParameterPack(); 2455} 2456 2457void StmtPrinter::VisitSubstNonTypeTemplateParmExpr( 2458 SubstNonTypeTemplateParmExpr *Node) { 2459 Visit(Node->getReplacement()); 2460} 2461 2462void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) { 2463 OS << *E->getParameterPack(); 2464} 2465 2466void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){ 2467 PrintExpr(Node->getSubExpr()); 2468} 2469 2470void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) { 2471 OS << "("; 2472 if (E->getLHS()) { 2473 PrintExpr(E->getLHS()); 2474 OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " "; 2475 } 2476 OS << "..."; 2477 if (E->getRHS()) { 2478 OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " "; 2479 PrintExpr(E->getRHS()); 2480 } 2481 OS << ")"; 2482} 2483 2484void StmtPrinter::VisitCXXParenListInitExpr(CXXParenListInitExpr *Node) { 2485 OS << "("; 2486 llvm::interleaveComma(Node->getInitExprs(), OS, 2487 [&](Expr *E) { PrintExpr(E); }); 2488 OS << ")"; 2489} 2490 2491void StmtPrinter::VisitConceptSpecializationExpr(ConceptSpecializationExpr *E) { 2492 NestedNameSpecifierLoc NNS = E->getNestedNameSpecifierLoc(); 2493 if (NNS) 2494 NNS.getNestedNameSpecifier()->print(OS, Policy); 2495 if (E->getTemplateKWLoc().isValid()) 2496 OS << "template "; 2497 OS << E->getFoundDecl()->getName(); 2498 printTemplateArgumentList(OS, E->getTemplateArgsAsWritten()->arguments(), 2499 Policy, 2500 E->getNamedConcept()->getTemplateParameters()); 2501} 2502 2503void StmtPrinter::VisitRequiresExpr(RequiresExpr *E) { 2504 OS << "requires "; 2505 auto LocalParameters = E->getLocalParameters(); 2506 if (!LocalParameters.empty()) { 2507 OS << "("; 2508 for (ParmVarDecl *LocalParam : LocalParameters) { 2509 PrintRawDecl(LocalParam); 2510 if (LocalParam != LocalParameters.back()) 2511 OS << ", "; 2512 } 2513 2514 OS << ") "; 2515 } 2516 OS << "{ "; 2517 auto Requirements = E->getRequirements(); 2518 for (concepts::Requirement *Req : Requirements) { 2519 if (auto *TypeReq = dyn_cast<concepts::TypeRequirement>(Req)) { 2520 if (TypeReq->isSubstitutionFailure()) 2521 OS << "<<error-type>>"; 2522 else 2523 TypeReq->getType()->getType().print(OS, Policy); 2524 } else if (auto *ExprReq = dyn_cast<concepts::ExprRequirement>(Req)) { 2525 if (ExprReq->isCompound()) 2526 OS << "{ "; 2527 if (ExprReq->isExprSubstitutionFailure()) 2528 OS << "<<error-expression>>"; 2529 else 2530 PrintExpr(ExprReq->getExpr()); 2531 if (ExprReq->isCompound()) { 2532 OS << " }"; 2533 if (ExprReq->getNoexceptLoc().isValid()) 2534 OS << " noexcept"; 2535 const auto &RetReq = ExprReq->getReturnTypeRequirement(); 2536 if (!RetReq.isEmpty()) { 2537 OS << " -> "; 2538 if (RetReq.isSubstitutionFailure()) 2539 OS << "<<error-type>>"; 2540 else if (RetReq.isTypeConstraint()) 2541 RetReq.getTypeConstraint()->print(OS, Policy); 2542 } 2543 } 2544 } else { 2545 auto *NestedReq = cast<concepts::NestedRequirement>(Req); 2546 OS << "requires "; 2547 if (NestedReq->hasInvalidConstraint()) 2548 OS << "<<error-expression>>"; 2549 else 2550 PrintExpr(NestedReq->getConstraintExpr()); 2551 } 2552 OS << "; "; 2553 } 2554 OS << "}"; 2555} 2556 2557// C++ Coroutines 2558 2559void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) { 2560 Visit(S->getBody()); 2561} 2562 2563void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) { 2564 OS << "co_return"; 2565 if (S->getOperand()) { 2566 OS << " "; 2567 Visit(S->getOperand()); 2568 } 2569 OS << ";"; 2570} 2571 2572void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) { 2573 OS << "co_await "; 2574 PrintExpr(S->getOperand()); 2575} 2576 2577void StmtPrinter::VisitDependentCoawaitExpr(DependentCoawaitExpr *S) { 2578 OS << "co_await "; 2579 PrintExpr(S->getOperand()); 2580} 2581 2582void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) { 2583 OS << "co_yield "; 2584 PrintExpr(S->getOperand()); 2585} 2586 2587// Obj-C 2588 2589void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) { 2590 OS << "@"; 2591 VisitStringLiteral(Node->getString()); 2592} 2593 2594void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) { 2595 OS << "@"; 2596 Visit(E->getSubExpr()); 2597} 2598 2599void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) { 2600 OS << "@[ "; 2601 ObjCArrayLiteral::child_range Ch = E->children(); 2602 for (auto I = Ch.begin(), E = Ch.end(); I != E; ++I) { 2603 if (I != Ch.begin()) 2604 OS << ", "; 2605 Visit(*I); 2606 } 2607 OS << " ]"; 2608} 2609 2610void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) { 2611 OS << "@{ "; 2612 for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) { 2613 if (I > 0) 2614 OS << ", "; 2615 2616 ObjCDictionaryElement Element = E->getKeyValueElement(I); 2617 Visit(Element.Key); 2618 OS << " : "; 2619 Visit(Element.Value); 2620 if (Element.isPackExpansion()) 2621 OS << "..."; 2622 } 2623 OS << " }"; 2624} 2625 2626void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) { 2627 OS << "@encode("; 2628 Node->getEncodedType().print(OS, Policy); 2629 OS << ')'; 2630} 2631 2632void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) { 2633 OS << "@selector("; 2634 Node->getSelector().print(OS); 2635 OS << ')'; 2636} 2637 2638void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) { 2639 OS << "@protocol(" << *Node->getProtocol() << ')'; 2640} 2641 2642void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) { 2643 OS << "["; 2644 switch (Mess->getReceiverKind()) { 2645 case ObjCMessageExpr::Instance: 2646 PrintExpr(Mess->getInstanceReceiver()); 2647 break; 2648 2649 case ObjCMessageExpr::Class: 2650 Mess->getClassReceiver().print(OS, Policy); 2651 break; 2652 2653 case ObjCMessageExpr::SuperInstance: 2654 case ObjCMessageExpr::SuperClass: 2655 OS << "Super"; 2656 break; 2657 } 2658 2659 OS << ' '; 2660 Selector selector = Mess->getSelector(); 2661 if (selector.isUnarySelector()) { 2662 OS << selector.getNameForSlot(0); 2663 } else { 2664 for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) { 2665 if (i < selector.getNumArgs()) { 2666 if (i > 0) OS << ' '; 2667 if (selector.getIdentifierInfoForSlot(i)) 2668 OS << selector.getIdentifierInfoForSlot(i)->getName() << ':'; 2669 else 2670 OS << ":"; 2671 } 2672 else OS << ", "; // Handle variadic methods. 2673 2674 PrintExpr(Mess->getArg(i)); 2675 } 2676 } 2677 OS << "]"; 2678} 2679 2680void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) { 2681 OS << (Node->getValue() ? "__objc_yes" : "__objc_no"); 2682} 2683 2684void 2685StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) { 2686 PrintExpr(E->getSubExpr()); 2687} 2688 2689void 2690StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) { 2691 OS << '(' << E->getBridgeKindName(); 2692 E->getType().print(OS, Policy); 2693 OS << ')'; 2694 PrintExpr(E->getSubExpr()); 2695} 2696 2697void StmtPrinter::VisitBlockExpr(BlockExpr *Node) { 2698 BlockDecl *BD = Node->getBlockDecl(); 2699 OS << "^"; 2700 2701 const FunctionType *AFT = Node->getFunctionType(); 2702 2703 if (isa<FunctionNoProtoType>(AFT)) { 2704 OS << "()"; 2705 } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) { 2706 OS << '('; 2707 for (BlockDecl::param_iterator AI = BD->param_begin(), 2708 E = BD->param_end(); AI != E; ++AI) { 2709 if (AI != BD->param_begin()) OS << ", "; 2710 std::string ParamStr = (*AI)->getNameAsString(); 2711 (*AI)->getType().print(OS, Policy, ParamStr); 2712 } 2713 2714 const auto *FT = cast<FunctionProtoType>(AFT); 2715 if (FT->isVariadic()) { 2716 if (!BD->param_empty()) OS << ", "; 2717 OS << "..."; 2718 } 2719 OS << ')'; 2720 } 2721 OS << "{ }"; 2722} 2723 2724void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) { 2725 PrintExpr(Node->getSourceExpr()); 2726} 2727 2728void StmtPrinter::VisitTypoExpr(TypoExpr *Node) { 2729 // TODO: Print something reasonable for a TypoExpr, if necessary. 2730 llvm_unreachable("Cannot print TypoExpr nodes"); 2731} 2732 2733void StmtPrinter::VisitRecoveryExpr(RecoveryExpr *Node) { 2734 OS << "<recovery-expr>("; 2735 const char *Sep = ""; 2736 for (Expr *E : Node->subExpressions()) { 2737 OS << Sep; 2738 PrintExpr(E); 2739 Sep = ", "; 2740 } 2741 OS << ')'; 2742} 2743 2744void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) { 2745 OS << "__builtin_astype("; 2746 PrintExpr(Node->getSrcExpr()); 2747 OS << ", "; 2748 Node->getType().print(OS, Policy); 2749 OS << ")"; 2750} 2751 2752//===----------------------------------------------------------------------===// 2753// Stmt method implementations 2754//===----------------------------------------------------------------------===// 2755 2756void Stmt::dumpPretty(const ASTContext &Context) const { 2757 printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts())); 2758} 2759 2760void Stmt::printPretty(raw_ostream &Out, PrinterHelper *Helper, 2761 const PrintingPolicy &Policy, unsigned Indentation, 2762 StringRef NL, const ASTContext *Context) const { 2763 StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context); 2764 P.Visit(const_cast<Stmt *>(this)); 2765} 2766 2767void Stmt::printPrettyControlled(raw_ostream &Out, PrinterHelper *Helper, 2768 const PrintingPolicy &Policy, 2769 unsigned Indentation, StringRef NL, 2770 const ASTContext *Context) const { 2771 StmtPrinter P(Out, Helper, Policy, Indentation, NL, Context); 2772 P.PrintControlledStmt(const_cast<Stmt *>(this)); 2773} 2774 2775void Stmt::printJson(raw_ostream &Out, PrinterHelper *Helper, 2776 const PrintingPolicy &Policy, bool AddQuotes) const { 2777 std::string Buf; 2778 llvm::raw_string_ostream TempOut(Buf); 2779 2780 printPretty(TempOut, Helper, Policy); 2781 2782 Out << JsonFormat(TempOut.str(), AddQuotes); 2783} 2784 2785//===----------------------------------------------------------------------===// 2786// PrinterHelper 2787//===----------------------------------------------------------------------===// 2788 2789// Implement virtual destructor. 2790PrinterHelper::~PrinterHelper() = default; 2791