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