clang  3.9.0
StmtPrinter.cpp
Go to the documentation of this file.
1 //===--- StmtPrinter.cpp - Printing implementation for Stmt ASTs ----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Stmt::dumpPretty/Stmt::printPretty methods, which
11 // pretty print the AST back out to C code.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclOpenMP.h"
20 #include "clang/AST/DeclTemplate.h"
21 #include "clang/AST/Expr.h"
22 #include "clang/AST/ExprCXX.h"
23 #include "clang/AST/ExprOpenMP.h"
25 #include "clang/AST/StmtVisitor.h"
26 #include "clang/Basic/CharInfo.h"
27 #include "llvm/ADT/SmallString.h"
28 #include "llvm/Support/Format.h"
29 using namespace clang;
30 
31 //===----------------------------------------------------------------------===//
32 // StmtPrinter Visitor
33 //===----------------------------------------------------------------------===//
34 
35 namespace {
36  class StmtPrinter : public StmtVisitor<StmtPrinter> {
37  raw_ostream &OS;
38  unsigned IndentLevel;
39  clang::PrinterHelper* Helper;
40  PrintingPolicy Policy;
41 
42  public:
43  StmtPrinter(raw_ostream &os, PrinterHelper* helper,
44  const PrintingPolicy &Policy,
45  unsigned Indentation = 0)
46  : OS(os), IndentLevel(Indentation), Helper(helper), Policy(Policy) {}
47 
48  void PrintStmt(Stmt *S) {
49  PrintStmt(S, Policy.Indentation);
50  }
51 
52  void PrintStmt(Stmt *S, int SubIndent) {
53  IndentLevel += SubIndent;
54  if (S && isa<Expr>(S)) {
55  // If this is an expr used in a stmt context, indent and newline it.
56  Indent();
57  Visit(S);
58  OS << ";\n";
59  } else if (S) {
60  Visit(S);
61  } else {
62  Indent() << "<<<NULL STATEMENT>>>\n";
63  }
64  IndentLevel -= SubIndent;
65  }
66 
67  void PrintRawCompoundStmt(CompoundStmt *S);
68  void PrintRawDecl(Decl *D);
69  void PrintRawDeclStmt(const DeclStmt *S);
70  void PrintRawIfStmt(IfStmt *If);
71  void PrintRawCXXCatchStmt(CXXCatchStmt *Catch);
72  void PrintCallArgs(CallExpr *E);
73  void PrintRawSEHExceptHandler(SEHExceptStmt *S);
74  void PrintRawSEHFinallyStmt(SEHFinallyStmt *S);
75  void PrintOMPExecutableDirective(OMPExecutableDirective *S);
76 
77  void PrintExpr(Expr *E) {
78  if (E)
79  Visit(E);
80  else
81  OS << "<null expr>";
82  }
83 
84  raw_ostream &Indent(int Delta = 0) {
85  for (int i = 0, e = IndentLevel+Delta; i < e; ++i)
86  OS << " ";
87  return OS;
88  }
89 
90  void Visit(Stmt* S) {
91  if (Helper && Helper->handledStmt(S,OS))
92  return;
94  }
95 
96  void VisitStmt(Stmt *Node) LLVM_ATTRIBUTE_UNUSED {
97  Indent() << "<<unknown stmt type>>\n";
98  }
99  void VisitExpr(Expr *Node) LLVM_ATTRIBUTE_UNUSED {
100  OS << "<<unknown expr type>>";
101  }
102  void VisitCXXNamedCastExpr(CXXNamedCastExpr *Node);
103 
104 #define ABSTRACT_STMT(CLASS)
105 #define STMT(CLASS, PARENT) \
106  void Visit##CLASS(CLASS *Node);
107 #include "clang/AST/StmtNodes.inc"
108  };
109 }
110 
111 //===----------------------------------------------------------------------===//
112 // Stmt printing methods.
113 //===----------------------------------------------------------------------===//
114 
115 /// PrintRawCompoundStmt - Print a compound stmt without indenting the {, and
116 /// with no newline after the }.
117 void StmtPrinter::PrintRawCompoundStmt(CompoundStmt *Node) {
118  OS << "{\n";
119  for (auto *I : Node->body())
120  PrintStmt(I);
121 
122  Indent() << "}";
123 }
124 
125 void StmtPrinter::PrintRawDecl(Decl *D) {
126  D->print(OS, Policy, IndentLevel);
127 }
128 
129 void StmtPrinter::PrintRawDeclStmt(const DeclStmt *S) {
130  SmallVector<Decl*, 2> Decls(S->decls());
131  Decl::printGroup(Decls.data(), Decls.size(), OS, Policy, IndentLevel);
132 }
133 
134 void StmtPrinter::VisitNullStmt(NullStmt *Node) {
135  Indent() << ";\n";
136 }
137 
138 void StmtPrinter::VisitDeclStmt(DeclStmt *Node) {
139  Indent();
140  PrintRawDeclStmt(Node);
141  OS << ";\n";
142 }
143 
144 void StmtPrinter::VisitCompoundStmt(CompoundStmt *Node) {
145  Indent();
146  PrintRawCompoundStmt(Node);
147  OS << "\n";
148 }
149 
150 void StmtPrinter::VisitCaseStmt(CaseStmt *Node) {
151  Indent(-1) << "case ";
152  PrintExpr(Node->getLHS());
153  if (Node->getRHS()) {
154  OS << " ... ";
155  PrintExpr(Node->getRHS());
156  }
157  OS << ":\n";
158 
159  PrintStmt(Node->getSubStmt(), 0);
160 }
161 
162 void StmtPrinter::VisitDefaultStmt(DefaultStmt *Node) {
163  Indent(-1) << "default:\n";
164  PrintStmt(Node->getSubStmt(), 0);
165 }
166 
167 void StmtPrinter::VisitLabelStmt(LabelStmt *Node) {
168  Indent(-1) << Node->getName() << ":\n";
169  PrintStmt(Node->getSubStmt(), 0);
170 }
171 
172 void StmtPrinter::VisitAttributedStmt(AttributedStmt *Node) {
173  for (const auto *Attr : Node->getAttrs()) {
174  Attr->printPretty(OS, Policy);
175  }
176 
177  PrintStmt(Node->getSubStmt(), 0);
178 }
179 
180 void StmtPrinter::PrintRawIfStmt(IfStmt *If) {
181  OS << "if (";
182  if (const DeclStmt *DS = If->getConditionVariableDeclStmt())
183  PrintRawDeclStmt(DS);
184  else
185  PrintExpr(If->getCond());
186  OS << ')';
187 
188  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(If->getThen())) {
189  OS << ' ';
190  PrintRawCompoundStmt(CS);
191  OS << (If->getElse() ? ' ' : '\n');
192  } else {
193  OS << '\n';
194  PrintStmt(If->getThen());
195  if (If->getElse()) Indent();
196  }
197 
198  if (Stmt *Else = If->getElse()) {
199  OS << "else";
200 
201  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Else)) {
202  OS << ' ';
203  PrintRawCompoundStmt(CS);
204  OS << '\n';
205  } else if (IfStmt *ElseIf = dyn_cast<IfStmt>(Else)) {
206  OS << ' ';
207  PrintRawIfStmt(ElseIf);
208  } else {
209  OS << '\n';
210  PrintStmt(If->getElse());
211  }
212  }
213 }
214 
215 void StmtPrinter::VisitIfStmt(IfStmt *If) {
216  Indent();
217  PrintRawIfStmt(If);
218 }
219 
220 void StmtPrinter::VisitSwitchStmt(SwitchStmt *Node) {
221  Indent() << "switch (";
222  if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
223  PrintRawDeclStmt(DS);
224  else
225  PrintExpr(Node->getCond());
226  OS << ")";
227 
228  // Pretty print compoundstmt bodies (very common).
229  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
230  OS << " ";
231  PrintRawCompoundStmt(CS);
232  OS << "\n";
233  } else {
234  OS << "\n";
235  PrintStmt(Node->getBody());
236  }
237 }
238 
239 void StmtPrinter::VisitWhileStmt(WhileStmt *Node) {
240  Indent() << "while (";
241  if (const DeclStmt *DS = Node->getConditionVariableDeclStmt())
242  PrintRawDeclStmt(DS);
243  else
244  PrintExpr(Node->getCond());
245  OS << ")\n";
246  PrintStmt(Node->getBody());
247 }
248 
249 void StmtPrinter::VisitDoStmt(DoStmt *Node) {
250  Indent() << "do ";
251  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
252  PrintRawCompoundStmt(CS);
253  OS << " ";
254  } else {
255  OS << "\n";
256  PrintStmt(Node->getBody());
257  Indent();
258  }
259 
260  OS << "while (";
261  PrintExpr(Node->getCond());
262  OS << ");\n";
263 }
264 
265 void StmtPrinter::VisitForStmt(ForStmt *Node) {
266  Indent() << "for (";
267  if (Node->getInit()) {
268  if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getInit()))
269  PrintRawDeclStmt(DS);
270  else
271  PrintExpr(cast<Expr>(Node->getInit()));
272  }
273  OS << ";";
274  if (Node->getCond()) {
275  OS << " ";
276  PrintExpr(Node->getCond());
277  }
278  OS << ";";
279  if (Node->getInc()) {
280  OS << " ";
281  PrintExpr(Node->getInc());
282  }
283  OS << ") ";
284 
285  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
286  PrintRawCompoundStmt(CS);
287  OS << "\n";
288  } else {
289  OS << "\n";
290  PrintStmt(Node->getBody());
291  }
292 }
293 
294 void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
295  Indent() << "for (";
296  if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement()))
297  PrintRawDeclStmt(DS);
298  else
299  PrintExpr(cast<Expr>(Node->getElement()));
300  OS << " in ";
301  PrintExpr(Node->getCollection());
302  OS << ") ";
303 
304  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Node->getBody())) {
305  PrintRawCompoundStmt(CS);
306  OS << "\n";
307  } else {
308  OS << "\n";
309  PrintStmt(Node->getBody());
310  }
311 }
312 
313 void StmtPrinter::VisitCXXForRangeStmt(CXXForRangeStmt *Node) {
314  Indent() << "for (";
315  PrintingPolicy SubPolicy(Policy);
316  SubPolicy.SuppressInitializers = true;
317  Node->getLoopVariable()->print(OS, SubPolicy, IndentLevel);
318  OS << " : ";
319  PrintExpr(Node->getRangeInit());
320  OS << ") {\n";
321  PrintStmt(Node->getBody());
322  Indent() << "}";
323  if (Policy.IncludeNewlines) OS << "\n";
324 }
325 
326 void StmtPrinter::VisitMSDependentExistsStmt(MSDependentExistsStmt *Node) {
327  Indent();
328  if (Node->isIfExists())
329  OS << "__if_exists (";
330  else
331  OS << "__if_not_exists (";
332 
333  if (NestedNameSpecifier *Qualifier
335  Qualifier->print(OS, Policy);
336 
337  OS << Node->getNameInfo() << ") ";
338 
339  PrintRawCompoundStmt(Node->getSubStmt());
340 }
341 
342 void StmtPrinter::VisitGotoStmt(GotoStmt *Node) {
343  Indent() << "goto " << Node->getLabel()->getName() << ";";
344  if (Policy.IncludeNewlines) OS << "\n";
345 }
346 
347 void StmtPrinter::VisitIndirectGotoStmt(IndirectGotoStmt *Node) {
348  Indent() << "goto *";
349  PrintExpr(Node->getTarget());
350  OS << ";";
351  if (Policy.IncludeNewlines) OS << "\n";
352 }
353 
354 void StmtPrinter::VisitContinueStmt(ContinueStmt *Node) {
355  Indent() << "continue;";
356  if (Policy.IncludeNewlines) OS << "\n";
357 }
358 
359 void StmtPrinter::VisitBreakStmt(BreakStmt *Node) {
360  Indent() << "break;";
361  if (Policy.IncludeNewlines) OS << "\n";
362 }
363 
364 
365 void StmtPrinter::VisitReturnStmt(ReturnStmt *Node) {
366  Indent() << "return";
367  if (Node->getRetValue()) {
368  OS << " ";
369  PrintExpr(Node->getRetValue());
370  }
371  OS << ";";
372  if (Policy.IncludeNewlines) OS << "\n";
373 }
374 
375 
376 void StmtPrinter::VisitGCCAsmStmt(GCCAsmStmt *Node) {
377  Indent() << "asm ";
378 
379  if (Node->isVolatile())
380  OS << "volatile ";
381 
382  OS << "(";
383  VisitStringLiteral(Node->getAsmString());
384 
385  // Outputs
386  if (Node->getNumOutputs() != 0 || Node->getNumInputs() != 0 ||
387  Node->getNumClobbers() != 0)
388  OS << " : ";
389 
390  for (unsigned i = 0, e = Node->getNumOutputs(); i != e; ++i) {
391  if (i != 0)
392  OS << ", ";
393 
394  if (!Node->getOutputName(i).empty()) {
395  OS << '[';
396  OS << Node->getOutputName(i);
397  OS << "] ";
398  }
399 
400  VisitStringLiteral(Node->getOutputConstraintLiteral(i));
401  OS << " (";
402  Visit(Node->getOutputExpr(i));
403  OS << ")";
404  }
405 
406  // Inputs
407  if (Node->getNumInputs() != 0 || Node->getNumClobbers() != 0)
408  OS << " : ";
409 
410  for (unsigned i = 0, e = Node->getNumInputs(); i != e; ++i) {
411  if (i != 0)
412  OS << ", ";
413 
414  if (!Node->getInputName(i).empty()) {
415  OS << '[';
416  OS << Node->getInputName(i);
417  OS << "] ";
418  }
419 
420  VisitStringLiteral(Node->getInputConstraintLiteral(i));
421  OS << " (";
422  Visit(Node->getInputExpr(i));
423  OS << ")";
424  }
425 
426  // Clobbers
427  if (Node->getNumClobbers() != 0)
428  OS << " : ";
429 
430  for (unsigned i = 0, e = Node->getNumClobbers(); i != e; ++i) {
431  if (i != 0)
432  OS << ", ";
433 
434  VisitStringLiteral(Node->getClobberStringLiteral(i));
435  }
436 
437  OS << ");";
438  if (Policy.IncludeNewlines) OS << "\n";
439 }
440 
441 void StmtPrinter::VisitMSAsmStmt(MSAsmStmt *Node) {
442  // FIXME: Implement MS style inline asm statement printer.
443  Indent() << "__asm ";
444  if (Node->hasBraces())
445  OS << "{\n";
446  OS << Node->getAsmString() << "\n";
447  if (Node->hasBraces())
448  Indent() << "}\n";
449 }
450 
451 void StmtPrinter::VisitCapturedStmt(CapturedStmt *Node) {
452  PrintStmt(Node->getCapturedDecl()->getBody());
453 }
454 
455 void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
456  Indent() << "@try";
457  if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
458  PrintRawCompoundStmt(TS);
459  OS << "\n";
460  }
461 
462  for (unsigned I = 0, N = Node->getNumCatchStmts(); I != N; ++I) {
463  ObjCAtCatchStmt *catchStmt = Node->getCatchStmt(I);
464  Indent() << "@catch(";
465  if (catchStmt->getCatchParamDecl()) {
466  if (Decl *DS = catchStmt->getCatchParamDecl())
467  PrintRawDecl(DS);
468  }
469  OS << ")";
470  if (CompoundStmt *CS = dyn_cast<CompoundStmt>(catchStmt->getCatchBody())) {
471  PrintRawCompoundStmt(CS);
472  OS << "\n";
473  }
474  }
475 
476  if (ObjCAtFinallyStmt *FS = static_cast<ObjCAtFinallyStmt *>(
477  Node->getFinallyStmt())) {
478  Indent() << "@finally";
479  PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
480  OS << "\n";
481  }
482 }
483 
484 void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
485 }
486 
487 void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
488  Indent() << "@catch (...) { /* todo */ } \n";
489 }
490 
491 void StmtPrinter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *Node) {
492  Indent() << "@throw";
493  if (Node->getThrowExpr()) {
494  OS << " ";
495  PrintExpr(Node->getThrowExpr());
496  }
497  OS << ";\n";
498 }
499 
500 void StmtPrinter::VisitObjCAvailabilityCheckExpr(
502  OS << "@available(...)";
503 }
504 
505 void StmtPrinter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *Node) {
506  Indent() << "@synchronized (";
507  PrintExpr(Node->getSynchExpr());
508  OS << ")";
509  PrintRawCompoundStmt(Node->getSynchBody());
510  OS << "\n";
511 }
512 
513 void StmtPrinter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *Node) {
514  Indent() << "@autoreleasepool";
515  PrintRawCompoundStmt(dyn_cast<CompoundStmt>(Node->getSubStmt()));
516  OS << "\n";
517 }
518 
519 void StmtPrinter::PrintRawCXXCatchStmt(CXXCatchStmt *Node) {
520  OS << "catch (";
521  if (Decl *ExDecl = Node->getExceptionDecl())
522  PrintRawDecl(ExDecl);
523  else
524  OS << "...";
525  OS << ") ";
526  PrintRawCompoundStmt(cast<CompoundStmt>(Node->getHandlerBlock()));
527 }
528 
529 void StmtPrinter::VisitCXXCatchStmt(CXXCatchStmt *Node) {
530  Indent();
531  PrintRawCXXCatchStmt(Node);
532  OS << "\n";
533 }
534 
535 void StmtPrinter::VisitCXXTryStmt(CXXTryStmt *Node) {
536  Indent() << "try ";
537  PrintRawCompoundStmt(Node->getTryBlock());
538  for (unsigned i = 0, e = Node->getNumHandlers(); i < e; ++i) {
539  OS << " ";
540  PrintRawCXXCatchStmt(Node->getHandler(i));
541  }
542  OS << "\n";
543 }
544 
545 void StmtPrinter::VisitSEHTryStmt(SEHTryStmt *Node) {
546  Indent() << (Node->getIsCXXTry() ? "try " : "__try ");
547  PrintRawCompoundStmt(Node->getTryBlock());
548  SEHExceptStmt *E = Node->getExceptHandler();
549  SEHFinallyStmt *F = Node->getFinallyHandler();
550  if(E)
551  PrintRawSEHExceptHandler(E);
552  else {
553  assert(F && "Must have a finally block...");
554  PrintRawSEHFinallyStmt(F);
555  }
556  OS << "\n";
557 }
558 
559 void StmtPrinter::PrintRawSEHFinallyStmt(SEHFinallyStmt *Node) {
560  OS << "__finally ";
561  PrintRawCompoundStmt(Node->getBlock());
562  OS << "\n";
563 }
564 
565 void StmtPrinter::PrintRawSEHExceptHandler(SEHExceptStmt *Node) {
566  OS << "__except (";
567  VisitExpr(Node->getFilterExpr());
568  OS << ")\n";
569  PrintRawCompoundStmt(Node->getBlock());
570  OS << "\n";
571 }
572 
573 void StmtPrinter::VisitSEHExceptStmt(SEHExceptStmt *Node) {
574  Indent();
575  PrintRawSEHExceptHandler(Node);
576  OS << "\n";
577 }
578 
579 void StmtPrinter::VisitSEHFinallyStmt(SEHFinallyStmt *Node) {
580  Indent();
581  PrintRawSEHFinallyStmt(Node);
582  OS << "\n";
583 }
584 
585 void StmtPrinter::VisitSEHLeaveStmt(SEHLeaveStmt *Node) {
586  Indent() << "__leave;";
587  if (Policy.IncludeNewlines) OS << "\n";
588 }
589 
590 //===----------------------------------------------------------------------===//
591 // OpenMP clauses printing methods
592 //===----------------------------------------------------------------------===//
593 
594 namespace {
595 class OMPClausePrinter : public OMPClauseVisitor<OMPClausePrinter> {
596  raw_ostream &OS;
597  const PrintingPolicy &Policy;
598  /// \brief Process clauses with list of variables.
599  template <typename T>
600  void VisitOMPClauseList(T *Node, char StartSym);
601 public:
602  OMPClausePrinter(raw_ostream &OS, const PrintingPolicy &Policy)
603  : OS(OS), Policy(Policy) { }
604 #define OPENMP_CLAUSE(Name, Class) \
605  void Visit##Class(Class *S);
606 #include "clang/Basic/OpenMPKinds.def"
607 };
608 
609 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) {
610  OS << "if(";
611  if (Node->getNameModifier() != OMPD_unknown)
612  OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": ";
613  Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
614  OS << ")";
615 }
616 
617 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) {
618  OS << "final(";
619  Node->getCondition()->printPretty(OS, nullptr, Policy, 0);
620  OS << ")";
621 }
622 
623 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) {
624  OS << "num_threads(";
625  Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0);
626  OS << ")";
627 }
628 
629 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) {
630  OS << "safelen(";
631  Node->getSafelen()->printPretty(OS, nullptr, Policy, 0);
632  OS << ")";
633 }
634 
635 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) {
636  OS << "simdlen(";
637  Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0);
638  OS << ")";
639 }
640 
641 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) {
642  OS << "collapse(";
643  Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0);
644  OS << ")";
645 }
646 
647 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) {
648  OS << "default("
649  << getOpenMPSimpleClauseTypeName(OMPC_default, Node->getDefaultKind())
650  << ")";
651 }
652 
653 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) {
654  OS << "proc_bind("
655  << getOpenMPSimpleClauseTypeName(OMPC_proc_bind, Node->getProcBindKind())
656  << ")";
657 }
658 
659 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) {
660  OS << "schedule(";
662  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
663  Node->getFirstScheduleModifier());
665  OS << ", ";
666  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule,
667  Node->getSecondScheduleModifier());
668  }
669  OS << ": ";
670  }
671  OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind());
672  if (auto *E = Node->getChunkSize()) {
673  OS << ", ";
674  E->printPretty(OS, nullptr, Policy);
675  }
676  OS << ")";
677 }
678 
679 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) {
680  OS << "ordered";
681  if (auto *Num = Node->getNumForLoops()) {
682  OS << "(";
683  Num->printPretty(OS, nullptr, Policy, 0);
684  OS << ")";
685  }
686 }
687 
688 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) {
689  OS << "nowait";
690 }
691 
692 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) {
693  OS << "untied";
694 }
695 
696 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) {
697  OS << "nogroup";
698 }
699 
700 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) {
701  OS << "mergeable";
702 }
703 
704 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; }
705 
706 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; }
707 
708 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *) {
709  OS << "update";
710 }
711 
712 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) {
713  OS << "capture";
714 }
715 
716 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) {
717  OS << "seq_cst";
718 }
719 
720 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) {
721  OS << "threads";
722 }
723 
724 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; }
725 
726 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) {
727  OS << "device(";
728  Node->getDevice()->printPretty(OS, nullptr, Policy, 0);
729  OS << ")";
730 }
731 
732 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) {
733  OS << "num_teams(";
734  Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0);
735  OS << ")";
736 }
737 
738 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) {
739  OS << "thread_limit(";
740  Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0);
741  OS << ")";
742 }
743 
744 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) {
745  OS << "priority(";
746  Node->getPriority()->printPretty(OS, nullptr, Policy, 0);
747  OS << ")";
748 }
749 
750 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) {
751  OS << "grainsize(";
752  Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0);
753  OS << ")";
754 }
755 
756 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) {
757  OS << "num_tasks(";
758  Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0);
759  OS << ")";
760 }
761 
762 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) {
763  OS << "hint(";
764  Node->getHint()->printPretty(OS, nullptr, Policy, 0);
765  OS << ")";
766 }
767 
768 template<typename T>
769 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) {
770  for (typename T::varlist_iterator I = Node->varlist_begin(),
771  E = Node->varlist_end();
772  I != E; ++I) {
773  assert(*I && "Expected non-null Stmt");
774  OS << (I == Node->varlist_begin() ? StartSym : ',');
775  if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(*I)) {
776  if (isa<OMPCapturedExprDecl>(DRE->getDecl()))
777  DRE->printPretty(OS, nullptr, Policy, 0);
778  else
779  DRE->getDecl()->printQualifiedName(OS);
780  } else
781  (*I)->printPretty(OS, nullptr, Policy, 0);
782  }
783 }
784 
785 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) {
786  if (!Node->varlist_empty()) {
787  OS << "private";
788  VisitOMPClauseList(Node, '(');
789  OS << ")";
790  }
791 }
792 
793 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) {
794  if (!Node->varlist_empty()) {
795  OS << "firstprivate";
796  VisitOMPClauseList(Node, '(');
797  OS << ")";
798  }
799 }
800 
801 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) {
802  if (!Node->varlist_empty()) {
803  OS << "lastprivate";
804  VisitOMPClauseList(Node, '(');
805  OS << ")";
806  }
807 }
808 
809 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) {
810  if (!Node->varlist_empty()) {
811  OS << "shared";
812  VisitOMPClauseList(Node, '(');
813  OS << ")";
814  }
815 }
816 
817 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) {
818  if (!Node->varlist_empty()) {
819  OS << "reduction(";
820  NestedNameSpecifier *QualifierLoc =
824  if (QualifierLoc == nullptr && OOK != OO_None) {
825  // Print reduction identifier in C format
826  OS << getOperatorSpelling(OOK);
827  } else {
828  // Use C++ format
829  if (QualifierLoc != nullptr)
830  QualifierLoc->print(OS, Policy);
831  OS << Node->getNameInfo();
832  }
833  OS << ":";
834  VisitOMPClauseList(Node, ' ');
835  OS << ")";
836  }
837 }
838 
839 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) {
840  if (!Node->varlist_empty()) {
841  OS << "linear";
842  if (Node->getModifierLoc().isValid()) {
843  OS << '('
844  << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier());
845  }
846  VisitOMPClauseList(Node, '(');
847  if (Node->getModifierLoc().isValid())
848  OS << ')';
849  if (Node->getStep() != nullptr) {
850  OS << ": ";
851  Node->getStep()->printPretty(OS, nullptr, Policy, 0);
852  }
853  OS << ")";
854  }
855 }
856 
857 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) {
858  if (!Node->varlist_empty()) {
859  OS << "aligned";
860  VisitOMPClauseList(Node, '(');
861  if (Node->getAlignment() != nullptr) {
862  OS << ": ";
863  Node->getAlignment()->printPretty(OS, nullptr, Policy, 0);
864  }
865  OS << ")";
866  }
867 }
868 
869 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) {
870  if (!Node->varlist_empty()) {
871  OS << "copyin";
872  VisitOMPClauseList(Node, '(');
873  OS << ")";
874  }
875 }
876 
877 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) {
878  if (!Node->varlist_empty()) {
879  OS << "copyprivate";
880  VisitOMPClauseList(Node, '(');
881  OS << ")";
882  }
883 }
884 
885 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) {
886  if (!Node->varlist_empty()) {
887  VisitOMPClauseList(Node, '(');
888  OS << ")";
889  }
890 }
891 
892 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) {
893  OS << "depend(";
894  OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(),
895  Node->getDependencyKind());
896  if (!Node->varlist_empty()) {
897  OS << " :";
898  VisitOMPClauseList(Node, ' ');
899  }
900  OS << ")";
901 }
902 
903 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) {
904  if (!Node->varlist_empty()) {
905  OS << "map(";
906  if (Node->getMapType() != OMPC_MAP_unknown) {
907  if (Node->getMapTypeModifier() != OMPC_MAP_unknown) {
908  OS << getOpenMPSimpleClauseTypeName(OMPC_map,
909  Node->getMapTypeModifier());
910  OS << ',';
911  }
912  OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType());
913  OS << ':';
914  }
915  VisitOMPClauseList(Node, ' ');
916  OS << ")";
917  }
918 }
919 
920 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) {
921  if (!Node->varlist_empty()) {
922  OS << "to";
923  VisitOMPClauseList(Node, '(');
924  OS << ")";
925  }
926 }
927 
928 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) {
929  if (!Node->varlist_empty()) {
930  OS << "from";
931  VisitOMPClauseList(Node, '(');
932  OS << ")";
933  }
934 }
935 
936 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) {
937  OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName(
938  OMPC_dist_schedule, Node->getDistScheduleKind());
939  if (auto *E = Node->getChunkSize()) {
940  OS << ", ";
941  E->printPretty(OS, nullptr, Policy);
942  }
943  OS << ")";
944 }
945 
946 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) {
947  OS << "defaultmap(";
948  OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
949  Node->getDefaultmapModifier());
950  OS << ": ";
951  OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap,
952  Node->getDefaultmapKind());
953  OS << ")";
954 }
955 
956 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) {
957  if (!Node->varlist_empty()) {
958  OS << "use_device_ptr";
959  VisitOMPClauseList(Node, '(');
960  OS << ")";
961  }
962 }
963 
964 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) {
965  if (!Node->varlist_empty()) {
966  OS << "is_device_ptr";
967  VisitOMPClauseList(Node, '(');
968  OS << ")";
969  }
970 }
971 }
972 
973 //===----------------------------------------------------------------------===//
974 // OpenMP directives printing methods
975 //===----------------------------------------------------------------------===//
976 
977 void StmtPrinter::PrintOMPExecutableDirective(OMPExecutableDirective *S) {
978  OMPClausePrinter Printer(OS, Policy);
979  ArrayRef<OMPClause *> Clauses = S->clauses();
980  for (ArrayRef<OMPClause *>::iterator I = Clauses.begin(), E = Clauses.end();
981  I != E; ++I)
982  if (*I && !(*I)->isImplicit()) {
983  Printer.Visit(*I);
984  OS << ' ';
985  }
986  OS << "\n";
987  if (S->hasAssociatedStmt() && S->getAssociatedStmt()) {
988  assert(isa<CapturedStmt>(S->getAssociatedStmt()) &&
989  "Expected captured statement!");
990  Stmt *CS = cast<CapturedStmt>(S->getAssociatedStmt())->getCapturedStmt();
991  PrintStmt(CS);
992  }
993 }
994 
995 void StmtPrinter::VisitOMPParallelDirective(OMPParallelDirective *Node) {
996  Indent() << "#pragma omp parallel ";
997  PrintOMPExecutableDirective(Node);
998 }
999 
1000 void StmtPrinter::VisitOMPSimdDirective(OMPSimdDirective *Node) {
1001  Indent() << "#pragma omp simd ";
1002  PrintOMPExecutableDirective(Node);
1003 }
1004 
1005 void StmtPrinter::VisitOMPForDirective(OMPForDirective *Node) {
1006  Indent() << "#pragma omp for ";
1007  PrintOMPExecutableDirective(Node);
1008 }
1009 
1010 void StmtPrinter::VisitOMPForSimdDirective(OMPForSimdDirective *Node) {
1011  Indent() << "#pragma omp for simd ";
1012  PrintOMPExecutableDirective(Node);
1013 }
1014 
1015 void StmtPrinter::VisitOMPSectionsDirective(OMPSectionsDirective *Node) {
1016  Indent() << "#pragma omp sections ";
1017  PrintOMPExecutableDirective(Node);
1018 }
1019 
1020 void StmtPrinter::VisitOMPSectionDirective(OMPSectionDirective *Node) {
1021  Indent() << "#pragma omp section";
1022  PrintOMPExecutableDirective(Node);
1023 }
1024 
1025 void StmtPrinter::VisitOMPSingleDirective(OMPSingleDirective *Node) {
1026  Indent() << "#pragma omp single ";
1027  PrintOMPExecutableDirective(Node);
1028 }
1029 
1030 void StmtPrinter::VisitOMPMasterDirective(OMPMasterDirective *Node) {
1031  Indent() << "#pragma omp master";
1032  PrintOMPExecutableDirective(Node);
1033 }
1034 
1035 void StmtPrinter::VisitOMPCriticalDirective(OMPCriticalDirective *Node) {
1036  Indent() << "#pragma omp critical";
1037  if (Node->getDirectiveName().getName()) {
1038  OS << " (";
1039  Node->getDirectiveName().printName(OS);
1040  OS << ")";
1041  }
1042  OS << " ";
1043  PrintOMPExecutableDirective(Node);
1044 }
1045 
1046 void StmtPrinter::VisitOMPParallelForDirective(OMPParallelForDirective *Node) {
1047  Indent() << "#pragma omp parallel for ";
1048  PrintOMPExecutableDirective(Node);
1049 }
1050 
1051 void StmtPrinter::VisitOMPParallelForSimdDirective(
1053  Indent() << "#pragma omp parallel for simd ";
1054  PrintOMPExecutableDirective(Node);
1055 }
1056 
1057 void StmtPrinter::VisitOMPParallelSectionsDirective(
1059  Indent() << "#pragma omp parallel sections ";
1060  PrintOMPExecutableDirective(Node);
1061 }
1062 
1063 void StmtPrinter::VisitOMPTaskDirective(OMPTaskDirective *Node) {
1064  Indent() << "#pragma omp task ";
1065  PrintOMPExecutableDirective(Node);
1066 }
1067 
1068 void StmtPrinter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *Node) {
1069  Indent() << "#pragma omp taskyield";
1070  PrintOMPExecutableDirective(Node);
1071 }
1072 
1073 void StmtPrinter::VisitOMPBarrierDirective(OMPBarrierDirective *Node) {
1074  Indent() << "#pragma omp barrier";
1075  PrintOMPExecutableDirective(Node);
1076 }
1077 
1078 void StmtPrinter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *Node) {
1079  Indent() << "#pragma omp taskwait";
1080  PrintOMPExecutableDirective(Node);
1081 }
1082 
1083 void StmtPrinter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *Node) {
1084  Indent() << "#pragma omp taskgroup";
1085  PrintOMPExecutableDirective(Node);
1086 }
1087 
1088 void StmtPrinter::VisitOMPFlushDirective(OMPFlushDirective *Node) {
1089  Indent() << "#pragma omp flush ";
1090  PrintOMPExecutableDirective(Node);
1091 }
1092 
1093 void StmtPrinter::VisitOMPOrderedDirective(OMPOrderedDirective *Node) {
1094  Indent() << "#pragma omp ordered ";
1095  PrintOMPExecutableDirective(Node);
1096 }
1097 
1098 void StmtPrinter::VisitOMPAtomicDirective(OMPAtomicDirective *Node) {
1099  Indent() << "#pragma omp atomic ";
1100  PrintOMPExecutableDirective(Node);
1101 }
1102 
1103 void StmtPrinter::VisitOMPTargetDirective(OMPTargetDirective *Node) {
1104  Indent() << "#pragma omp target ";
1105  PrintOMPExecutableDirective(Node);
1106 }
1107 
1108 void StmtPrinter::VisitOMPTargetDataDirective(OMPTargetDataDirective *Node) {
1109  Indent() << "#pragma omp target data ";
1110  PrintOMPExecutableDirective(Node);
1111 }
1112 
1113 void StmtPrinter::VisitOMPTargetEnterDataDirective(
1115  Indent() << "#pragma omp target enter data ";
1116  PrintOMPExecutableDirective(Node);
1117 }
1118 
1119 void StmtPrinter::VisitOMPTargetExitDataDirective(
1121  Indent() << "#pragma omp target exit data ";
1122  PrintOMPExecutableDirective(Node);
1123 }
1124 
1125 void StmtPrinter::VisitOMPTargetParallelDirective(
1127  Indent() << "#pragma omp target parallel ";
1128  PrintOMPExecutableDirective(Node);
1129 }
1130 
1131 void StmtPrinter::VisitOMPTargetParallelForDirective(
1133  Indent() << "#pragma omp target parallel for ";
1134  PrintOMPExecutableDirective(Node);
1135 }
1136 
1137 void StmtPrinter::VisitOMPTeamsDirective(OMPTeamsDirective *Node) {
1138  Indent() << "#pragma omp teams ";
1139  PrintOMPExecutableDirective(Node);
1140 }
1141 
1142 void StmtPrinter::VisitOMPCancellationPointDirective(
1144  Indent() << "#pragma omp cancellation point "
1146  PrintOMPExecutableDirective(Node);
1147 }
1148 
1149 void StmtPrinter::VisitOMPCancelDirective(OMPCancelDirective *Node) {
1150  Indent() << "#pragma omp cancel "
1151  << getOpenMPDirectiveName(Node->getCancelRegion()) << " ";
1152  PrintOMPExecutableDirective(Node);
1153 }
1154 
1155 void StmtPrinter::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *Node) {
1156  Indent() << "#pragma omp taskloop ";
1157  PrintOMPExecutableDirective(Node);
1158 }
1159 
1160 void StmtPrinter::VisitOMPTaskLoopSimdDirective(
1161  OMPTaskLoopSimdDirective *Node) {
1162  Indent() << "#pragma omp taskloop simd ";
1163  PrintOMPExecutableDirective(Node);
1164 }
1165 
1166 void StmtPrinter::VisitOMPDistributeDirective(OMPDistributeDirective *Node) {
1167  Indent() << "#pragma omp distribute ";
1168  PrintOMPExecutableDirective(Node);
1169 }
1170 
1171 void StmtPrinter::VisitOMPTargetUpdateDirective(
1172  OMPTargetUpdateDirective *Node) {
1173  Indent() << "#pragma omp target update ";
1174  PrintOMPExecutableDirective(Node);
1175 }
1176 
1177 void StmtPrinter::VisitOMPDistributeParallelForDirective(
1179  Indent() << "#pragma omp distribute parallel for ";
1180  PrintOMPExecutableDirective(Node);
1181 }
1182 
1183 void StmtPrinter::VisitOMPDistributeParallelForSimdDirective(
1185  Indent() << "#pragma omp distribute parallel for simd ";
1186  PrintOMPExecutableDirective(Node);
1187 }
1188 
1189 void StmtPrinter::VisitOMPDistributeSimdDirective(
1191  Indent() << "#pragma omp distribute simd ";
1192  PrintOMPExecutableDirective(Node);
1193 }
1194 
1195 void StmtPrinter::VisitOMPTargetParallelForSimdDirective(
1197  Indent() << "#pragma omp target parallel for simd ";
1198  PrintOMPExecutableDirective(Node);
1199 }
1200 
1201 //===----------------------------------------------------------------------===//
1202 // Expr printing methods.
1203 //===----------------------------------------------------------------------===//
1204 
1205 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
1206  if (auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
1207  OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
1208  return;
1209  }
1210  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1211  Qualifier->print(OS, Policy);
1212  if (Node->hasTemplateKeyword())
1213  OS << "template ";
1214  OS << Node->getNameInfo();
1215  if (Node->hasExplicitTemplateArgs())
1217  OS, Node->template_arguments(), Policy);
1218 }
1219 
1220 void StmtPrinter::VisitDependentScopeDeclRefExpr(
1221  DependentScopeDeclRefExpr *Node) {
1222  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1223  Qualifier->print(OS, Policy);
1224  if (Node->hasTemplateKeyword())
1225  OS << "template ";
1226  OS << Node->getNameInfo();
1227  if (Node->hasExplicitTemplateArgs())
1229  OS, Node->template_arguments(), Policy);
1230 }
1231 
1232 void StmtPrinter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *Node) {
1233  if (Node->getQualifier())
1234  Node->getQualifier()->print(OS, Policy);
1235  if (Node->hasTemplateKeyword())
1236  OS << "template ";
1237  OS << Node->getNameInfo();
1238  if (Node->hasExplicitTemplateArgs())
1240  OS, Node->template_arguments(), Policy);
1241 }
1242 
1243 void StmtPrinter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *Node) {
1244  if (Node->getBase()) {
1245  PrintExpr(Node->getBase());
1246  OS << (Node->isArrow() ? "->" : ".");
1247  }
1248  OS << *Node->getDecl();
1249 }
1250 
1251 void StmtPrinter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *Node) {
1252  if (Node->isSuperReceiver())
1253  OS << "super.";
1254  else if (Node->isObjectReceiver() && Node->getBase()) {
1255  PrintExpr(Node->getBase());
1256  OS << ".";
1257  } else if (Node->isClassReceiver() && Node->getClassReceiver()) {
1258  OS << Node->getClassReceiver()->getName() << ".";
1259  }
1260 
1261  if (Node->isImplicitProperty())
1263  else
1264  OS << Node->getExplicitProperty()->getName();
1265 }
1266 
1267 void StmtPrinter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *Node) {
1268 
1269  PrintExpr(Node->getBaseExpr());
1270  OS << "[";
1271  PrintExpr(Node->getKeyExpr());
1272  OS << "]";
1273 }
1274 
1275 void StmtPrinter::VisitPredefinedExpr(PredefinedExpr *Node) {
1277 }
1278 
1279 void StmtPrinter::VisitCharacterLiteral(CharacterLiteral *Node) {
1280  unsigned value = Node->getValue();
1281 
1282  switch (Node->getKind()) {
1283  case CharacterLiteral::Ascii: break; // no prefix.
1284  case CharacterLiteral::Wide: OS << 'L'; break;
1285  case CharacterLiteral::UTF8: OS << "u8"; break;
1286  case CharacterLiteral::UTF16: OS << 'u'; break;
1287  case CharacterLiteral::UTF32: OS << 'U'; break;
1288  }
1289 
1290  switch (value) {
1291  case '\\':
1292  OS << "'\\\\'";
1293  break;
1294  case '\'':
1295  OS << "'\\''";
1296  break;
1297  case '\a':
1298  // TODO: K&R: the meaning of '\\a' is different in traditional C
1299  OS << "'\\a'";
1300  break;
1301  case '\b':
1302  OS << "'\\b'";
1303  break;
1304  // Nonstandard escape sequence.
1305  /*case '\e':
1306  OS << "'\\e'";
1307  break;*/
1308  case '\f':
1309  OS << "'\\f'";
1310  break;
1311  case '\n':
1312  OS << "'\\n'";
1313  break;
1314  case '\r':
1315  OS << "'\\r'";
1316  break;
1317  case '\t':
1318  OS << "'\\t'";
1319  break;
1320  case '\v':
1321  OS << "'\\v'";
1322  break;
1323  default:
1324  // A character literal might be sign-extended, which
1325  // would result in an invalid \U escape sequence.
1326  // FIXME: multicharacter literals such as '\xFF\xFF\xFF\xFF'
1327  // are not correctly handled.
1328  if ((value & ~0xFFu) == ~0xFFu && Node->getKind() == CharacterLiteral::Ascii)
1329  value &= 0xFFu;
1330  if (value < 256 && isPrintable((unsigned char)value))
1331  OS << "'" << (char)value << "'";
1332  else if (value < 256)
1333  OS << "'\\x" << llvm::format("%02x", value) << "'";
1334  else if (value <= 0xFFFF)
1335  OS << "'\\u" << llvm::format("%04x", value) << "'";
1336  else
1337  OS << "'\\U" << llvm::format("%08x", value) << "'";
1338  }
1339 }
1340 
1341 void StmtPrinter::VisitIntegerLiteral(IntegerLiteral *Node) {
1342  bool isSigned = Node->getType()->isSignedIntegerType();
1343  OS << Node->getValue().toString(10, isSigned);
1344 
1345  // Emit suffixes. Integer literals are always a builtin integer type.
1346  switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1347  default: llvm_unreachable("Unexpected type for integer literal!");
1348  case BuiltinType::Char_S:
1349  case BuiltinType::Char_U: OS << "i8"; break;
1350  case BuiltinType::UChar: OS << "Ui8"; break;
1351  case BuiltinType::Short: OS << "i16"; break;
1352  case BuiltinType::UShort: OS << "Ui16"; break;
1353  case BuiltinType::Int: break; // no suffix.
1354  case BuiltinType::UInt: OS << 'U'; break;
1355  case BuiltinType::Long: OS << 'L'; break;
1356  case BuiltinType::ULong: OS << "UL"; break;
1357  case BuiltinType::LongLong: OS << "LL"; break;
1358  case BuiltinType::ULongLong: OS << "ULL"; break;
1359  }
1360 }
1361 
1362 static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
1363  bool PrintSuffix) {
1364  SmallString<16> Str;
1365  Node->getValue().toString(Str);
1366  OS << Str;
1367  if (Str.find_first_not_of("-0123456789") == StringRef::npos)
1368  OS << '.'; // Trailing dot in order to separate from ints.
1369 
1370  if (!PrintSuffix)
1371  return;
1372 
1373  // Emit suffixes. Float literals are always a builtin float type.
1374  switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
1375  default: llvm_unreachable("Unexpected type for float literal!");
1376  case BuiltinType::Half: break; // FIXME: suffix?
1377  case BuiltinType::Double: break; // no suffix.
1378  case BuiltinType::Float: OS << 'F'; break;
1379  case BuiltinType::LongDouble: OS << 'L'; break;
1380  case BuiltinType::Float128: OS << 'Q'; break;
1381  }
1382 }
1383 
1384 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
1385  PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
1386 }
1387 
1388 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
1389  PrintExpr(Node->getSubExpr());
1390  OS << "i";
1391 }
1392 
1393 void StmtPrinter::VisitStringLiteral(StringLiteral *Str) {
1394  Str->outputString(OS);
1395 }
1396 void StmtPrinter::VisitParenExpr(ParenExpr *Node) {
1397  OS << "(";
1398  PrintExpr(Node->getSubExpr());
1399  OS << ")";
1400 }
1401 void StmtPrinter::VisitUnaryOperator(UnaryOperator *Node) {
1402  if (!Node->isPostfix()) {
1403  OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1404 
1405  // Print a space if this is an "identifier operator" like __real, or if
1406  // it might be concatenated incorrectly like '+'.
1407  switch (Node->getOpcode()) {
1408  default: break;
1409  case UO_Real:
1410  case UO_Imag:
1411  case UO_Extension:
1412  OS << ' ';
1413  break;
1414  case UO_Plus:
1415  case UO_Minus:
1416  if (isa<UnaryOperator>(Node->getSubExpr()))
1417  OS << ' ';
1418  break;
1419  }
1420  }
1421  PrintExpr(Node->getSubExpr());
1422 
1423  if (Node->isPostfix())
1424  OS << UnaryOperator::getOpcodeStr(Node->getOpcode());
1425 }
1426 
1427 void StmtPrinter::VisitOffsetOfExpr(OffsetOfExpr *Node) {
1428  OS << "__builtin_offsetof(";
1429  Node->getTypeSourceInfo()->getType().print(OS, Policy);
1430  OS << ", ";
1431  bool PrintedSomething = false;
1432  for (unsigned i = 0, n = Node->getNumComponents(); i < n; ++i) {
1433  OffsetOfNode ON = Node->getComponent(i);
1434  if (ON.getKind() == OffsetOfNode::Array) {
1435  // Array node
1436  OS << "[";
1437  PrintExpr(Node->getIndexExpr(ON.getArrayExprIndex()));
1438  OS << "]";
1439  PrintedSomething = true;
1440  continue;
1441  }
1442 
1443  // Skip implicit base indirections.
1444  if (ON.getKind() == OffsetOfNode::Base)
1445  continue;
1446 
1447  // Field or identifier node.
1448  IdentifierInfo *Id = ON.getFieldName();
1449  if (!Id)
1450  continue;
1451 
1452  if (PrintedSomething)
1453  OS << ".";
1454  else
1455  PrintedSomething = true;
1456  OS << Id->getName();
1457  }
1458  OS << ")";
1459 }
1460 
1461 void StmtPrinter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *Node){
1462  switch(Node->getKind()) {
1463  case UETT_SizeOf:
1464  OS << "sizeof";
1465  break;
1466  case UETT_AlignOf:
1467  if (Policy.Alignof)
1468  OS << "alignof";
1469  else if (Policy.UnderscoreAlignof)
1470  OS << "_Alignof";
1471  else
1472  OS << "__alignof";
1473  break;
1474  case UETT_VecStep:
1475  OS << "vec_step";
1476  break;
1478  OS << "__builtin_omp_required_simd_align";
1479  break;
1480  }
1481  if (Node->isArgumentType()) {
1482  OS << '(';
1483  Node->getArgumentType().print(OS, Policy);
1484  OS << ')';
1485  } else {
1486  OS << " ";
1487  PrintExpr(Node->getArgumentExpr());
1488  }
1489 }
1490 
1491 void StmtPrinter::VisitGenericSelectionExpr(GenericSelectionExpr *Node) {
1492  OS << "_Generic(";
1493  PrintExpr(Node->getControllingExpr());
1494  for (unsigned i = 0; i != Node->getNumAssocs(); ++i) {
1495  OS << ", ";
1496  QualType T = Node->getAssocType(i);
1497  if (T.isNull())
1498  OS << "default";
1499  else
1500  T.print(OS, Policy);
1501  OS << ": ";
1502  PrintExpr(Node->getAssocExpr(i));
1503  }
1504  OS << ")";
1505 }
1506 
1507 void StmtPrinter::VisitArraySubscriptExpr(ArraySubscriptExpr *Node) {
1508  PrintExpr(Node->getLHS());
1509  OS << "[";
1510  PrintExpr(Node->getRHS());
1511  OS << "]";
1512 }
1513 
1514 void StmtPrinter::VisitOMPArraySectionExpr(OMPArraySectionExpr *Node) {
1515  PrintExpr(Node->getBase());
1516  OS << "[";
1517  if (Node->getLowerBound())
1518  PrintExpr(Node->getLowerBound());
1519  if (Node->getColonLoc().isValid()) {
1520  OS << ":";
1521  if (Node->getLength())
1522  PrintExpr(Node->getLength());
1523  }
1524  OS << "]";
1525 }
1526 
1527 void StmtPrinter::PrintCallArgs(CallExpr *Call) {
1528  for (unsigned i = 0, e = Call->getNumArgs(); i != e; ++i) {
1529  if (isa<CXXDefaultArgExpr>(Call->getArg(i))) {
1530  // Don't print any defaulted arguments
1531  break;
1532  }
1533 
1534  if (i) OS << ", ";
1535  PrintExpr(Call->getArg(i));
1536  }
1537 }
1538 
1539 void StmtPrinter::VisitCallExpr(CallExpr *Call) {
1540  PrintExpr(Call->getCallee());
1541  OS << "(";
1542  PrintCallArgs(Call);
1543  OS << ")";
1544 }
1545 void StmtPrinter::VisitMemberExpr(MemberExpr *Node) {
1546  // FIXME: Suppress printing implicit bases (like "this")
1547  PrintExpr(Node->getBase());
1548 
1549  MemberExpr *ParentMember = dyn_cast<MemberExpr>(Node->getBase());
1550  FieldDecl *ParentDecl = ParentMember
1551  ? dyn_cast<FieldDecl>(ParentMember->getMemberDecl()) : nullptr;
1552 
1553  if (!ParentDecl || !ParentDecl->isAnonymousStructOrUnion())
1554  OS << (Node->isArrow() ? "->" : ".");
1555 
1556  if (FieldDecl *FD = dyn_cast<FieldDecl>(Node->getMemberDecl()))
1557  if (FD->isAnonymousStructOrUnion())
1558  return;
1559 
1560  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
1561  Qualifier->print(OS, Policy);
1562  if (Node->hasTemplateKeyword())
1563  OS << "template ";
1564  OS << Node->getMemberNameInfo();
1565  if (Node->hasExplicitTemplateArgs())
1567  OS, Node->template_arguments(), Policy);
1568 }
1569 void StmtPrinter::VisitObjCIsaExpr(ObjCIsaExpr *Node) {
1570  PrintExpr(Node->getBase());
1571  OS << (Node->isArrow() ? "->isa" : ".isa");
1572 }
1573 
1574 void StmtPrinter::VisitExtVectorElementExpr(ExtVectorElementExpr *Node) {
1575  PrintExpr(Node->getBase());
1576  OS << ".";
1577  OS << Node->getAccessor().getName();
1578 }
1579 void StmtPrinter::VisitCStyleCastExpr(CStyleCastExpr *Node) {
1580  OS << '(';
1581  Node->getTypeAsWritten().print(OS, Policy);
1582  OS << ')';
1583  PrintExpr(Node->getSubExpr());
1584 }
1585 void StmtPrinter::VisitCompoundLiteralExpr(CompoundLiteralExpr *Node) {
1586  OS << '(';
1587  Node->getType().print(OS, Policy);
1588  OS << ')';
1589  PrintExpr(Node->getInitializer());
1590 }
1591 void StmtPrinter::VisitImplicitCastExpr(ImplicitCastExpr *Node) {
1592  // No need to print anything, simply forward to the subexpression.
1593  PrintExpr(Node->getSubExpr());
1594 }
1595 void StmtPrinter::VisitBinaryOperator(BinaryOperator *Node) {
1596  PrintExpr(Node->getLHS());
1597  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1598  PrintExpr(Node->getRHS());
1599 }
1600 void StmtPrinter::VisitCompoundAssignOperator(CompoundAssignOperator *Node) {
1601  PrintExpr(Node->getLHS());
1602  OS << " " << BinaryOperator::getOpcodeStr(Node->getOpcode()) << " ";
1603  PrintExpr(Node->getRHS());
1604 }
1605 void StmtPrinter::VisitConditionalOperator(ConditionalOperator *Node) {
1606  PrintExpr(Node->getCond());
1607  OS << " ? ";
1608  PrintExpr(Node->getLHS());
1609  OS << " : ";
1610  PrintExpr(Node->getRHS());
1611 }
1612 
1613 // GNU extensions.
1614 
1615 void
1616 StmtPrinter::VisitBinaryConditionalOperator(BinaryConditionalOperator *Node) {
1617  PrintExpr(Node->getCommon());
1618  OS << " ?: ";
1619  PrintExpr(Node->getFalseExpr());
1620 }
1621 void StmtPrinter::VisitAddrLabelExpr(AddrLabelExpr *Node) {
1622  OS << "&&" << Node->getLabel()->getName();
1623 }
1624 
1625 void StmtPrinter::VisitStmtExpr(StmtExpr *E) {
1626  OS << "(";
1627  PrintRawCompoundStmt(E->getSubStmt());
1628  OS << ")";
1629 }
1630 
1631 void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
1632  OS << "__builtin_choose_expr(";
1633  PrintExpr(Node->getCond());
1634  OS << ", ";
1635  PrintExpr(Node->getLHS());
1636  OS << ", ";
1637  PrintExpr(Node->getRHS());
1638  OS << ")";
1639 }
1640 
1641 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
1642  OS << "__null";
1643 }
1644 
1645 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
1646  OS << "__builtin_shufflevector(";
1647  for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
1648  if (i) OS << ", ";
1649  PrintExpr(Node->getExpr(i));
1650  }
1651  OS << ")";
1652 }
1653 
1654 void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) {
1655  OS << "__builtin_convertvector(";
1656  PrintExpr(Node->getSrcExpr());
1657  OS << ", ";
1658  Node->getType().print(OS, Policy);
1659  OS << ")";
1660 }
1661 
1662 void StmtPrinter::VisitInitListExpr(InitListExpr* Node) {
1663  if (Node->getSyntacticForm()) {
1664  Visit(Node->getSyntacticForm());
1665  return;
1666  }
1667 
1668  OS << "{";
1669  for (unsigned i = 0, e = Node->getNumInits(); i != e; ++i) {
1670  if (i) OS << ", ";
1671  if (Node->getInit(i))
1672  PrintExpr(Node->getInit(i));
1673  else
1674  OS << "{}";
1675  }
1676  OS << "}";
1677 }
1678 
1679 void StmtPrinter::VisitParenListExpr(ParenListExpr* Node) {
1680  OS << "(";
1681  for (unsigned i = 0, e = Node->getNumExprs(); i != e; ++i) {
1682  if (i) OS << ", ";
1683  PrintExpr(Node->getExpr(i));
1684  }
1685  OS << ")";
1686 }
1687 
1688 void StmtPrinter::VisitDesignatedInitExpr(DesignatedInitExpr *Node) {
1689  bool NeedsEquals = true;
1690  for (const DesignatedInitExpr::Designator &D : Node->designators()) {
1691  if (D.isFieldDesignator()) {
1692  if (D.getDotLoc().isInvalid()) {
1693  if (IdentifierInfo *II = D.getFieldName()) {
1694  OS << II->getName() << ":";
1695  NeedsEquals = false;
1696  }
1697  } else {
1698  OS << "." << D.getFieldName()->getName();
1699  }
1700  } else {
1701  OS << "[";
1702  if (D.isArrayDesignator()) {
1703  PrintExpr(Node->getArrayIndex(D));
1704  } else {
1705  PrintExpr(Node->getArrayRangeStart(D));
1706  OS << " ... ";
1707  PrintExpr(Node->getArrayRangeEnd(D));
1708  }
1709  OS << "]";
1710  }
1711  }
1712 
1713  if (NeedsEquals)
1714  OS << " = ";
1715  else
1716  OS << " ";
1717  PrintExpr(Node->getInit());
1718 }
1719 
1720 void StmtPrinter::VisitDesignatedInitUpdateExpr(
1721  DesignatedInitUpdateExpr *Node) {
1722  OS << "{";
1723  OS << "/*base*/";
1724  PrintExpr(Node->getBase());
1725  OS << ", ";
1726 
1727  OS << "/*updater*/";
1728  PrintExpr(Node->getUpdater());
1729  OS << "}";
1730 }
1731 
1732 void StmtPrinter::VisitNoInitExpr(NoInitExpr *Node) {
1733  OS << "/*no init*/";
1734 }
1735 
1736 void StmtPrinter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *Node) {
1737  if (Node->getType()->getAsCXXRecordDecl()) {
1738  OS << "/*implicit*/";
1739  Node->getType().print(OS, Policy);
1740  OS << "()";
1741  } else {
1742  OS << "/*implicit*/(";
1743  Node->getType().print(OS, Policy);
1744  OS << ')';
1745  if (Node->getType()->isRecordType())
1746  OS << "{}";
1747  else
1748  OS << 0;
1749  }
1750 }
1751 
1752 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
1753  OS << "__builtin_va_arg(";
1754  PrintExpr(Node->getSubExpr());
1755  OS << ", ";
1756  Node->getType().print(OS, Policy);
1757  OS << ")";
1758 }
1759 
1760 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
1761  PrintExpr(Node->getSyntacticForm());
1762 }
1763 
1764 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
1765  const char *Name = nullptr;
1766  switch (Node->getOp()) {
1767 #define BUILTIN(ID, TYPE, ATTRS)
1768 #define ATOMIC_BUILTIN(ID, TYPE, ATTRS) \
1769  case AtomicExpr::AO ## ID: \
1770  Name = #ID "("; \
1771  break;
1772 #include "clang/Basic/Builtins.def"
1773  }
1774  OS << Name;
1775 
1776  // AtomicExpr stores its subexpressions in a permuted order.
1777  PrintExpr(Node->getPtr());
1778  if (Node->getOp() != AtomicExpr::AO__c11_atomic_load &&
1779  Node->getOp() != AtomicExpr::AO__atomic_load_n) {
1780  OS << ", ";
1781  PrintExpr(Node->getVal1());
1782  }
1783  if (Node->getOp() == AtomicExpr::AO__atomic_exchange ||
1784  Node->isCmpXChg()) {
1785  OS << ", ";
1786  PrintExpr(Node->getVal2());
1787  }
1788  if (Node->getOp() == AtomicExpr::AO__atomic_compare_exchange ||
1789  Node->getOp() == AtomicExpr::AO__atomic_compare_exchange_n) {
1790  OS << ", ";
1791  PrintExpr(Node->getWeak());
1792  }
1793  if (Node->getOp() != AtomicExpr::AO__c11_atomic_init) {
1794  OS << ", ";
1795  PrintExpr(Node->getOrder());
1796  }
1797  if (Node->isCmpXChg()) {
1798  OS << ", ";
1799  PrintExpr(Node->getOrderFail());
1800  }
1801  OS << ")";
1802 }
1803 
1804 // C++
1805 void StmtPrinter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *Node) {
1806  const char *OpStrings[NUM_OVERLOADED_OPERATORS] = {
1807  "",
1808 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
1809  Spelling,
1810 #include "clang/Basic/OperatorKinds.def"
1811  };
1812 
1814  if (Kind == OO_PlusPlus || Kind == OO_MinusMinus) {
1815  if (Node->getNumArgs() == 1) {
1816  OS << OpStrings[Kind] << ' ';
1817  PrintExpr(Node->getArg(0));
1818  } else {
1819  PrintExpr(Node->getArg(0));
1820  OS << ' ' << OpStrings[Kind];
1821  }
1822  } else if (Kind == OO_Arrow) {
1823  PrintExpr(Node->getArg(0));
1824  } else if (Kind == OO_Call) {
1825  PrintExpr(Node->getArg(0));
1826  OS << '(';
1827  for (unsigned ArgIdx = 1; ArgIdx < Node->getNumArgs(); ++ArgIdx) {
1828  if (ArgIdx > 1)
1829  OS << ", ";
1830  if (!isa<CXXDefaultArgExpr>(Node->getArg(ArgIdx)))
1831  PrintExpr(Node->getArg(ArgIdx));
1832  }
1833  OS << ')';
1834  } else if (Kind == OO_Subscript) {
1835  PrintExpr(Node->getArg(0));
1836  OS << '[';
1837  PrintExpr(Node->getArg(1));
1838  OS << ']';
1839  } else if (Node->getNumArgs() == 1) {
1840  OS << OpStrings[Kind] << ' ';
1841  PrintExpr(Node->getArg(0));
1842  } else if (Node->getNumArgs() == 2) {
1843  PrintExpr(Node->getArg(0));
1844  OS << ' ' << OpStrings[Kind] << ' ';
1845  PrintExpr(Node->getArg(1));
1846  } else {
1847  llvm_unreachable("unknown overloaded operator");
1848  }
1849 }
1850 
1851 void StmtPrinter::VisitCXXMemberCallExpr(CXXMemberCallExpr *Node) {
1852  // If we have a conversion operator call only print the argument.
1853  CXXMethodDecl *MD = Node->getMethodDecl();
1854  if (MD && isa<CXXConversionDecl>(MD)) {
1855  PrintExpr(Node->getImplicitObjectArgument());
1856  return;
1857  }
1858  VisitCallExpr(cast<CallExpr>(Node));
1859 }
1860 
1861 void StmtPrinter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *Node) {
1862  PrintExpr(Node->getCallee());
1863  OS << "<<<";
1864  PrintCallArgs(Node->getConfig());
1865  OS << ">>>(";
1866  PrintCallArgs(Node);
1867  OS << ")";
1868 }
1869 
1870 void StmtPrinter::VisitCXXNamedCastExpr(CXXNamedCastExpr *Node) {
1871  OS << Node->getCastName() << '<';
1872  Node->getTypeAsWritten().print(OS, Policy);
1873  OS << ">(";
1874  PrintExpr(Node->getSubExpr());
1875  OS << ")";
1876 }
1877 
1878 void StmtPrinter::VisitCXXStaticCastExpr(CXXStaticCastExpr *Node) {
1879  VisitCXXNamedCastExpr(Node);
1880 }
1881 
1882 void StmtPrinter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *Node) {
1883  VisitCXXNamedCastExpr(Node);
1884 }
1885 
1886 void StmtPrinter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *Node) {
1887  VisitCXXNamedCastExpr(Node);
1888 }
1889 
1890 void StmtPrinter::VisitCXXConstCastExpr(CXXConstCastExpr *Node) {
1891  VisitCXXNamedCastExpr(Node);
1892 }
1893 
1894 void StmtPrinter::VisitCXXTypeidExpr(CXXTypeidExpr *Node) {
1895  OS << "typeid(";
1896  if (Node->isTypeOperand()) {
1897  Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1898  } else {
1899  PrintExpr(Node->getExprOperand());
1900  }
1901  OS << ")";
1902 }
1903 
1904 void StmtPrinter::VisitCXXUuidofExpr(CXXUuidofExpr *Node) {
1905  OS << "__uuidof(";
1906  if (Node->isTypeOperand()) {
1907  Node->getTypeOperandSourceInfo()->getType().print(OS, Policy);
1908  } else {
1909  PrintExpr(Node->getExprOperand());
1910  }
1911  OS << ")";
1912 }
1913 
1914 void StmtPrinter::VisitMSPropertyRefExpr(MSPropertyRefExpr *Node) {
1915  PrintExpr(Node->getBaseExpr());
1916  if (Node->isArrow())
1917  OS << "->";
1918  else
1919  OS << ".";
1920  if (NestedNameSpecifier *Qualifier =
1922  Qualifier->print(OS, Policy);
1923  OS << Node->getPropertyDecl()->getDeclName();
1924 }
1925 
1926 void StmtPrinter::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *Node) {
1927  PrintExpr(Node->getBase());
1928  OS << "[";
1929  PrintExpr(Node->getIdx());
1930  OS << "]";
1931 }
1932 
1933 void StmtPrinter::VisitUserDefinedLiteral(UserDefinedLiteral *Node) {
1934  switch (Node->getLiteralOperatorKind()) {
1936  OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
1937  break;
1939  DeclRefExpr *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
1940  const TemplateArgumentList *Args =
1941  cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
1942  assert(Args);
1943 
1944  if (Args->size() != 1) {
1945  OS << "operator\"\"" << Node->getUDSuffix()->getName();
1947  OS, Args->asArray(), Policy);
1948  OS << "()";
1949  return;
1950  }
1951 
1952  const TemplateArgument &Pack = Args->get(0);
1953  for (const auto &P : Pack.pack_elements()) {
1954  char C = (char)P.getAsIntegral().getZExtValue();
1955  OS << C;
1956  }
1957  break;
1958  }
1960  // Print integer literal without suffix.
1961  IntegerLiteral *Int = cast<IntegerLiteral>(Node->getCookedLiteral());
1962  OS << Int->getValue().toString(10, /*isSigned*/false);
1963  break;
1964  }
1966  // Print floating literal without suffix.
1967  FloatingLiteral *Float = cast<FloatingLiteral>(Node->getCookedLiteral());
1968  PrintFloatingLiteral(OS, Float, /*PrintSuffix=*/false);
1969  break;
1970  }
1973  PrintExpr(Node->getCookedLiteral());
1974  break;
1975  }
1976  OS << Node->getUDSuffix()->getName();
1977 }
1978 
1979 void StmtPrinter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *Node) {
1980  OS << (Node->getValue() ? "true" : "false");
1981 }
1982 
1983 void StmtPrinter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *Node) {
1984  OS << "nullptr";
1985 }
1986 
1987 void StmtPrinter::VisitCXXThisExpr(CXXThisExpr *Node) {
1988  OS << "this";
1989 }
1990 
1991 void StmtPrinter::VisitCXXThrowExpr(CXXThrowExpr *Node) {
1992  if (!Node->getSubExpr())
1993  OS << "throw";
1994  else {
1995  OS << "throw ";
1996  PrintExpr(Node->getSubExpr());
1997  }
1998 }
1999 
2000 void StmtPrinter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *Node) {
2001  // Nothing to print: we picked up the default argument.
2002 }
2003 
2004 void StmtPrinter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *Node) {
2005  // Nothing to print: we picked up the default initializer.
2006 }
2007 
2008 void StmtPrinter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *Node) {
2009  Node->getType().print(OS, Policy);
2010  // If there are no parens, this is list-initialization, and the braces are
2011  // part of the syntax of the inner construct.
2012  if (Node->getLParenLoc().isValid())
2013  OS << "(";
2014  PrintExpr(Node->getSubExpr());
2015  if (Node->getLParenLoc().isValid())
2016  OS << ")";
2017 }
2018 
2019 void StmtPrinter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *Node) {
2020  PrintExpr(Node->getSubExpr());
2021 }
2022 
2023 void StmtPrinter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *Node) {
2024  Node->getType().print(OS, Policy);
2025  if (Node->isStdInitListInitialization())
2026  /* Nothing to do; braces are part of creating the std::initializer_list. */;
2027  else if (Node->isListInitialization())
2028  OS << "{";
2029  else
2030  OS << "(";
2032  ArgEnd = Node->arg_end();
2033  Arg != ArgEnd; ++Arg) {
2034  if ((*Arg)->isDefaultArgument())
2035  break;
2036  if (Arg != Node->arg_begin())
2037  OS << ", ";
2038  PrintExpr(*Arg);
2039  }
2040  if (Node->isStdInitListInitialization())
2041  /* See above. */;
2042  else if (Node->isListInitialization())
2043  OS << "}";
2044  else
2045  OS << ")";
2046 }
2047 
2048 void StmtPrinter::VisitLambdaExpr(LambdaExpr *Node) {
2049  OS << '[';
2050  bool NeedComma = false;
2051  switch (Node->getCaptureDefault()) {
2052  case LCD_None:
2053  break;
2054 
2055  case LCD_ByCopy:
2056  OS << '=';
2057  NeedComma = true;
2058  break;
2059 
2060  case LCD_ByRef:
2061  OS << '&';
2062  NeedComma = true;
2063  break;
2064  }
2066  CEnd = Node->explicit_capture_end();
2067  C != CEnd;
2068  ++C) {
2069  if (NeedComma)
2070  OS << ", ";
2071  NeedComma = true;
2072 
2073  switch (C->getCaptureKind()) {
2074  case LCK_This:
2075  OS << "this";
2076  break;
2077  case LCK_StarThis:
2078  OS << "*this";
2079  break;
2080  case LCK_ByRef:
2081  if (Node->getCaptureDefault() != LCD_ByRef || Node->isInitCapture(C))
2082  OS << '&';
2083  OS << C->getCapturedVar()->getName();
2084  break;
2085 
2086  case LCK_ByCopy:
2087  OS << C->getCapturedVar()->getName();
2088  break;
2089  case LCK_VLAType:
2090  llvm_unreachable("VLA type in explicit captures.");
2091  }
2092 
2093  if (Node->isInitCapture(C))
2094  PrintExpr(C->getCapturedVar()->getInit());
2095  }
2096  OS << ']';
2097 
2098  if (Node->hasExplicitParameters()) {
2099  OS << " (";
2100  CXXMethodDecl *Method = Node->getCallOperator();
2101  NeedComma = false;
2102  for (auto P : Method->parameters()) {
2103  if (NeedComma) {
2104  OS << ", ";
2105  } else {
2106  NeedComma = true;
2107  }
2108  std::string ParamStr = P->getNameAsString();
2109  P->getOriginalType().print(OS, Policy, ParamStr);
2110  }
2111  if (Method->isVariadic()) {
2112  if (NeedComma)
2113  OS << ", ";
2114  OS << "...";
2115  }
2116  OS << ')';
2117 
2118  if (Node->isMutable())
2119  OS << " mutable";
2120 
2121  const FunctionProtoType *Proto
2122  = Method->getType()->getAs<FunctionProtoType>();
2123  Proto->printExceptionSpecification(OS, Policy);
2124 
2125  // FIXME: Attributes
2126 
2127  // Print the trailing return type if it was specified in the source.
2128  if (Node->hasExplicitResultType()) {
2129  OS << " -> ";
2130  Proto->getReturnType().print(OS, Policy);
2131  }
2132  }
2133 
2134  // Print the body.
2135  CompoundStmt *Body = Node->getBody();
2136  OS << ' ';
2137  PrintStmt(Body);
2138 }
2139 
2140 void StmtPrinter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *Node) {
2141  if (TypeSourceInfo *TSInfo = Node->getTypeSourceInfo())
2142  TSInfo->getType().print(OS, Policy);
2143  else
2144  Node->getType().print(OS, Policy);
2145  OS << "()";
2146 }
2147 
2148 void StmtPrinter::VisitCXXNewExpr(CXXNewExpr *E) {
2149  if (E->isGlobalNew())
2150  OS << "::";
2151  OS << "new ";
2152  unsigned NumPlace = E->getNumPlacementArgs();
2153  if (NumPlace > 0 && !isa<CXXDefaultArgExpr>(E->getPlacementArg(0))) {
2154  OS << "(";
2155  PrintExpr(E->getPlacementArg(0));
2156  for (unsigned i = 1; i < NumPlace; ++i) {
2157  if (isa<CXXDefaultArgExpr>(E->getPlacementArg(i)))
2158  break;
2159  OS << ", ";
2160  PrintExpr(E->getPlacementArg(i));
2161  }
2162  OS << ") ";
2163  }
2164  if (E->isParenTypeId())
2165  OS << "(";
2166  std::string TypeS;
2167  if (Expr *Size = E->getArraySize()) {
2168  llvm::raw_string_ostream s(TypeS);
2169  s << '[';
2170  Size->printPretty(s, Helper, Policy);
2171  s << ']';
2172  }
2173  E->getAllocatedType().print(OS, Policy, TypeS);
2174  if (E->isParenTypeId())
2175  OS << ")";
2176 
2178  if (InitStyle) {
2179  if (InitStyle == CXXNewExpr::CallInit)
2180  OS << "(";
2181  PrintExpr(E->getInitializer());
2182  if (InitStyle == CXXNewExpr::CallInit)
2183  OS << ")";
2184  }
2185 }
2186 
2187 void StmtPrinter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
2188  if (E->isGlobalDelete())
2189  OS << "::";
2190  OS << "delete ";
2191  if (E->isArrayForm())
2192  OS << "[] ";
2193  PrintExpr(E->getArgument());
2194 }
2195 
2196 void StmtPrinter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
2197  PrintExpr(E->getBase());
2198  if (E->isArrow())
2199  OS << "->";
2200  else
2201  OS << '.';
2202  if (E->getQualifier())
2203  E->getQualifier()->print(OS, Policy);
2204  OS << "~";
2205 
2207  OS << II->getName();
2208  else
2209  E->getDestroyedType().print(OS, Policy);
2210 }
2211 
2212 void StmtPrinter::VisitCXXConstructExpr(CXXConstructExpr *E) {
2214  OS << "{";
2215 
2216  for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
2217  if (isa<CXXDefaultArgExpr>(E->getArg(i))) {
2218  // Don't print any defaulted arguments
2219  break;
2220  }
2221 
2222  if (i) OS << ", ";
2223  PrintExpr(E->getArg(i));
2224  }
2225 
2227  OS << "}";
2228 }
2229 
2230 void StmtPrinter::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
2231  // Parens are printed by the surrounding context.
2232  OS << "<forwarded>";
2233 }
2234 
2235 void StmtPrinter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
2236  PrintExpr(E->getSubExpr());
2237 }
2238 
2239 void StmtPrinter::VisitExprWithCleanups(ExprWithCleanups *E) {
2240  // Just forward to the subexpression.
2241  PrintExpr(E->getSubExpr());
2242 }
2243 
2244 void
2245 StmtPrinter::VisitCXXUnresolvedConstructExpr(
2247  Node->getTypeAsWritten().print(OS, Policy);
2248  OS << "(";
2250  ArgEnd = Node->arg_end();
2251  Arg != ArgEnd; ++Arg) {
2252  if (Arg != Node->arg_begin())
2253  OS << ", ";
2254  PrintExpr(*Arg);
2255  }
2256  OS << ")";
2257 }
2258 
2259 void StmtPrinter::VisitCXXDependentScopeMemberExpr(
2261  if (!Node->isImplicitAccess()) {
2262  PrintExpr(Node->getBase());
2263  OS << (Node->isArrow() ? "->" : ".");
2264  }
2265  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2266  Qualifier->print(OS, Policy);
2267  if (Node->hasTemplateKeyword())
2268  OS << "template ";
2269  OS << Node->getMemberNameInfo();
2270  if (Node->hasExplicitTemplateArgs())
2272  OS, Node->template_arguments(), Policy);
2273 }
2274 
2275 void StmtPrinter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *Node) {
2276  if (!Node->isImplicitAccess()) {
2277  PrintExpr(Node->getBase());
2278  OS << (Node->isArrow() ? "->" : ".");
2279  }
2280  if (NestedNameSpecifier *Qualifier = Node->getQualifier())
2281  Qualifier->print(OS, Policy);
2282  if (Node->hasTemplateKeyword())
2283  OS << "template ";
2284  OS << Node->getMemberNameInfo();
2285  if (Node->hasExplicitTemplateArgs())
2287  OS, Node->template_arguments(), Policy);
2288 }
2289 
2290 static const char *getTypeTraitName(TypeTrait TT) {
2291  switch (TT) {
2292 #define TYPE_TRAIT_1(Spelling, Name, Key) \
2293 case clang::UTT_##Name: return #Spelling;
2294 #define TYPE_TRAIT_2(Spelling, Name, Key) \
2295 case clang::BTT_##Name: return #Spelling;
2296 #define TYPE_TRAIT_N(Spelling, Name, Key) \
2297  case clang::TT_##Name: return #Spelling;
2298 #include "clang/Basic/TokenKinds.def"
2299  }
2300  llvm_unreachable("Type trait not covered by switch");
2301 }
2302 
2303 static const char *getTypeTraitName(ArrayTypeTrait ATT) {
2304  switch (ATT) {
2305  case ATT_ArrayRank: return "__array_rank";
2306  case ATT_ArrayExtent: return "__array_extent";
2307  }
2308  llvm_unreachable("Array type trait not covered by switch");
2309 }
2310 
2311 static const char *getExpressionTraitName(ExpressionTrait ET) {
2312  switch (ET) {
2313  case ET_IsLValueExpr: return "__is_lvalue_expr";
2314  case ET_IsRValueExpr: return "__is_rvalue_expr";
2315  }
2316  llvm_unreachable("Expression type trait not covered by switch");
2317 }
2318 
2319 void StmtPrinter::VisitTypeTraitExpr(TypeTraitExpr *E) {
2320  OS << getTypeTraitName(E->getTrait()) << "(";
2321  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
2322  if (I > 0)
2323  OS << ", ";
2324  E->getArg(I)->getType().print(OS, Policy);
2325  }
2326  OS << ")";
2327 }
2328 
2329 void StmtPrinter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2330  OS << getTypeTraitName(E->getTrait()) << '(';
2331  E->getQueriedType().print(OS, Policy);
2332  OS << ')';
2333 }
2334 
2335 void StmtPrinter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2336  OS << getExpressionTraitName(E->getTrait()) << '(';
2337  PrintExpr(E->getQueriedExpression());
2338  OS << ')';
2339 }
2340 
2341 void StmtPrinter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2342  OS << "noexcept(";
2343  PrintExpr(E->getOperand());
2344  OS << ")";
2345 }
2346 
2347 void StmtPrinter::VisitPackExpansionExpr(PackExpansionExpr *E) {
2348  PrintExpr(E->getPattern());
2349  OS << "...";
2350 }
2351 
2352 void StmtPrinter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2353  OS << "sizeof...(" << *E->getPack() << ")";
2354 }
2355 
2356 void StmtPrinter::VisitSubstNonTypeTemplateParmPackExpr(
2358  OS << *Node->getParameterPack();
2359 }
2360 
2361 void StmtPrinter::VisitSubstNonTypeTemplateParmExpr(
2363  Visit(Node->getReplacement());
2364 }
2365 
2366 void StmtPrinter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2367  OS << *E->getParameterPack();
2368 }
2369 
2370 void StmtPrinter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *Node){
2371  PrintExpr(Node->GetTemporaryExpr());
2372 }
2373 
2374 void StmtPrinter::VisitCXXFoldExpr(CXXFoldExpr *E) {
2375  OS << "(";
2376  if (E->getLHS()) {
2377  PrintExpr(E->getLHS());
2378  OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2379  }
2380  OS << "...";
2381  if (E->getRHS()) {
2382  OS << " " << BinaryOperator::getOpcodeStr(E->getOperator()) << " ";
2383  PrintExpr(E->getRHS());
2384  }
2385  OS << ")";
2386 }
2387 
2388 // C++ Coroutines TS
2389 
2390 void StmtPrinter::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
2391  Visit(S->getBody());
2392 }
2393 
2394 void StmtPrinter::VisitCoreturnStmt(CoreturnStmt *S) {
2395  OS << "co_return";
2396  if (S->getOperand()) {
2397  OS << " ";
2398  Visit(S->getOperand());
2399  }
2400  OS << ";";
2401 }
2402 
2403 void StmtPrinter::VisitCoawaitExpr(CoawaitExpr *S) {
2404  OS << "co_await ";
2405  PrintExpr(S->getOperand());
2406 }
2407 
2408 void StmtPrinter::VisitCoyieldExpr(CoyieldExpr *S) {
2409  OS << "co_yield ";
2410  PrintExpr(S->getOperand());
2411 }
2412 
2413 // Obj-C
2414 
2415 void StmtPrinter::VisitObjCStringLiteral(ObjCStringLiteral *Node) {
2416  OS << "@";
2417  VisitStringLiteral(Node->getString());
2418 }
2419 
2420 void StmtPrinter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
2421  OS << "@";
2422  Visit(E->getSubExpr());
2423 }
2424 
2425 void StmtPrinter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
2426  OS << "@[ ";
2427  ObjCArrayLiteral::child_range Ch = E->children();
2428  for (auto I = Ch.begin(), E = Ch.end(); I != E; ++I) {
2429  if (I != Ch.begin())
2430  OS << ", ";
2431  Visit(*I);
2432  }
2433  OS << " ]";
2434 }
2435 
2436 void StmtPrinter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
2437  OS << "@{ ";
2438  for (unsigned I = 0, N = E->getNumElements(); I != N; ++I) {
2439  if (I > 0)
2440  OS << ", ";
2441 
2442  ObjCDictionaryElement Element = E->getKeyValueElement(I);
2443  Visit(Element.Key);
2444  OS << " : ";
2445  Visit(Element.Value);
2446  if (Element.isPackExpansion())
2447  OS << "...";
2448  }
2449  OS << " }";
2450 }
2451 
2452 void StmtPrinter::VisitObjCEncodeExpr(ObjCEncodeExpr *Node) {
2453  OS << "@encode(";
2454  Node->getEncodedType().print(OS, Policy);
2455  OS << ')';
2456 }
2457 
2458 void StmtPrinter::VisitObjCSelectorExpr(ObjCSelectorExpr *Node) {
2459  OS << "@selector(";
2460  Node->getSelector().print(OS);
2461  OS << ')';
2462 }
2463 
2464 void StmtPrinter::VisitObjCProtocolExpr(ObjCProtocolExpr *Node) {
2465  OS << "@protocol(" << *Node->getProtocol() << ')';
2466 }
2467 
2468 void StmtPrinter::VisitObjCMessageExpr(ObjCMessageExpr *Mess) {
2469  OS << "[";
2470  switch (Mess->getReceiverKind()) {
2472  PrintExpr(Mess->getInstanceReceiver());
2473  break;
2474 
2476  Mess->getClassReceiver().print(OS, Policy);
2477  break;
2478 
2481  OS << "Super";
2482  break;
2483  }
2484 
2485  OS << ' ';
2486  Selector selector = Mess->getSelector();
2487  if (selector.isUnarySelector()) {
2488  OS << selector.getNameForSlot(0);
2489  } else {
2490  for (unsigned i = 0, e = Mess->getNumArgs(); i != e; ++i) {
2491  if (i < selector.getNumArgs()) {
2492  if (i > 0) OS << ' ';
2493  if (selector.getIdentifierInfoForSlot(i))
2494  OS << selector.getIdentifierInfoForSlot(i)->getName() << ':';
2495  else
2496  OS << ":";
2497  }
2498  else OS << ", "; // Handle variadic methods.
2499 
2500  PrintExpr(Mess->getArg(i));
2501  }
2502  }
2503  OS << "]";
2504 }
2505 
2506 void StmtPrinter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Node) {
2507  OS << (Node->getValue() ? "__objc_yes" : "__objc_no");
2508 }
2509 
2510 void
2511 StmtPrinter::VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
2512  PrintExpr(E->getSubExpr());
2513 }
2514 
2515 void
2516 StmtPrinter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
2517  OS << '(' << E->getBridgeKindName();
2518  E->getType().print(OS, Policy);
2519  OS << ')';
2520  PrintExpr(E->getSubExpr());
2521 }
2522 
2523 void StmtPrinter::VisitBlockExpr(BlockExpr *Node) {
2524  BlockDecl *BD = Node->getBlockDecl();
2525  OS << "^";
2526 
2527  const FunctionType *AFT = Node->getFunctionType();
2528 
2529  if (isa<FunctionNoProtoType>(AFT)) {
2530  OS << "()";
2531  } else if (!BD->param_empty() || cast<FunctionProtoType>(AFT)->isVariadic()) {
2532  OS << '(';
2533  for (BlockDecl::param_iterator AI = BD->param_begin(),
2534  E = BD->param_end(); AI != E; ++AI) {
2535  if (AI != BD->param_begin()) OS << ", ";
2536  std::string ParamStr = (*AI)->getNameAsString();
2537  (*AI)->getType().print(OS, Policy, ParamStr);
2538  }
2539 
2540  const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
2541  if (FT->isVariadic()) {
2542  if (!BD->param_empty()) OS << ", ";
2543  OS << "...";
2544  }
2545  OS << ')';
2546  }
2547  OS << "{ }";
2548 }
2549 
2550 void StmtPrinter::VisitOpaqueValueExpr(OpaqueValueExpr *Node) {
2551  PrintExpr(Node->getSourceExpr());
2552 }
2553 
2554 void StmtPrinter::VisitTypoExpr(TypoExpr *Node) {
2555  // TODO: Print something reasonable for a TypoExpr, if necessary.
2556  llvm_unreachable("Cannot print TypoExpr nodes");
2557 }
2558 
2559 void StmtPrinter::VisitAsTypeExpr(AsTypeExpr *Node) {
2560  OS << "__builtin_astype(";
2561  PrintExpr(Node->getSrcExpr());
2562  OS << ", ";
2563  Node->getType().print(OS, Policy);
2564  OS << ")";
2565 }
2566 
2567 //===----------------------------------------------------------------------===//
2568 // Stmt method implementations
2569 //===----------------------------------------------------------------------===//
2570 
2571 void Stmt::dumpPretty(const ASTContext &Context) const {
2572  printPretty(llvm::errs(), nullptr, PrintingPolicy(Context.getLangOpts()));
2573 }
2574 
2575 void Stmt::printPretty(raw_ostream &OS,
2576  PrinterHelper *Helper,
2577  const PrintingPolicy &Policy,
2578  unsigned Indentation) const {
2579  StmtPrinter P(OS, Helper, Policy, Indentation);
2580  P.Visit(const_cast<Stmt*>(this));
2581 }
2582 
2583 //===----------------------------------------------------------------------===//
2584 // PrinterHelper
2585 //===----------------------------------------------------------------------===//
2586 
2587 // Implement virtual destructor.
Expr * getInc()
Definition: Stmt.h:1187
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:539
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1464
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:52
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1009
Represents a single C99 designator.
Definition: Expr.h:4028
Raw form: operator "" X (const char *)
Definition: ExprCXX.h:424
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2411
Defines the clang::ASTContext interface.
This represents '#pragma omp distribute simd' composite directive.
Definition: StmtOpenMP.h:2966
unsigned getNumInits() const
Definition: Expr.h:3776
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1181
operator "" X (long double)
Definition: ExprCXX.h:427
const Expr * getBase() const
Definition: ExprObjC.h:509
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:505
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:1521
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:1565
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
Definition: Expr.cpp:1356
bool isVariadic() const
Definition: Type.h:3366
OpenMPScheduleClauseModifier getSecondScheduleModifier() const
Get the second modifier of the clause.
Definition: OpenMPClause.h:831
unsigned getNumOutputs() const
Definition: Stmt.h:1462
This represents 'thread_limit' clause in the '#pragma omp ...' directive.
The receiver is an object instance.
Definition: ExprObjC.h:1005
bool hasExplicitResultType() const
Whether this lambda had its result type explicitly specified.
Definition: ExprCXX.h:1741
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:237
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:4723
Smart pointer class that efficiently represents Objective-C method names.
llvm::iterator_range< pack_iterator > pack_elements() const
Iterator range referencing all of the elements of a template argument pack.
Definition: TemplateBase.h:329
This represents clause 'copyin' in the '#pragma omp ...' directives.
bool hasTemplateKeyword() const
Determines whether the name in this declaration reference was preceded by the template keyword...
Definition: Expr.h:1091
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:224
A (possibly-)qualified type.
Definition: Type.h:598
bool hasExplicitTemplateArgs() const
Determines whether this expression had explicit template arguments.
Definition: ExprCXX.h:2626
ArrayRef< OMPClause * > clauses()
Definition: StmtOpenMP.h:215
bool getValue() const
Definition: ExprCXX.h:483
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: Expr.h:2217
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:2898
Expr * getCond()
Definition: Stmt.h:1075
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
Definition: Expr.h:3462
DeclarationNameInfo getMemberNameInfo() const
Retrieve the member declaration name info.
Definition: Expr.h:2503
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1174
OpenMPDistScheduleClauseKind getDistScheduleKind() const
Get kind of the clause.
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2272
CompoundStmt * getSubStmt()
Definition: Expr.h:3396
Expr * getSimdlen() const
Return safe iteration space distance.
Definition: OpenMPClause.h:481
CharacterKind getKind() const
Definition: Expr.h:1331
Represents a 'co_return' statement in the C++ Coroutines TS.
Definition: StmtCXX.h:379
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2879
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
bool isArgumentType() const
Definition: Expr.h:2010
IfStmt - This represents an if/then/else.
Definition: Stmt.h:881
Expr * getInit() const
Retrieve the initializer value.
Definition: Expr.h:4184
bool isGlobalDelete() const
Definition: ExprCXX.h:2041
Expr * GetTemporaryExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue...
Definition: ExprCXX.h:4003
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:931
Expr * getOperand() const
Definition: ExprCXX.h:4240
OpenMPProcBindClauseKind getProcBindKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:676
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:1916
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2440
bool isRecordType() const
Definition: Type.h:5539
This represents 'grainsize' clause in the '#pragma omp ...' directive.
arg_iterator arg_begin()
Definition: ExprCXX.h:1276
param_iterator param_end()
Definition: Decl.h:3555
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2671
This represents 'if' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:197
Defines the C++ template declaration subclasses.
StringRef P
Represents an attribute applied to a statement.
Definition: Stmt.h:830
TypeSourceInfo * getArg(unsigned I) const
Retrieve the Ith argument.
Definition: ExprCXX.h:2320
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1619
Expr * getLowerBound()
Get lower bound of array section.
Definition: ExprOpenMP.h:91
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Definition: Expr.h:1828
This represents 'priority' clause in the '#pragma omp ...' directive.
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:313
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
InitListExpr * getSyntacticForm() const
Definition: Expr.h:3882
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1162
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:760
bool hasExplicitTemplateArgs() const
Determines whether this lookup had explicit template arguments.
Definition: ExprCXX.h:2874
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1783
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2356
A container of type source information.
Definition: Decl.h:62
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: Expr.h:1123
This represents 'update' clause in the '#pragma omp atomic' directive.
const Stmt * getElse() const
Definition: Stmt.h:921
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:1302
MS property subscript expression.
Definition: ExprCXX.h:728
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:26
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3962
Expr * getVal1() const
Definition: Expr.h:4840
Expr * getAlignment()
Returns alignment.
int Delta
bool hasExplicitTemplateArgs() const
Determines whether the member name was followed by an explicit template argument list.
Definition: Expr.h:2470
CompoundStmt * getBlock() const
Definition: Stmt.h:1910
IdentType getIdentType() const
Definition: Expr.h:1187
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:1937
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:309
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:2191
Stmt * getSubStmt()
Definition: Stmt.h:760
This represents 'read' clause in the '#pragma omp atomic' directive.
Expr * getOperand() const
Definition: ExprCXX.h:3548
This represents clause 'private' in the '#pragma omp ...' directives.
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition: ExprObjC.h:1383
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:2562
This represents 'num_threads' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:334
const Expr * getCallee() const
Definition: Expr.h:2188
This represents 'defaultmap' clause in the '#pragma omp ...' directive.
OpenMPDefaultmapClauseModifier getDefaultmapModifier() const
Get the modifier of the clause.
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
Definition: Expr.cpp:1871
void printPretty(raw_ostream &OS, const PrintingPolicy &Policy) const
bool hasExplicitParameters() const
Determine whether this lambda has an explicit parameter list vs.
Definition: ExprCXX.h:1738
bool hasTemplateKeyword() const
Determines whether the member name was preceded by the template keyword.
Definition: ExprCXX.h:3285
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:533
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2005
bool varlist_empty() const
Definition: OpenMPClause.h:162
This represents implicit clause 'flush' for the '#pragma omp flush' directive.
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
unsigned getValue() const
Definition: Expr.h:1338
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:913
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:2936
Expr * getNumForLoops() const
Return the number of associated for-loops.
Definition: OpenMPClause.h:913
Defines the clang::Expr interface and subclasses for C++ expressions.
bool isArrow() const
Definition: ExprObjC.h:1410
Expr * getArrayIndex(const Designator &D) const
Definition: Expr.cpp:3641
ArrayTypeTrait getTrait() const
Definition: ExprCXX.h:2399
This represents 'nogroup' clause in the '#pragma omp ...' directive.
bool getIsCXXTry() const
Definition: Stmt.h:1949
This represents 'safelen' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:392
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:254
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:789
Expr * IgnoreImpCasts() LLVM_READONLY
IgnoreImpCasts - Skip past any implicit casts which might surround this expression.
Definition: Expr.h:2777
Represents a C99 designated initializer expression.
Definition: Expr.h:3953
Expr * getNumThreads() const
Returns number of threads.
Definition: OpenMPClause.h:370
DeclarationName getName() const
getName - Returns the embedded declaration name.
One of these records is kept for each identifier that is lexed.
Stmt * getBody()
Definition: Stmt.h:1123
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:453
CompoundStmt * getSubStmt() const
Retrieve the compound statement that will be included in the program only if the existence of the sym...
Definition: StmtCXX.h:280
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:212
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:231
unsigned getNumInputs() const
Definition: Stmt.h:1484
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition: Expr.h:3422
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:92
ObjCInterfaceDecl * getClassReceiver() const
Definition: ExprObjC.h:696
This represents 'simd' clause in the '#pragma omp ...' directive.
LambdaCaptureDefault getCaptureDefault() const
Determine the default capture kind for this lambda.
Definition: ExprCXX.h:1602
OpenMPScheduleClauseModifier getFirstScheduleModifier() const
Get the first modifier of the clause.
Definition: OpenMPClause.h:826
unsigned getNumAssocs() const
Definition: Expr.h:4440
child_range children()
Definition: ExprObjC.h:201
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2293
This represents clause 'lastprivate' in the '#pragma omp ...' directives.
Expr * getBase()
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3434
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4240
StringLiteral * getString()
Definition: ExprObjC.h:40
Expr * getImplicitObjectArgument() const
Retrieves the implicit object argument for the member call.
Definition: ExprCXX.cpp:459
Expr * getChunkSize()
Get chunk size.
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:3624
This represents clause 'map' in the '#pragma omp ...' directives.
CXXMethodDecl * getCallOperator() const
Retrieve the function call operator associated with this lambda expression.
Definition: ExprCXX.cpp:999
This represents clause 'to' in the '#pragma omp ...' directives.
Expr * getOrder() const
Definition: Expr.h:4837
Expr * getPlacementArg(unsigned i)
Definition: ExprCXX.h:1907
DeclarationNameInfo getNameInfo() const
Retrieve the name of the entity we're testing for, along with location information.
Definition: StmtCXX.h:276
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3366
const DeclarationNameInfo & getNameInfo() const
Gets the full name info.
Definition: ExprCXX.h:2584
IdentifierInfo & getAccessor() const
Definition: Expr.h:4531
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:4509
QualType getQueriedType() const
Definition: ExprCXX.h:2401
Expr * getSubExpr()
Definition: Expr.h:2684
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:1633
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:144
Expr * getNumTeams()
Return NumTeams number.
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:3822
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:1228
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:2553
Expr * getFilterExpr() const
Definition: Stmt.h:1870
Expr * getLHS() const
Definition: Expr.h:2943
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:94
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:74
const CompoundStmt * getSynchBody() const
Definition: StmtObjC.h:282
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:1258
Describes an C or C++ initializer list.
Definition: Expr.h:3746
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:575
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:2827
Expr * getRHS() const
Definition: ExprCXX.h:4089
Stmt * getBody() const override
Definition: Decl.cpp:4074
Expr * getArraySize()
Definition: ExprCXX.h:1895
Expr * getVal2() const
Definition: Expr.h:4850
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition: Stmt.h:1153
const LangOptions & getLangOpts() const
Definition: ASTContext.h:604
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
Definition: ExprCXX.h:2230
< Capturing the *this object by copy
Definition: Lambda.h:37
DeclarationNameInfo getNameInfo() const
Definition: Expr.h:1021
QualType getReturnType() const
Definition: Type.h:3009
bool isSuperReceiver() const
Definition: ExprObjC.h:700
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:52
Expr * getInitializer()
The initializer of this new-expression.
Definition: ExprCXX.h:1932
Expr * getExprOperand() const
Definition: ExprCXX.h:630
Stmt * getBody()
Definition: Stmt.h:1188
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:3317
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the full name info for the member that this expression refers to.
Definition: ExprCXX.h:3461
OpenMPScheduleClauseKind getScheduleKind() const
Get kind of the clause.
Definition: OpenMPClause.h:823
const Expr * getSubExpr() const
Definition: Expr.h:3673
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2897
Selector getSelector() const
Definition: ExprObjC.cpp:306
InitializationStyle getInitializationStyle() const
The kind of initializer this new-expression has.
Definition: ExprCXX.h:1925
Stmt * getInit()
Definition: Stmt.h:1167
Expr * getOutputExpr(unsigned i)
Definition: Stmt.cpp:397
static bool isPostfix(Opcode Op)
isPostfix - Return true if this is a postfix operation, like x++.
Definition: Expr.h:1703
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition: StmtCXX.h:128
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies this declaration.
Definition: ExprCXX.h:2845
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:2446
This represents 'default' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:554
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:29
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2448
QualType getTypeAsWritten() const
getTypeAsWritten - Returns the type that this expression is casting to, as written in the source code...
Definition: Expr.h:2823
const DeclStmt * getConditionVariableDeclStmt() const
If this SwitchStmt has a condition variable, return the faux DeclStmt associated with the creation of...
Definition: Stmt.h:987
Expr * getBaseExpr() const
Definition: ExprCXX.h:708
void print(raw_ostream &OS, const PrintingPolicy &Policy, const Twine &PlaceHolder=Twine(), unsigned Indentation=0) const
Definition: Type.h:934
New-expression has a C++98 paren-delimited initializer.
Definition: ExprCXX.h:1846
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:4898
const Stmt * getCatchBody() const
Definition: StmtObjC.h:90
This represents 'final' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:280
This represents 'mergeable' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:992
Expr * getCond()
Definition: Stmt.h:1186
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:2389
Expr * getLHS() const
Definition: Expr.h:3215
StringRef getBridgeKindName() const
Retrieve the kind of bridge being performed as a string.
Definition: ExprObjC.cpp:349
This represents clause 'reduction' in the '#pragma omp ...' directives.
Helper class for OffsetOfExpr.
Definition: Expr.h:1770
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1119
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:206
StringLiteral * getClobberStringLiteral(unsigned i)
Definition: Stmt.h:1729
CompoundStmt * getBody() const
Retrieve the body of the lambda.
Definition: ExprCXX.cpp:1010
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:87
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:214
void print(llvm::raw_ostream &OS) const
Prints the full selector name (e.g. "foo:bar:").
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1503
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3128
const Expr * getBase() const
Definition: ExprObjC.h:682
This represents clause 'is_device_ptr' in the '#pragma omp ...' directives.
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise, it used a '.
Definition: ExprCXX.h:2193
Expr * getHint() const
Returns number of threads.
detail::InMemoryDirectory::const_iterator I
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:967
QualType getType() const
Definition: Decl.h:599
ExpressionTrait getTrait() const
Definition: ExprCXX.h:2462
NestedNameSpecifier * getQualifier() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name.
Definition: Expr.h:1044
This represents clause 'from' in the '#pragma omp ...' directives.
Represents the this expression in C++.
Definition: ExprCXX.h:873
MSPropertyDecl * getPropertyDecl() const
Definition: ExprCXX.h:709
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:505
OpenMPDefaultClauseKind getDefaultKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:603
TypeTrait
Names for traits that operate specifically on types.
Definition: TypeTraits.h:21
Expr * getRHS() const
Definition: Expr.h:3216
QualType getTypeAsWritten() const
Retrieve the type that is being constructed, as specified in the source code.
Definition: ExprCXX.h:3059
OpenMPDependClauseKind getDependencyKind() const
Get dependency type.
This represents '#pragma omp target parallel for simd' directive.
Definition: StmtOpenMP.h:3034
OpenMP 4.0 [2.4, Array Sections].
Definition: ExprOpenMP.h:45
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3170
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:2490
Expr * getLHS() const
Definition: Expr.h:3594
llvm::APInt getValue() const
Definition: Expr.h:1248
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2129
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:551
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3073
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the member name.
Definition: ExprCXX.h:3225
This represents 'threads' clause in the '#pragma omp ...' directive.
StringRef getAsmString() const
Definition: Stmt.h:1779
CXXMethodDecl * getMethodDecl() const
Retrieves the declaration of the called method.
Definition: ExprCXX.cpp:471
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:1721
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2317
const Expr * getControllingExpr() const
Definition: Expr.h:4463
This represents clause 'aligned' in the '#pragma omp ...' directives.
bool isCmpXChg() const
Definition: Expr.h:4873
Expr * getQueriedExpression() const
Definition: ExprCXX.h:2464
NestedNameSpecifierLoc getQualifierLoc() const
Definition: ExprCXX.h:712
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:1974
ASTContext * Context
arg_iterator arg_end()
Definition: ExprCXX.h:1277
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:3655
Expr * getCond() const
Definition: Expr.h:3204
bool isPackExpansion() const
Determines whether this dictionary element is a pack expansion.
Definition: ExprObjC.h:227
bool isUnarySelector() const
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:2700
This represents implicit clause 'depend' for the '#pragma omp task' directive.
unsigned getNumExprs() const
Definition: Expr.h:4350
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1764
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3456
llvm::MutableArrayRef< Designator > designators()
Definition: Expr.h:4156
This represents 'proc_bind' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:626
bool isMutable() const
Determine whether the lambda is mutable, meaning that any captures values can be modified.
Definition: ExprCXX.cpp:1021
This represents 'capture' clause in the '#pragma omp atomic' directive.
Expr - This represents one expression.
Definition: Expr.h:105
StringRef getName() const
Return the actual identifier string.
const Expr * getExpr(unsigned Init) const
Definition: Expr.h:4352
void outputString(raw_ostream &OS) const
Definition: Expr.cpp:863
bool hasBraces() const
Definition: Stmt.h:1773
unsigned getNumArgs() const
static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node, bool PrintSuffix)
This represents 'simdlen' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:447
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Definition: ExprCXX.h:1240
Expr * getCondition() const
Returns condition.
Definition: OpenMPClause.h:316
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1454
A C++ const_cast expression (C++ [expr.const.cast]).
Definition: ExprCXX.h:372
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:4567
const DeclarationNameInfo & getNameInfo() const
Retrieve the name that this expression refers to.
Definition: ExprCXX.h:2829
bool hasExplicitTemplateArgs() const
Determines whether this member expression actually had a C++ template argument list explicitly specif...
Definition: ExprCXX.h:3289
bool hasTemplateKeyword() const
Determines whether the name was preceded by the template keyword.
Definition: ExprCXX.h:2623
ObjCMethodDecl * getImplicitPropertyGetter() const
Definition: ExprObjC.h:638
Stmt * getBody()
Definition: Stmt.h:1078
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:257
Expr * getArrayRangeStart(const Designator &D) const
Definition: Expr.cpp:3646
Expr * getRHS()
Definition: Stmt.h:715
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:262
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:397
bool isImplicitAccess() const
True if this is an implicit access, i.e., one in which the member being accessed was not written in t...
Definition: ExprCXX.cpp:1239
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3653
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:65
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:4609
OpenMPDirectiveKind getNameModifier() const
Return directive name modifier associated with the clause.
Definition: OpenMPClause.h:260
This represents 'ordered' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:878
Selector getSelector() const
Definition: ExprObjC.h:409
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Definition: ExprCXX.h:3848
QualType getAllocatedType() const
Definition: ExprCXX.h:1863
StringRef getInputName(unsigned i) const
Definition: Stmt.h:1687
Expr * getSubExpr() const
Definition: Expr.h:1695
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:854
Expr * getLHS() const
Definition: ExprCXX.h:4088
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4065
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:1366
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:3511
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:860
unsigned getNumComponents() const
Definition: Expr.h:1933
This represents a Microsoft inline-assembly statement extension.
Definition: Stmt.h:1744
const DeclStmt * getConditionVariableDeclStmt() const
If this IfStmt has a condition variable, return the faux DeclStmt associated with the creation of tha...
Definition: Stmt.h:910
UnaryOperator - This represents the unary-expression's (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:1668
Expr * getCond() const
Definition: Expr.h:3592
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:663
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3767
Expr * getDevice()
Return device number.
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:2504
This represents 'collapse' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:502
This represents clause 'firstprivate' in the '#pragma omp ...' directives.
ValueDecl * getDecl()
Definition: Expr.h:1017
NestedNameSpecifier * getQualifier() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: ExprCXX.h:2187
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
Definition: Expr.h:2834
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
AtomicOp getOp() const
Definition: Expr.h:4861
Expr * getLHS()
An array access can be written A[4] or 4[A] (both are equivalent).
Definition: Expr.h:2096
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
Definition: Expr.h:1423
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1290
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:1772
bool param_empty() const
Definition: Decl.h:3553
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:1382
InitListExpr * getUpdater() const
Definition: Expr.h:4295
DoStmt - This represents a 'do/while' stmt.
Definition: Stmt.h:1102
This represents 'seq_cst' clause in the '#pragma omp atomic' directive.
This represents 'untied' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:960
unsigned getNumSubExprs() const
getNumSubExprs - Return the size of the SubExprs array.
Definition: Expr.h:3456
param_iterator param_begin()
Definition: Decl.h:3554
LabelDecl * getLabel() const
Definition: Stmt.h:1235
Expr * getBase() const
Definition: ExprObjC.h:1408
Expr * getArgument()
Definition: ExprCXX.h:2055
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:2132
bool isArrayForm() const
Definition: ExprCXX.h:2042
This represents 'num_teams' clause in the '#pragma omp ...' directive.
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:290
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:848
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:3487
const StringLiteral * getAsmString() const
Definition: Stmt.h:1592
Kind
This captures a statement into a function.
Definition: Stmt.h:2006
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1325
operator "" X (const CharT *, size_t)
Definition: ExprCXX.h:428
Expr * getArrayRangeEnd(const Designator &D) const
Definition: Expr.cpp:3652
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:4679
bool getValue() const
Definition: ExprObjC.h:71
Raw form: operator "" X<cs...> ()
Definition: ExprCXX.h:425
Expr * getNumForLoops() const
Return the number of associated for-loops.
Definition: OpenMPClause.h:537
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1126
body_range body()
Definition: Stmt.h:581
This represents 'hint' clause in the '#pragma omp ...' directive.
Expr * getSourceExpr() const
The source expression of an opaque value expression is the expression which originally generated the ...
Definition: Expr.h:902
Expr * getPtr() const
Definition: Expr.h:4834
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
bool isValid() const
Return true if this is a valid SourceLocation object.
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies this name, if any.
Definition: StmtCXX.h:272
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1804
Expr * getLHS()
Definition: Stmt.h:714
static const char * getExpressionTraitName(ExpressionTrait ET)
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Definition: ExprCXX.h:409
Expr * getCondition() const
Returns condition.
Definition: OpenMPClause.h:258
This represents 'schedule' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:698
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:121
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:443
CompoundStmt * getBlock() const
Definition: Stmt.h:1874
This represents clause 'shared' in the '#pragma omp ...' directives.
const Expr * getCond() const
Definition: Stmt.h:994
Expr * getOperand() const
Retrieve the operand of the 'co_return' statement.
Definition: StmtCXX.h:397
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1736
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:4632
void VisitStmt(Stmt *S)
Expr * getPriority()
Return Priority number.
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:178
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:1989
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:1677
OpenMPMapClauseKind getMapType() const LLVM_READONLY
Fetches mapping kind for the clause.
const DeclarationNameInfo & getMemberNameInfo() const
Retrieve the name of the member that this expression refers to.
Definition: ExprCXX.h:3251
This file defines OpenMP nodes for declarative directives.
bool isImplicitAccess() const
True if this is an implicit access, i.e.
Definition: ExprCXX.cpp:1185
NamedDecl * getPack() const
Retrieve the parameter pack.
Definition: ExprCXX.h:3724
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>.
Definition: Expr.h:4804
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:441
bool isInitCapture(const LambdaCapture *Capture) const
Determine whether one of this lambda's captures is an init-capture.
Definition: ExprCXX.cpp:939
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:2734
LiteralOperatorKind getLiteralOperatorKind() const
Returns the kind of literal operator invocation which this expression represents. ...
Definition: ExprCXX.cpp:660
capture_iterator explicit_capture_end() const
Retrieve an iterator pointing past the end of the sequence of explicit lambda captures.
Definition: ExprCXX.cpp:960
QualType getAssocType(unsigned i) const
Definition: Expr.h:4456
OpenMPMapClauseKind getMapTypeModifier() const LLVM_READONLY
Fetches the map type modifier for the clause.
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
Definition: ExprCXX.h:3913
SEHExceptStmt * getExceptHandler() const
Returns 0 if not defined.
Definition: Stmt.cpp:924
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:2016
Expr * getInputExpr(unsigned i)
Definition: Stmt.cpp:408
static const char * getTypeTraitName(TypeTrait TT)
TypeTrait getTrait() const
Determine which type trait this expression uses.
Definition: ExprCXX.h:2307
StringRef getOutputName(unsigned i) const
Definition: Stmt.h:1659
static void PrintTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, bool SkipBrackets=false)
Print a template argument list, including the '<' and '>' enclosing the template arguments...
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
Definition: ExprCXX.h:3451
Expr * getSubExpr()
Definition: ExprObjC.h:108
An expression trait intrinsic.
Definition: ExprCXX.h:2428
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:620
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:1827
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3380
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: Expr.h:2498
const Expr * getBase() const
Definition: Expr.h:4527
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:2768
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:94
Expr * getGrainsize() const
Return safe iteration space distance.
const BlockDecl * getBlockDecl() const
Definition: Expr.h:4581
bool isObjectReceiver() const
Definition: ExprObjC.h:699
bool isParenTypeId() const
Definition: ExprCXX.h:1916
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:70
Opcode getOpcode() const
Definition: Expr.h:1692
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name...
Definition: StmtCXX.h:240
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:1923
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2791
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:217
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3092
Represents a C11 generic selection.
Definition: Expr.h:4413
const char * getCastName() const
getCastName - Get the name of the C++ cast being used, e.g., "static_cast", "dynamic_cast", "reinterpret_cast", or "const_cast".
Definition: ExprCXX.cpp:500
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1155
bool isArrow() const
Definition: Expr.h:2510
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3339
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
Definition: ExprObjC.h:1519
ast_type_traits::DynTypedNode Node
QualType getType() const
Definition: Expr.h:126
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Definition: ExprCXX.h:3884
Represents a template argument.
Definition: TemplateBase.h:40
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition.
Definition: Expr.h:3280
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:511
void print(raw_ostream &OS, const PrintingPolicy &Policy) const
Print this nested name specifier to the given output stream.
const Expr * getSubExpr() const
Definition: ExprCXX.h:933
bool isImplicitProperty() const
Definition: ExprObjC.h:630
Stmt * getBody() const
Retrieve the body of the coroutine as written.
Definition: StmtCXX.h:331
This represents 'device' clause in the '#pragma omp ...' directive.
const Expr * getAssocExpr(unsigned i) const
Definition: Expr.h:4446
StringRef getOpcodeStr() const
Definition: Expr.h:2959
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1160
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2008
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:820
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
static LLVM_READONLY bool isPrintable(unsigned char c)
Return true if this character is an ASCII printable character; that is, a character that should take ...
Definition: CharInfo.h:140
const Stmt * getBody() const
Definition: Stmt.h:995
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1064
SourceLocation getLParenLoc() const
Definition: ExprCXX.h:1423
bool isClassReceiver() const
Definition: ExprObjC.h:701
A runtime availability query.
Definition: ExprObjC.h:1579
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:332
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:789
Represents a 'co_yield' expression.
Definition: ExprCXX.h:4228
const Expr * getSynchExpr() const
Definition: StmtObjC.h:290
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
Expr * getNumTasks() const
Return safe iteration space distance.
const StringLiteral * getOutputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1668
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3581
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:1902
This represents clause 'linear' in the '#pragma omp ...' directives.
DeclarationNameInfo getDirectiveName() const
Return name of the directive.
Definition: StmtOpenMP.h:1286
Selector getSelector() const
Definition: DeclObjC.h:328
bool isTypeOperand() const
Definition: ExprCXX.h:813
void printName(raw_ostream &OS) const
printName - Print the human-readable name to a stream.
detail::InMemoryDirectory::const_iterator E
const Expr * getRetValue() const
Definition: Stmt.cpp:899
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2205
unsigned getNumArgs() const
Definition: ExprCXX.h:1285
This represents '#pragma omp atomic' directive.
Definition: StmtOpenMP.h:1882
Expr * getBaseExpr() const
Definition: ExprObjC.h:807
llvm::APFloat getValue() const
Definition: Expr.h:1368
Represents a __leave statement.
Definition: Stmt.h:1972
const Stmt * getThen() const
Definition: Stmt.h:919
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3526
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:957
Capturing variable-length array type.
Definition: Lambda.h:39
Not an overloaded operator.
Definition: OperatorKinds.h:23
Expr * getSafelen() const
Return safe iteration space distance.
Definition: OpenMPClause.h:426
Represents the body of a coroutine.
Definition: StmtCXX.h:299
Expr * getRHS() const
Definition: Expr.h:3596
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3209
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:5818
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2063
const Stmt * getSubStmt() const
Definition: StmtObjC.h:356
capture_iterator explicit_capture_begin() const
Retrieve an iterator pointing to the first explicit lambda capture.
Definition: ExprCXX.cpp:956
Represents Objective-C's collection statement.
Definition: StmtObjC.h:24
static StringRef getIdentTypeName(IdentType IT)
Definition: Expr.cpp:450
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:355
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:1782
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:160
Represents a 'co_await' expression.
Definition: ExprCXX.h:4205
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:3551
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1288
decl_range decls()
Definition: Stmt.h:491
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1528
Expr * getExprOperand() const
Definition: ExprCXX.h:830
bool isVolatile() const
Definition: Stmt.h:1449
bool hasTemplateKeyword() const
Determines whether the member name was preceded by the template keyword.
Definition: Expr.h:2466
Represents Objective-C's @finally statement.
Definition: StmtObjC.h:120
const Expr * getSubExpr() const
Definition: Expr.h:1435
Expr * getKeyExpr() const
Definition: ExprObjC.h:810
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver. ...
Definition: ExprObjC.h:1277
LabelDecl * getLabel() const
Definition: Expr.h:3361
const DeclStmt * getConditionVariableDeclStmt() const
If this WhileStmt has a condition variable, return the faux DeclStmt associated with the creation of ...
Definition: Stmt.h:1071
Capturing the *this object by reference.
Definition: Lambda.h:35
This represents 'write' clause in the '#pragma omp atomic' directive.
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:633
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:203
const char * getOpenMPDirectiveName(OpenMPDirectiveKind Kind)
Definition: OpenMPKinds.cpp:31
const Expr * getInitializer() const
Definition: Expr.h:2588
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:479
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:193
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:3299
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3021
void printExceptionSpecification(raw_ostream &OS, const PrintingPolicy &Policy) const
GotoStmt - This represents a direct goto.
Definition: Stmt.h:1224
ArrayRef< const Attr * > getAttrs() const
Definition: Stmt.h:862
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1037
Expr * getTarget()
Definition: Stmt.h:1277
Expr * getBase() const
Definition: Expr.h:2405
A template argument list.
Definition: DeclTemplate.h:173
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
Definition: Stmt.cpp:1084
Expr * getCond()
Definition: Stmt.h:1120
Expr * getWeak() const
Definition: Expr.h:4856
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
const StringLiteral * getInputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1696
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2315
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Definition: ExprCXX.h:77
const Expr * getSubExpr() const
Definition: Expr.h:1635
const IdentifierInfo * getUDSuffix() const
Returns the ud-suffix specified for this literal.
Definition: ExprCXX.cpp:689
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:2249
This represents 'nowait' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:929
ContinueStmt - This represents a continue.
Definition: Stmt.h:1302
This represents 'num_tasks' clause in the '#pragma omp ...' directive.
bool isGlobalNew() const
Definition: ExprCXX.h:1919
Opcode getOpcode() const
Definition: Expr.h:2940
QualType getEncodedType() const
Definition: ExprObjC.h:376
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:3547
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3240
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:29
VarDecl * getLoopVariable()
Definition: StmtCXX.cpp:80
An index into an array.
Definition: Expr.h:1775
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
Definition: ExprCXX.h:1395
NestedNameSpecifier * getNestedNameSpecifier() const
Retrieve the nested-name-specifier to which this instance refers.
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:1047
Capturing by reference.
Definition: Lambda.h:38
const Expr * getCond() const
Definition: Stmt.h:917
Expr * getThreadLimit()
Return ThreadLimit number.
This class is used for builtin types like 'int'.
Definition: Type.h:2039
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:96
OpenMPDefaultmapClauseKind getDefaultmapKind() const
Get kind of the clause.
The receiver is a class.
Definition: ExprObjC.h:1003
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
This represents '#pragma omp taskloop simd' directive.
Definition: StmtOpenMP.h:2634
const Expr * getThrowExpr() const
Definition: StmtObjC.h:325
bool hasExplicitTemplateArgs() const
Determines whether this declaration reference was followed by an explicit template argument list...
Definition: Expr.h:1095
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1466
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2148
Expr * getRHS() const
Definition: Expr.h:2945
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:3610
This represents 'dist_schedule' clause in the '#pragma omp ...' directive.
bool isIfExists() const
Determine whether this is an __if_exists statement.
Definition: StmtCXX.h:265
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:810
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:203
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
Definition: ExprCXX.h:1247
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:996
Expr * getBase() const
Definition: Expr.h:4292
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:60
const Stmt * getTryBody() const
Retrieve the @try body.
Definition: StmtObjC.h:197
This represents '#pragma omp target data' directive.
Definition: StmtOpenMP.h:2074
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:50
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:932
ArrayRef< TemplateArgumentLoc > template_arguments() const
Definition: ExprCXX.h:2641
BreakStmt - This represents a break.
Definition: Stmt.h:1328
SourceLocation getColonLoc() const
Definition: ExprOpenMP.h:109
Expr * getChunkSize()
Get chunk size.
Definition: OpenMPClause.h:855
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3785
const Expr * getSubExpr() const
Definition: ExprCXX.h:1143
Stmt * getSubStmt()
Definition: Stmt.h:809
bool hasTemplateKeyword() const
Determines whether the name was preceded by the template keyword.
Definition: ExprCXX.h:2871
ExprIterator arg_iterator
Definition: ExprCXX.h:1266
BinaryOperatorKind getOperator() const
Definition: ExprCXX.h:4103
unsigned getNumClobbers() const
Definition: Stmt.h:1494
static StringRef getOpcodeStr(Opcode Op)
getOpcodeStr - Turn an Opcode enum value into the punctuation char it corresponds to...
Definition: Expr.cpp:1085
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:1589
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:2897
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:471
NestedNameSpecifier * getQualifier() const
Fetches the nested-name qualifier, if one was given.
Definition: ExprCXX.h:2593
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:1874
QualType getDestroyedType() const
Retrieve the type being destroyed.
Definition: ExprCXX.cpp:197
CompoundStmt * getTryBlock() const
Definition: Stmt.h:1951
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:1450
bool isArrow() const
Definition: ExprCXX.h:710
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:784
Expr * getOperand() const
Definition: ExprCXX.h:4217
bool isSignedIntegerType() const
Return true if this is an integer type that is signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], or an enum decl which has a signed representation.
Definition: Type.cpp:1706
const CallExpr * getConfig() const
Definition: ExprCXX.h:173
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition: Type.h:665
bool isTypeOperand() const
Definition: ExprCXX.h:613
The receiver is a superclass.
Definition: ExprObjC.h:1007
const char * getName() const
Definition: Stmt.cpp:309
Stmt * getAssociatedStmt() const
Returns statement associated with the directive.
Definition: StmtOpenMP.h:196
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1136
Represents Objective-C's @autoreleasepool Statement.
Definition: StmtObjC.h:345
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
Definition: ExprCXX.h:3218
Expr * getOrderFail() const
Definition: Expr.h:4846
Stmt * getSubStmt()
Definition: Stmt.h:865
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4315
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:307
This represents '#pragma omp target parallel for' directive.
Definition: StmtOpenMP.h:2309
Attr - This represents one attribute.
Definition: Attr.h:45
This represents clause 'use_device_ptr' in the '#pragma omp ...' directives.
operator "" X (unsigned long long)
Definition: ExprCXX.h:426
Expr * getLength()
Get length of array section.
Definition: ExprOpenMP.h:99
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1824
Expr * getCookedLiteral()
If this is not a raw user-defined literal, get the underlying cooked literal (representing the litera...
Definition: ExprCXX.cpp:681
bool isArrow() const
Definition: ExprObjC.h:513
SEHFinallyStmt * getFinallyHandler() const
Definition: Stmt.cpp:928
Expr * getBase()
An array section can be written only as Base[LowerBound:Length].
Definition: ExprOpenMP.h:82
unsigned Indent
The current line's indent.
Stmt * getSubStmt()
Definition: Stmt.h:716
QualType getArgumentType() const
Definition: Expr.h:2011
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:2569