clang  3.7.0
ASTWriterStmt.cpp
Go to the documentation of this file.
1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
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 /// \file
11 /// \brief Implements serialization for Statements and Expressions.
12 ///
13 //===----------------------------------------------------------------------===//
14 
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/DeclCXX.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/StmtVisitor.h"
21 #include "clang/Lex/Token.h"
22 #include "llvm/Bitcode/BitstreamWriter.h"
23 using namespace clang;
24 
25 //===----------------------------------------------------------------------===//
26 // Statement/expression serialization
27 //===----------------------------------------------------------------------===//
28 
29 namespace clang {
30 
31  class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
32  friend class OMPClauseWriter;
33  ASTWriter &Writer;
34  ASTWriter::RecordData &Record;
35 
36  public:
38  unsigned AbbrevToUse;
39 
41  : Writer(Writer), Record(Record) { }
42 
44 
45  void VisitStmt(Stmt *S);
46 #define STMT(Type, Base) \
47  void Visit##Type(Type *);
48 #include "clang/AST/StmtNodes.inc"
49  };
50 }
51 
52 void ASTStmtWriter::
54  Writer.AddSourceLocation(Args.getTemplateKeywordLoc(), Record);
55  Writer.AddSourceLocation(Args.LAngleLoc, Record);
56  Writer.AddSourceLocation(Args.RAngleLoc, Record);
57  for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
58  Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record);
59 }
60 
62 }
63 
64 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
65  VisitStmt(S);
66  Writer.AddSourceLocation(S->getSemiLoc(), Record);
67  Record.push_back(S->HasLeadingEmptyMacro);
69 }
70 
71 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
72  VisitStmt(S);
73  Record.push_back(S->size());
74  for (auto *CS : S->body())
75  Writer.AddStmt(CS);
76  Writer.AddSourceLocation(S->getLBracLoc(), Record);
77  Writer.AddSourceLocation(S->getRBracLoc(), Record);
79 }
80 
81 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
82  VisitStmt(S);
83  Record.push_back(Writer.getSwitchCaseID(S));
84  Writer.AddSourceLocation(S->getKeywordLoc(), Record);
85  Writer.AddSourceLocation(S->getColonLoc(), Record);
86 }
87 
88 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
89  VisitSwitchCase(S);
90  Writer.AddStmt(S->getLHS());
91  Writer.AddStmt(S->getRHS());
92  Writer.AddStmt(S->getSubStmt());
93  Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
95 }
96 
97 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
98  VisitSwitchCase(S);
99  Writer.AddStmt(S->getSubStmt());
101 }
102 
103 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
104  VisitStmt(S);
105  Writer.AddDeclRef(S->getDecl(), Record);
106  Writer.AddStmt(S->getSubStmt());
107  Writer.AddSourceLocation(S->getIdentLoc(), Record);
109 }
110 
111 void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
112  VisitStmt(S);
113  Record.push_back(S->getAttrs().size());
114  Writer.WriteAttributes(S->getAttrs(), Record);
115  Writer.AddStmt(S->getSubStmt());
116  Writer.AddSourceLocation(S->getAttrLoc(), Record);
118 }
119 
120 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
121  VisitStmt(S);
122  Writer.AddDeclRef(S->getConditionVariable(), Record);
123  Writer.AddStmt(S->getCond());
124  Writer.AddStmt(S->getThen());
125  Writer.AddStmt(S->getElse());
126  Writer.AddSourceLocation(S->getIfLoc(), Record);
127  Writer.AddSourceLocation(S->getElseLoc(), Record);
129 }
130 
131 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
132  VisitStmt(S);
133  Writer.AddDeclRef(S->getConditionVariable(), Record);
134  Writer.AddStmt(S->getCond());
135  Writer.AddStmt(S->getBody());
136  Writer.AddSourceLocation(S->getSwitchLoc(), Record);
137  Record.push_back(S->isAllEnumCasesCovered());
138  for (SwitchCase *SC = S->getSwitchCaseList(); SC;
139  SC = SC->getNextSwitchCase())
140  Record.push_back(Writer.RecordSwitchCaseID(SC));
142 }
143 
144 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
145  VisitStmt(S);
146  Writer.AddDeclRef(S->getConditionVariable(), Record);
147  Writer.AddStmt(S->getCond());
148  Writer.AddStmt(S->getBody());
149  Writer.AddSourceLocation(S->getWhileLoc(), Record);
151 }
152 
153 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
154  VisitStmt(S);
155  Writer.AddStmt(S->getCond());
156  Writer.AddStmt(S->getBody());
157  Writer.AddSourceLocation(S->getDoLoc(), Record);
158  Writer.AddSourceLocation(S->getWhileLoc(), Record);
159  Writer.AddSourceLocation(S->getRParenLoc(), Record);
161 }
162 
163 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
164  VisitStmt(S);
165  Writer.AddStmt(S->getInit());
166  Writer.AddStmt(S->getCond());
167  Writer.AddDeclRef(S->getConditionVariable(), Record);
168  Writer.AddStmt(S->getInc());
169  Writer.AddStmt(S->getBody());
170  Writer.AddSourceLocation(S->getForLoc(), Record);
171  Writer.AddSourceLocation(S->getLParenLoc(), Record);
172  Writer.AddSourceLocation(S->getRParenLoc(), Record);
174 }
175 
176 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
177  VisitStmt(S);
178  Writer.AddDeclRef(S->getLabel(), Record);
179  Writer.AddSourceLocation(S->getGotoLoc(), Record);
180  Writer.AddSourceLocation(S->getLabelLoc(), Record);
182 }
183 
184 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
185  VisitStmt(S);
186  Writer.AddSourceLocation(S->getGotoLoc(), Record);
187  Writer.AddSourceLocation(S->getStarLoc(), Record);
188  Writer.AddStmt(S->getTarget());
190 }
191 
192 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
193  VisitStmt(S);
194  Writer.AddSourceLocation(S->getContinueLoc(), Record);
196 }
197 
198 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
199  VisitStmt(S);
200  Writer.AddSourceLocation(S->getBreakLoc(), Record);
202 }
203 
204 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
205  VisitStmt(S);
206  Writer.AddStmt(S->getRetValue());
207  Writer.AddSourceLocation(S->getReturnLoc(), Record);
208  Writer.AddDeclRef(S->getNRVOCandidate(), Record);
210 }
211 
212 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
213  VisitStmt(S);
214  Writer.AddSourceLocation(S->getStartLoc(), Record);
215  Writer.AddSourceLocation(S->getEndLoc(), Record);
216  DeclGroupRef DG = S->getDeclGroup();
217  for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
218  Writer.AddDeclRef(*D, Record);
220 }
221 
222 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
223  VisitStmt(S);
224  Record.push_back(S->getNumOutputs());
225  Record.push_back(S->getNumInputs());
226  Record.push_back(S->getNumClobbers());
227  Writer.AddSourceLocation(S->getAsmLoc(), Record);
228  Record.push_back(S->isVolatile());
229  Record.push_back(S->isSimple());
230 }
231 
232 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
233  VisitAsmStmt(S);
234  Writer.AddSourceLocation(S->getRParenLoc(), Record);
235  Writer.AddStmt(S->getAsmString());
236 
237  // Outputs
238  for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
239  Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
240  Writer.AddStmt(S->getOutputConstraintLiteral(I));
241  Writer.AddStmt(S->getOutputExpr(I));
242  }
243 
244  // Inputs
245  for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
246  Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
247  Writer.AddStmt(S->getInputConstraintLiteral(I));
248  Writer.AddStmt(S->getInputExpr(I));
249  }
250 
251  // Clobbers
252  for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
253  Writer.AddStmt(S->getClobberStringLiteral(I));
254 
256 }
257 
258 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
259  VisitAsmStmt(S);
260  Writer.AddSourceLocation(S->getLBraceLoc(), Record);
261  Writer.AddSourceLocation(S->getEndLoc(), Record);
262  Record.push_back(S->getNumAsmToks());
263  Writer.AddString(S->getAsmString(), Record);
264 
265  // Tokens
266  for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {
267  Writer.AddToken(S->getAsmToks()[I], Record);
268  }
269 
270  // Clobbers
271  for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {
272  Writer.AddString(S->getClobber(I), Record);
273  }
274 
275  // Outputs
276  for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
277  Writer.AddStmt(S->getOutputExpr(I));
278  Writer.AddString(S->getOutputConstraint(I), Record);
279  }
280 
281  // Inputs
282  for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
283  Writer.AddStmt(S->getInputExpr(I));
284  Writer.AddString(S->getInputConstraint(I), Record);
285  }
286 
288 }
289 
290 void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {
291  VisitStmt(S);
292  // NumCaptures
293  Record.push_back(std::distance(S->capture_begin(), S->capture_end()));
294 
295  // CapturedDecl and captured region kind
296  Writer.AddDeclRef(S->getCapturedDecl(), Record);
297  Record.push_back(S->getCapturedRegionKind());
298 
299  Writer.AddDeclRef(S->getCapturedRecordDecl(), Record);
300 
301  // Capture inits
302  for (auto *I : S->capture_inits())
303  Writer.AddStmt(I);
304 
305  // Body
306  Writer.AddStmt(S->getCapturedStmt());
307 
308  // Captures
309  for (const auto &I : S->captures()) {
310  if (I.capturesThis() || I.capturesVariableArrayType())
311  Writer.AddDeclRef(nullptr, Record);
312  else
313  Writer.AddDeclRef(I.getCapturedVar(), Record);
314  Record.push_back(I.getCaptureKind());
315  Writer.AddSourceLocation(I.getLocation(), Record);
316  }
317 
319 }
320 
321 void ASTStmtWriter::VisitExpr(Expr *E) {
322  VisitStmt(E);
323  Writer.AddTypeRef(E->getType(), Record);
324  Record.push_back(E->isTypeDependent());
325  Record.push_back(E->isValueDependent());
326  Record.push_back(E->isInstantiationDependent());
327  Record.push_back(E->containsUnexpandedParameterPack());
328  Record.push_back(E->getValueKind());
329  Record.push_back(E->getObjectKind());
330 }
331 
332 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
333  VisitExpr(E);
334  Writer.AddSourceLocation(E->getLocation(), Record);
335  Record.push_back(E->getIdentType()); // FIXME: stable encoding
336  Writer.AddStmt(E->getFunctionName());
338 }
339 
340 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
341  VisitExpr(E);
342 
343  Record.push_back(E->hasQualifier());
344  Record.push_back(E->getDecl() != E->getFoundDecl());
345  Record.push_back(E->hasTemplateKWAndArgsInfo());
346  Record.push_back(E->hadMultipleCandidates());
347  Record.push_back(E->refersToEnclosingVariableOrCapture());
348 
349  if (E->hasTemplateKWAndArgsInfo()) {
350  unsigned NumTemplateArgs = E->getNumTemplateArgs();
351  Record.push_back(NumTemplateArgs);
352  }
353 
355 
356  if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
357  (E->getDecl() == E->getFoundDecl()) &&
360  }
361 
362  if (E->hasQualifier())
363  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
364 
365  if (E->getDecl() != E->getFoundDecl())
366  Writer.AddDeclRef(E->getFoundDecl(), Record);
367 
368  if (E->hasTemplateKWAndArgsInfo())
370 
371  Writer.AddDeclRef(E->getDecl(), Record);
372  Writer.AddSourceLocation(E->getLocation(), Record);
373  Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
375 }
376 
377 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
378  VisitExpr(E);
379  Writer.AddSourceLocation(E->getLocation(), Record);
380  Writer.AddAPInt(E->getValue(), Record);
381 
382  if (E->getValue().getBitWidth() == 32) {
384  }
385 
387 }
388 
389 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
390  VisitExpr(E);
391  Record.push_back(E->getRawSemantics());
392  Record.push_back(E->isExact());
393  Writer.AddAPFloat(E->getValue(), Record);
394  Writer.AddSourceLocation(E->getLocation(), Record);
396 }
397 
398 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
399  VisitExpr(E);
400  Writer.AddStmt(E->getSubExpr());
402 }
403 
404 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
405  VisitExpr(E);
406  Record.push_back(E->getByteLength());
407  Record.push_back(E->getNumConcatenated());
408  Record.push_back(E->getKind());
409  Record.push_back(E->isPascal());
410  // FIXME: String data should be stored as a blob at the end of the
411  // StringLiteral. However, we can't do so now because we have no
412  // provision for coping with abbreviations when we're jumping around
413  // the AST file during deserialization.
414  Record.append(E->getBytes().begin(), E->getBytes().end());
415  for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
416  Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
418 }
419 
420 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
421  VisitExpr(E);
422  Record.push_back(E->getValue());
423  Writer.AddSourceLocation(E->getLocation(), Record);
424  Record.push_back(E->getKind());
425 
427 
429 }
430 
431 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
432  VisitExpr(E);
433  Writer.AddSourceLocation(E->getLParen(), Record);
434  Writer.AddSourceLocation(E->getRParen(), Record);
435  Writer.AddStmt(E->getSubExpr());
437 }
438 
439 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
440  VisitExpr(E);
441  Record.push_back(E->NumExprs);
442  for (unsigned i=0; i != E->NumExprs; ++i)
443  Writer.AddStmt(E->Exprs[i]);
444  Writer.AddSourceLocation(E->LParenLoc, Record);
445  Writer.AddSourceLocation(E->RParenLoc, Record);
447 }
448 
449 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
450  VisitExpr(E);
451  Writer.AddStmt(E->getSubExpr());
452  Record.push_back(E->getOpcode()); // FIXME: stable encoding
453  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
455 }
456 
457 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
458  VisitExpr(E);
459  Record.push_back(E->getNumComponents());
460  Record.push_back(E->getNumExpressions());
461  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
462  Writer.AddSourceLocation(E->getRParenLoc(), Record);
463  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
464  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
465  const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I);
466  Record.push_back(ON.getKind()); // FIXME: Stable encoding
467  Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
468  Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
469  switch (ON.getKind()) {
471  Record.push_back(ON.getArrayExprIndex());
472  break;
473 
475  Writer.AddDeclRef(ON.getField(), Record);
476  break;
477 
479  Writer.AddIdentifierRef(ON.getFieldName(), Record);
480  break;
481 
483  Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
484  break;
485  }
486  }
487  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
488  Writer.AddStmt(E->getIndexExpr(I));
490 }
491 
492 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
493  VisitExpr(E);
494  Record.push_back(E->getKind());
495  if (E->isArgumentType())
496  Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
497  else {
498  Record.push_back(0);
499  Writer.AddStmt(E->getArgumentExpr());
500  }
501  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
502  Writer.AddSourceLocation(E->getRParenLoc(), Record);
504 }
505 
506 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
507  VisitExpr(E);
508  Writer.AddStmt(E->getLHS());
509  Writer.AddStmt(E->getRHS());
510  Writer.AddSourceLocation(E->getRBracketLoc(), Record);
512 }
513 
514 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
515  VisitExpr(E);
516  Record.push_back(E->getNumArgs());
517  Writer.AddSourceLocation(E->getRParenLoc(), Record);
518  Writer.AddStmt(E->getCallee());
519  for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
520  Arg != ArgEnd; ++Arg)
521  Writer.AddStmt(*Arg);
523 }
524 
525 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
526  // Don't call VisitExpr, we'll write everything here.
527 
528  Record.push_back(E->hasQualifier());
529  if (E->hasQualifier())
530  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
531 
532  Record.push_back(E->HasTemplateKWAndArgsInfo);
533  if (E->HasTemplateKWAndArgsInfo) {
534  Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record);
535  unsigned NumTemplateArgs = E->getNumTemplateArgs();
536  Record.push_back(NumTemplateArgs);
537  Writer.AddSourceLocation(E->getLAngleLoc(), Record);
538  Writer.AddSourceLocation(E->getRAngleLoc(), Record);
539  for (unsigned i=0; i != NumTemplateArgs; ++i)
540  Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
541  }
542 
543  Record.push_back(E->hadMultipleCandidates());
544 
545  DeclAccessPair FoundDecl = E->getFoundDecl();
546  Writer.AddDeclRef(FoundDecl.getDecl(), Record);
547  Record.push_back(FoundDecl.getAccess());
548 
549  Writer.AddTypeRef(E->getType(), Record);
550  Record.push_back(E->getValueKind());
551  Record.push_back(E->getObjectKind());
552  Writer.AddStmt(E->getBase());
553  Writer.AddDeclRef(E->getMemberDecl(), Record);
554  Writer.AddSourceLocation(E->getMemberLoc(), Record);
555  Record.push_back(E->isArrow());
556  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
557  Writer.AddDeclarationNameLoc(E->MemberDNLoc,
558  E->getMemberDecl()->getDeclName(), Record);
560 }
561 
562 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
563  VisitExpr(E);
564  Writer.AddStmt(E->getBase());
565  Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
566  Writer.AddSourceLocation(E->getOpLoc(), Record);
567  Record.push_back(E->isArrow());
569 }
570 
571 void ASTStmtWriter::
572 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
573  VisitExpr(E);
574  Writer.AddStmt(E->getSubExpr());
575  Record.push_back(E->shouldCopy());
577 }
578 
579 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
580  VisitExplicitCastExpr(E);
581  Writer.AddSourceLocation(E->getLParenLoc(), Record);
582  Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record);
583  Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
585 }
586 
587 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
588  VisitExpr(E);
589  Record.push_back(E->path_size());
590  Writer.AddStmt(E->getSubExpr());
591  Record.push_back(E->getCastKind()); // FIXME: stable encoding
592 
594  PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
595  Writer.AddCXXBaseSpecifier(**PI, Record);
596 }
597 
598 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
599  VisitExpr(E);
600  Writer.AddStmt(E->getLHS());
601  Writer.AddStmt(E->getRHS());
602  Record.push_back(E->getOpcode()); // FIXME: stable encoding
603  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
604  Record.push_back(E->isFPContractable());
606 }
607 
608 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
609  VisitBinaryOperator(E);
610  Writer.AddTypeRef(E->getComputationLHSType(), Record);
611  Writer.AddTypeRef(E->getComputationResultType(), Record);
613 }
614 
615 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
616  VisitExpr(E);
617  Writer.AddStmt(E->getCond());
618  Writer.AddStmt(E->getLHS());
619  Writer.AddStmt(E->getRHS());
620  Writer.AddSourceLocation(E->getQuestionLoc(), Record);
621  Writer.AddSourceLocation(E->getColonLoc(), Record);
623 }
624 
625 void
626 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
627  VisitExpr(E);
628  Writer.AddStmt(E->getOpaqueValue());
629  Writer.AddStmt(E->getCommon());
630  Writer.AddStmt(E->getCond());
631  Writer.AddStmt(E->getTrueExpr());
632  Writer.AddStmt(E->getFalseExpr());
633  Writer.AddSourceLocation(E->getQuestionLoc(), Record);
634  Writer.AddSourceLocation(E->getColonLoc(), Record);
636 }
637 
638 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
639  VisitCastExpr(E);
640 
641  if (E->path_size() == 0)
643 
645 }
646 
647 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
648  VisitCastExpr(E);
649  Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
650 }
651 
652 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
653  VisitExplicitCastExpr(E);
654  Writer.AddSourceLocation(E->getLParenLoc(), Record);
655  Writer.AddSourceLocation(E->getRParenLoc(), Record);
657 }
658 
659 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
660  VisitExpr(E);
661  Writer.AddSourceLocation(E->getLParenLoc(), Record);
662  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
663  Writer.AddStmt(E->getInitializer());
664  Record.push_back(E->isFileScope());
666 }
667 
668 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
669  VisitExpr(E);
670  Writer.AddStmt(E->getBase());
671  Writer.AddIdentifierRef(&E->getAccessor(), Record);
672  Writer.AddSourceLocation(E->getAccessorLoc(), Record);
674 }
675 
676 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
677  VisitExpr(E);
678  // NOTE: only add the (possibly null) syntactic form.
679  // No need to serialize the isSemanticForm flag and the semantic form.
680  Writer.AddStmt(E->getSyntacticForm());
681  Writer.AddSourceLocation(E->getLBraceLoc(), Record);
682  Writer.AddSourceLocation(E->getRBraceLoc(), Record);
683  bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
684  Record.push_back(isArrayFiller);
685  if (isArrayFiller)
686  Writer.AddStmt(E->getArrayFiller());
687  else
688  Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
689  Record.push_back(E->hadArrayRangeDesignator());
690  Record.push_back(E->getNumInits());
691  if (isArrayFiller) {
692  // ArrayFiller may have filled "holes" due to designated initializer.
693  // Replace them by 0 to indicate that the filler goes in that place.
694  Expr *filler = E->getArrayFiller();
695  for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
696  Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);
697  } else {
698  for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
699  Writer.AddStmt(E->getInit(I));
700  }
702 }
703 
704 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
705  VisitExpr(E);
706  Record.push_back(E->getNumSubExprs());
707  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
708  Writer.AddStmt(E->getSubExpr(I));
709  Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
710  Record.push_back(E->usesGNUSyntax());
712  DEnd = E->designators_end();
713  D != DEnd; ++D) {
714  if (D->isFieldDesignator()) {
715  if (FieldDecl *Field = D->getField()) {
716  Record.push_back(serialization::DESIG_FIELD_DECL);
717  Writer.AddDeclRef(Field, Record);
718  } else {
719  Record.push_back(serialization::DESIG_FIELD_NAME);
720  Writer.AddIdentifierRef(D->getFieldName(), Record);
721  }
722  Writer.AddSourceLocation(D->getDotLoc(), Record);
723  Writer.AddSourceLocation(D->getFieldLoc(), Record);
724  } else if (D->isArrayDesignator()) {
725  Record.push_back(serialization::DESIG_ARRAY);
726  Record.push_back(D->getFirstExprIndex());
727  Writer.AddSourceLocation(D->getLBracketLoc(), Record);
728  Writer.AddSourceLocation(D->getRBracketLoc(), Record);
729  } else {
730  assert(D->isArrayRangeDesignator() && "Unknown designator");
731  Record.push_back(serialization::DESIG_ARRAY_RANGE);
732  Record.push_back(D->getFirstExprIndex());
733  Writer.AddSourceLocation(D->getLBracketLoc(), Record);
734  Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
735  Writer.AddSourceLocation(D->getRBracketLoc(), Record);
736  }
737  }
739 }
740 
741 void ASTStmtWriter::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
742  VisitExpr(E);
743  Writer.AddStmt(E->getBase());
744  Writer.AddStmt(E->getUpdater());
746 }
747 
748 void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {
749  VisitExpr(E);
751 }
752 
753 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
754  VisitExpr(E);
756 }
757 
758 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
759  VisitExpr(E);
760  Writer.AddStmt(E->getSubExpr());
761  Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
762  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
763  Writer.AddSourceLocation(E->getRParenLoc(), Record);
765 }
766 
767 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
768  VisitExpr(E);
769  Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
770  Writer.AddSourceLocation(E->getLabelLoc(), Record);
771  Writer.AddDeclRef(E->getLabel(), Record);
773 }
774 
775 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
776  VisitExpr(E);
777  Writer.AddStmt(E->getSubStmt());
778  Writer.AddSourceLocation(E->getLParenLoc(), Record);
779  Writer.AddSourceLocation(E->getRParenLoc(), Record);
781 }
782 
783 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
784  VisitExpr(E);
785  Writer.AddStmt(E->getCond());
786  Writer.AddStmt(E->getLHS());
787  Writer.AddStmt(E->getRHS());
788  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
789  Writer.AddSourceLocation(E->getRParenLoc(), Record);
790  Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());
792 }
793 
794 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
795  VisitExpr(E);
796  Writer.AddSourceLocation(E->getTokenLocation(), Record);
798 }
799 
800 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
801  VisitExpr(E);
802  Record.push_back(E->getNumSubExprs());
803  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
804  Writer.AddStmt(E->getExpr(I));
805  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
806  Writer.AddSourceLocation(E->getRParenLoc(), Record);
808 }
809 
810 void ASTStmtWriter::VisitConvertVectorExpr(ConvertVectorExpr *E) {
811  VisitExpr(E);
812  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
813  Writer.AddSourceLocation(E->getRParenLoc(), Record);
814  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
815  Writer.AddStmt(E->getSrcExpr());
817 }
818 
819 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
820  VisitExpr(E);
821  Writer.AddDeclRef(E->getBlockDecl(), Record);
823 }
824 
825 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
826  VisitExpr(E);
827  Record.push_back(E->getNumAssocs());
828 
829  Writer.AddStmt(E->getControllingExpr());
830  for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
831  Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
832  Writer.AddStmt(E->getAssocExpr(I));
833  }
834  Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
835 
836  Writer.AddSourceLocation(E->getGenericLoc(), Record);
837  Writer.AddSourceLocation(E->getDefaultLoc(), Record);
838  Writer.AddSourceLocation(E->getRParenLoc(), Record);
840 }
841 
842 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
843  VisitExpr(E);
844  Record.push_back(E->getNumSemanticExprs());
845 
846  // Push the result index. Currently, this needs to exactly match
847  // the encoding used internally for ResultIndex.
848  unsigned result = E->getResultExprIndex();
849  result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
850  Record.push_back(result);
851 
852  Writer.AddStmt(E->getSyntacticForm());
854  i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
855  Writer.AddStmt(*i);
856  }
858 }
859 
860 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
861  VisitExpr(E);
862  Record.push_back(E->getOp());
863  for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
864  Writer.AddStmt(E->getSubExprs()[I]);
865  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
866  Writer.AddSourceLocation(E->getRParenLoc(), Record);
868 }
869 
870 //===----------------------------------------------------------------------===//
871 // Objective-C Expressions and Statements.
872 //===----------------------------------------------------------------------===//
873 
874 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
875  VisitExpr(E);
876  Writer.AddStmt(E->getString());
877  Writer.AddSourceLocation(E->getAtLoc(), Record);
879 }
880 
881 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
882  VisitExpr(E);
883  Writer.AddStmt(E->getSubExpr());
884  Writer.AddDeclRef(E->getBoxingMethod(), Record);
885  Writer.AddSourceRange(E->getSourceRange(), Record);
887 }
888 
889 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
890  VisitExpr(E);
891  Record.push_back(E->getNumElements());
892  for (unsigned i = 0; i < E->getNumElements(); i++)
893  Writer.AddStmt(E->getElement(i));
894  Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record);
895  Writer.AddSourceRange(E->getSourceRange(), Record);
897 }
898 
899 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
900  VisitExpr(E);
901  Record.push_back(E->getNumElements());
902  Record.push_back(E->HasPackExpansions);
903  for (unsigned i = 0; i < E->getNumElements(); i++) {
905  Writer.AddStmt(Element.Key);
906  Writer.AddStmt(Element.Value);
907  if (E->HasPackExpansions) {
908  Writer.AddSourceLocation(Element.EllipsisLoc, Record);
909  unsigned NumExpansions = 0;
910  if (Element.NumExpansions)
911  NumExpansions = *Element.NumExpansions + 1;
912  Record.push_back(NumExpansions);
913  }
914  }
915 
916  Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record);
917  Writer.AddSourceRange(E->getSourceRange(), Record);
919 }
920 
921 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
922  VisitExpr(E);
923  Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
924  Writer.AddSourceLocation(E->getAtLoc(), Record);
925  Writer.AddSourceLocation(E->getRParenLoc(), Record);
927 }
928 
929 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
930  VisitExpr(E);
931  Writer.AddSelectorRef(E->getSelector(), Record);
932  Writer.AddSourceLocation(E->getAtLoc(), Record);
933  Writer.AddSourceLocation(E->getRParenLoc(), Record);
935 }
936 
937 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
938  VisitExpr(E);
939  Writer.AddDeclRef(E->getProtocol(), Record);
940  Writer.AddSourceLocation(E->getAtLoc(), Record);
941  Writer.AddSourceLocation(E->ProtoLoc, Record);
942  Writer.AddSourceLocation(E->getRParenLoc(), Record);
944 }
945 
946 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
947  VisitExpr(E);
948  Writer.AddDeclRef(E->getDecl(), Record);
949  Writer.AddSourceLocation(E->getLocation(), Record);
950  Writer.AddSourceLocation(E->getOpLoc(), Record);
951  Writer.AddStmt(E->getBase());
952  Record.push_back(E->isArrow());
953  Record.push_back(E->isFreeIvar());
955 }
956 
957 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
958  VisitExpr(E);
959  Record.push_back(E->SetterAndMethodRefFlags.getInt());
960  Record.push_back(E->isImplicitProperty());
961  if (E->isImplicitProperty()) {
962  Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
963  Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
964  } else {
965  Writer.AddDeclRef(E->getExplicitProperty(), Record);
966  }
967  Writer.AddSourceLocation(E->getLocation(), Record);
968  Writer.AddSourceLocation(E->getReceiverLocation(), Record);
969  if (E->isObjectReceiver()) {
970  Record.push_back(0);
971  Writer.AddStmt(E->getBase());
972  } else if (E->isSuperReceiver()) {
973  Record.push_back(1);
974  Writer.AddTypeRef(E->getSuperReceiverType(), Record);
975  } else {
976  Record.push_back(2);
977  Writer.AddDeclRef(E->getClassReceiver(), Record);
978  }
979 
981 }
982 
983 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
984  VisitExpr(E);
985  Writer.AddSourceLocation(E->getRBracket(), Record);
986  Writer.AddStmt(E->getBaseExpr());
987  Writer.AddStmt(E->getKeyExpr());
988  Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record);
989  Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record);
990 
992 }
993 
994 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
995  VisitExpr(E);
996  Record.push_back(E->getNumArgs());
997  Record.push_back(E->getNumStoredSelLocs());
998  Record.push_back(E->SelLocsKind);
999  Record.push_back(E->isDelegateInitCall());
1000  Record.push_back(E->IsImplicit);
1001  Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
1002  switch (E->getReceiverKind()) {
1004  Writer.AddStmt(E->getInstanceReceiver());
1005  break;
1006 
1008  Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
1009  break;
1010 
1013  Writer.AddTypeRef(E->getSuperType(), Record);
1014  Writer.AddSourceLocation(E->getSuperLoc(), Record);
1015  break;
1016  }
1017 
1018  if (E->getMethodDecl()) {
1019  Record.push_back(1);
1020  Writer.AddDeclRef(E->getMethodDecl(), Record);
1021  } else {
1022  Record.push_back(0);
1023  Writer.AddSelectorRef(E->getSelector(), Record);
1024  }
1025 
1026  Writer.AddSourceLocation(E->getLeftLoc(), Record);
1027  Writer.AddSourceLocation(E->getRightLoc(), Record);
1028 
1029  for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
1030  Arg != ArgEnd; ++Arg)
1031  Writer.AddStmt(*Arg);
1032 
1033  SourceLocation *Locs = E->getStoredSelLocs();
1034  for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
1035  Writer.AddSourceLocation(Locs[i], Record);
1036 
1038 }
1039 
1040 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1041  VisitStmt(S);
1042  Writer.AddStmt(S->getElement());
1043  Writer.AddStmt(S->getCollection());
1044  Writer.AddStmt(S->getBody());
1045  Writer.AddSourceLocation(S->getForLoc(), Record);
1046  Writer.AddSourceLocation(S->getRParenLoc(), Record);
1048 }
1049 
1050 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1051  Writer.AddStmt(S->getCatchBody());
1052  Writer.AddDeclRef(S->getCatchParamDecl(), Record);
1053  Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
1054  Writer.AddSourceLocation(S->getRParenLoc(), Record);
1056 }
1057 
1058 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1059  Writer.AddStmt(S->getFinallyBody());
1060  Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
1062 }
1063 
1064 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1065  Writer.AddStmt(S->getSubStmt());
1066  Writer.AddSourceLocation(S->getAtLoc(), Record);
1068 }
1069 
1070 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1071  Record.push_back(S->getNumCatchStmts());
1072  Record.push_back(S->getFinallyStmt() != nullptr);
1073  Writer.AddStmt(S->getTryBody());
1074  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1075  Writer.AddStmt(S->getCatchStmt(I));
1076  if (S->getFinallyStmt())
1077  Writer.AddStmt(S->getFinallyStmt());
1078  Writer.AddSourceLocation(S->getAtTryLoc(), Record);
1080 }
1081 
1082 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1083  Writer.AddStmt(S->getSynchExpr());
1084  Writer.AddStmt(S->getSynchBody());
1085  Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
1087 }
1088 
1089 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1090  Writer.AddStmt(S->getThrowExpr());
1091  Writer.AddSourceLocation(S->getThrowLoc(), Record);
1093 }
1094 
1095 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1096  VisitExpr(E);
1097  Record.push_back(E->getValue());
1098  Writer.AddSourceLocation(E->getLocation(), Record);
1100 }
1101 
1102 //===----------------------------------------------------------------------===//
1103 // C++ Expressions and Statements.
1104 //===----------------------------------------------------------------------===//
1105 
1106 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1107  VisitStmt(S);
1108  Writer.AddSourceLocation(S->getCatchLoc(), Record);
1109  Writer.AddDeclRef(S->getExceptionDecl(), Record);
1110  Writer.AddStmt(S->getHandlerBlock());
1112 }
1113 
1114 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1115  VisitStmt(S);
1116  Record.push_back(S->getNumHandlers());
1117  Writer.AddSourceLocation(S->getTryLoc(), Record);
1118  Writer.AddStmt(S->getTryBlock());
1119  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1120  Writer.AddStmt(S->getHandler(i));
1122 }
1123 
1124 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1125  VisitStmt(S);
1126  Writer.AddSourceLocation(S->getForLoc(), Record);
1127  Writer.AddSourceLocation(S->getColonLoc(), Record);
1128  Writer.AddSourceLocation(S->getRParenLoc(), Record);
1129  Writer.AddStmt(S->getRangeStmt());
1130  Writer.AddStmt(S->getBeginEndStmt());
1131  Writer.AddStmt(S->getCond());
1132  Writer.AddStmt(S->getInc());
1133  Writer.AddStmt(S->getLoopVarStmt());
1134  Writer.AddStmt(S->getBody());
1136 }
1137 
1138 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1139  VisitStmt(S);
1140  Writer.AddSourceLocation(S->getKeywordLoc(), Record);
1141  Record.push_back(S->isIfExists());
1142  Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record);
1143  Writer.AddDeclarationNameInfo(S->getNameInfo(), Record);
1144  Writer.AddStmt(S->getSubStmt());
1146 }
1147 
1148 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1149  VisitCallExpr(E);
1150  Record.push_back(E->getOperator());
1151  Writer.AddSourceRange(E->Range, Record);
1152  Record.push_back(E->isFPContractable());
1154 }
1155 
1156 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1157  VisitCallExpr(E);
1159 }
1160 
1161 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1162  VisitExpr(E);
1163  Record.push_back(E->getNumArgs());
1164  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1165  Writer.AddStmt(E->getArg(I));
1166  Writer.AddDeclRef(E->getConstructor(), Record);
1167  Writer.AddSourceLocation(E->getLocation(), Record);
1168  Record.push_back(E->isElidable());
1169  Record.push_back(E->hadMultipleCandidates());
1170  Record.push_back(E->isListInitialization());
1171  Record.push_back(E->isStdInitListInitialization());
1172  Record.push_back(E->requiresZeroInitialization());
1173  Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1174  Writer.AddSourceRange(E->getParenOrBraceRange(), Record);
1176 }
1177 
1178 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1179  VisitCXXConstructExpr(E);
1180  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1182 }
1183 
1184 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1185  VisitExpr(E);
1186  Record.push_back(E->NumCaptures);
1187  unsigned NumArrayIndexVars = 0;
1188  if (E->HasArrayIndexVars)
1189  NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures];
1190  Record.push_back(NumArrayIndexVars);
1191  Writer.AddSourceRange(E->IntroducerRange, Record);
1192  Record.push_back(E->CaptureDefault); // FIXME: stable encoding
1193  Writer.AddSourceLocation(E->CaptureDefaultLoc, Record);
1194  Record.push_back(E->ExplicitParams);
1195  Record.push_back(E->ExplicitResultType);
1196  Writer.AddSourceLocation(E->ClosingBrace, Record);
1197 
1198  // Add capture initializers.
1200  CEnd = E->capture_init_end();
1201  C != CEnd; ++C) {
1202  Writer.AddStmt(*C);
1203  }
1204 
1205  // Add array index variables, if any.
1206  if (NumArrayIndexVars) {
1207  Record.append(E->getArrayIndexStarts(),
1208  E->getArrayIndexStarts() + E->NumCaptures + 1);
1209  VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1210  for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1211  Writer.AddDeclRef(ArrayIndexVars[I], Record);
1212  }
1213 
1215 }
1216 
1217 void ASTStmtWriter::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1218  VisitExpr(E);
1219  Writer.AddStmt(E->getSubExpr());
1221 }
1222 
1223 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1224  VisitExplicitCastExpr(E);
1226  Record);
1227  Writer.AddSourceRange(E->getAngleBrackets(), Record);
1228 }
1229 
1230 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1231  VisitCXXNamedCastExpr(E);
1233 }
1234 
1235 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1236  VisitCXXNamedCastExpr(E);
1238 }
1239 
1240 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1241  VisitCXXNamedCastExpr(E);
1243 }
1244 
1245 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1246  VisitCXXNamedCastExpr(E);
1248 }
1249 
1250 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1251  VisitExplicitCastExpr(E);
1252  Writer.AddSourceLocation(E->getLParenLoc(), Record);
1253  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1255 }
1256 
1257 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1258  VisitCallExpr(E);
1259  Writer.AddSourceLocation(E->UDSuffixLoc, Record);
1261 }
1262 
1263 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1264  VisitExpr(E);
1265  Record.push_back(E->getValue());
1266  Writer.AddSourceLocation(E->getLocation(), Record);
1268 }
1269 
1270 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1271  VisitExpr(E);
1272  Writer.AddSourceLocation(E->getLocation(), Record);
1274 }
1275 
1276 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1277  VisitExpr(E);
1278  Writer.AddSourceRange(E->getSourceRange(), Record);
1279  if (E->isTypeOperand()) {
1280  Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1282  } else {
1283  Writer.AddStmt(E->getExprOperand());
1285  }
1286 }
1287 
1288 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1289  VisitExpr(E);
1290  Writer.AddSourceLocation(E->getLocation(), Record);
1291  Record.push_back(E->isImplicit());
1293 }
1294 
1295 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1296  VisitExpr(E);
1297  Writer.AddSourceLocation(E->getThrowLoc(), Record);
1298  Writer.AddStmt(E->getSubExpr());
1299  Record.push_back(E->isThrownVariableInScope());
1301 }
1302 
1303 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1304  VisitExpr(E);
1305 
1306  bool HasOtherExprStored = E->Param.getInt();
1307  // Store these first, the reader reads them before creation.
1308  Record.push_back(HasOtherExprStored);
1309  if (HasOtherExprStored)
1310  Writer.AddStmt(E->getExpr());
1311  Writer.AddDeclRef(E->getParam(), Record);
1312  Writer.AddSourceLocation(E->getUsedLocation(), Record);
1313 
1315 }
1316 
1317 void ASTStmtWriter::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1318  VisitExpr(E);
1319  Writer.AddDeclRef(E->getField(), Record);
1320  Writer.AddSourceLocation(E->getExprLoc(), Record);
1322 }
1323 
1324 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1325  VisitExpr(E);
1326  Writer.AddCXXTemporary(E->getTemporary(), Record);
1327  Writer.AddStmt(E->getSubExpr());
1329 }
1330 
1331 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1332  VisitExpr(E);
1333  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1334  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1336 }
1337 
1338 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1339  VisitExpr(E);
1340  Record.push_back(E->isGlobalNew());
1341  Record.push_back(E->isArray());
1342  Record.push_back(E->doesUsualArrayDeleteWantSize());
1343  Record.push_back(E->getNumPlacementArgs());
1344  Record.push_back(E->StoredInitializationStyle);
1345  Writer.AddDeclRef(E->getOperatorNew(), Record);
1346  Writer.AddDeclRef(E->getOperatorDelete(), Record);
1347  Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1348  Writer.AddSourceRange(E->getTypeIdParens(), Record);
1349  Writer.AddSourceRange(E->getSourceRange(), Record);
1350  Writer.AddSourceRange(E->getDirectInitRange(), Record);
1351  for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1352  I != e; ++I)
1353  Writer.AddStmt(*I);
1354 
1356 }
1357 
1358 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1359  VisitExpr(E);
1360  Record.push_back(E->isGlobalDelete());
1361  Record.push_back(E->isArrayForm());
1362  Record.push_back(E->isArrayFormAsWritten());
1363  Record.push_back(E->doesUsualArrayDeleteWantSize());
1364  Writer.AddDeclRef(E->getOperatorDelete(), Record);
1365  Writer.AddStmt(E->getArgument());
1366  Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1367 
1369 }
1370 
1371 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1372  VisitExpr(E);
1373 
1374  Writer.AddStmt(E->getBase());
1375  Record.push_back(E->isArrow());
1376  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1377  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1378  Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1379  Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1380  Writer.AddSourceLocation(E->getTildeLoc(), Record);
1381 
1382  // PseudoDestructorTypeStorage.
1383  Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1384  if (E->getDestroyedTypeIdentifier())
1385  Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1386  else
1387  Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1388 
1390 }
1391 
1392 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1393  VisitExpr(E);
1394  Record.push_back(E->getNumObjects());
1395  for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
1396  Writer.AddDeclRef(E->getObject(i), Record);
1397 
1398  Writer.AddStmt(E->getSubExpr());
1400 }
1401 
1402 void
1403 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1404  VisitExpr(E);
1405 
1406  // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1407  // emitted first.
1408 
1409  Record.push_back(E->HasTemplateKWAndArgsInfo);
1410  if (E->HasTemplateKWAndArgsInfo) {
1411  const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo();
1412  Record.push_back(Args.NumTemplateArgs);
1414  }
1415 
1416  if (!E->isImplicitAccess())
1417  Writer.AddStmt(E->getBase());
1418  else
1419  Writer.AddStmt(nullptr);
1420  Writer.AddTypeRef(E->getBaseType(), Record);
1421  Record.push_back(E->isArrow());
1422  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1423  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1424  Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1425  Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1427 }
1428 
1429 void
1430 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1431  VisitExpr(E);
1432 
1433  // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1434  // emitted first.
1435 
1436  Record.push_back(E->HasTemplateKWAndArgsInfo);
1437  if (E->HasTemplateKWAndArgsInfo) {
1438  const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo();
1439  Record.push_back(Args.NumTemplateArgs);
1441  }
1442 
1443  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1444  Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1446 }
1447 
1448 void
1449 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1450  VisitExpr(E);
1451  Record.push_back(E->arg_size());
1453  ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1454  Writer.AddStmt(*ArgI);
1455  Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1456  Writer.AddSourceLocation(E->getLParenLoc(), Record);
1457  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1459 }
1460 
1461 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1462  VisitExpr(E);
1463 
1464  // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1465  // emitted first.
1466 
1467  Record.push_back(E->HasTemplateKWAndArgsInfo);
1468  if (E->HasTemplateKWAndArgsInfo) {
1470  Record.push_back(Args.NumTemplateArgs);
1472  }
1473 
1474  Record.push_back(E->getNumDecls());
1476  OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1477  Writer.AddDeclRef(OvI.getDecl(), Record);
1478  Record.push_back(OvI.getAccess());
1479  }
1480 
1481  Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1482  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1483 }
1484 
1485 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1486  VisitOverloadExpr(E);
1487  Record.push_back(E->isArrow());
1488  Record.push_back(E->hasUnresolvedUsing());
1489  Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : nullptr);
1490  Writer.AddTypeRef(E->getBaseType(), Record);
1491  Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1493 }
1494 
1495 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1496  VisitOverloadExpr(E);
1497  Record.push_back(E->requiresADL());
1498  Record.push_back(E->isOverloaded());
1499  Writer.AddDeclRef(E->getNamingClass(), Record);
1501 }
1502 
1503 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1504  VisitExpr(E);
1505  Record.push_back(E->TypeTraitExprBits.NumArgs);
1506  Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1507  Record.push_back(E->TypeTraitExprBits.Value);
1508  Writer.AddSourceRange(E->getSourceRange(), Record);
1509  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1510  Writer.AddTypeSourceInfo(E->getArg(I), Record);
1512 }
1513 
1514 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1515  VisitExpr(E);
1516  Record.push_back(E->getTrait());
1517  Record.push_back(E->getValue());
1518  Writer.AddSourceRange(E->getSourceRange(), Record);
1519  Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1521 }
1522 
1523 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1524  VisitExpr(E);
1525  Record.push_back(E->getTrait());
1526  Record.push_back(E->getValue());
1527  Writer.AddSourceRange(E->getSourceRange(), Record);
1528  Writer.AddStmt(E->getQueriedExpression());
1530 }
1531 
1532 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1533  VisitExpr(E);
1534  Record.push_back(E->getValue());
1535  Writer.AddSourceRange(E->getSourceRange(), Record);
1536  Writer.AddStmt(E->getOperand());
1538 }
1539 
1540 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1541  VisitExpr(E);
1542  Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1543  Record.push_back(E->NumExpansions);
1544  Writer.AddStmt(E->getPattern());
1546 }
1547 
1548 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1549  VisitExpr(E);
1550  Writer.AddSourceLocation(E->OperatorLoc, Record);
1551  Writer.AddSourceLocation(E->PackLoc, Record);
1552  Writer.AddSourceLocation(E->RParenLoc, Record);
1553  Record.push_back(E->Length);
1554  Writer.AddDeclRef(E->Pack, Record);
1556 }
1557 
1558 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1560  VisitExpr(E);
1561  Writer.AddDeclRef(E->getParameter(), Record);
1562  Writer.AddSourceLocation(E->getNameLoc(), Record);
1563  Writer.AddStmt(E->getReplacement());
1565 }
1566 
1567 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1569  VisitExpr(E);
1570  Writer.AddDeclRef(E->getParameterPack(), Record);
1571  Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1572  Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1574 }
1575 
1576 void ASTStmtWriter::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1577  VisitExpr(E);
1578  Record.push_back(E->getNumExpansions());
1579  Writer.AddDeclRef(E->getParameterPack(), Record);
1580  Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1581  for (FunctionParmPackExpr::iterator I = E->begin(), End = E->end();
1582  I != End; ++I)
1583  Writer.AddDeclRef(*I, Record);
1585 }
1586 
1587 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1588  VisitExpr(E);
1589  Writer.AddStmt(E->getTemporary());
1590  Writer.AddDeclRef(E->getExtendingDecl(), Record);
1591  Record.push_back(E->getManglingNumber());
1593 }
1594 
1595 void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
1596  VisitExpr(E);
1597  Writer.AddSourceLocation(E->LParenLoc, Record);
1598  Writer.AddSourceLocation(E->EllipsisLoc, Record);
1599  Writer.AddSourceLocation(E->RParenLoc, Record);
1600  Writer.AddStmt(E->SubExprs[0]);
1601  Writer.AddStmt(E->SubExprs[1]);
1602  Record.push_back(E->Opcode);
1604 }
1605 
1606 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1607  VisitExpr(E);
1608  Writer.AddStmt(E->getSourceExpr());
1609  Writer.AddSourceLocation(E->getLocation(), Record);
1611 }
1612 
1613 void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {
1614  VisitExpr(E);
1615  // TODO: Figure out sane writer behavior for a TypoExpr, if necessary
1616  assert(false && "Cannot write TypoExpr nodes");
1617 }
1618 
1619 //===----------------------------------------------------------------------===//
1620 // CUDA Expressions and Statements.
1621 //===----------------------------------------------------------------------===//
1622 
1623 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1624  VisitCallExpr(E);
1625  Writer.AddStmt(E->getConfig());
1627 }
1628 
1629 //===----------------------------------------------------------------------===//
1630 // OpenCL Expressions and Statements.
1631 //===----------------------------------------------------------------------===//
1632 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1633  VisitExpr(E);
1634  Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1635  Writer.AddSourceLocation(E->getRParenLoc(), Record);
1636  Writer.AddStmt(E->getSrcExpr());
1638 }
1639 
1640 //===----------------------------------------------------------------------===//
1641 // Microsoft Expressions and Statements.
1642 //===----------------------------------------------------------------------===//
1643 void ASTStmtWriter::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1644  VisitExpr(E);
1645  Record.push_back(E->isArrow());
1646  Writer.AddStmt(E->getBaseExpr());
1647  Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1648  Writer.AddSourceLocation(E->getMemberLoc(), Record);
1649  Writer.AddDeclRef(E->getPropertyDecl(), Record);
1651 }
1652 
1653 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1654  VisitExpr(E);
1655  Writer.AddSourceRange(E->getSourceRange(), Record);
1656  if (E->isTypeOperand()) {
1657  Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1659  } else {
1660  Writer.AddStmt(E->getExprOperand());
1662  }
1663 }
1664 
1665 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1666  VisitStmt(S);
1667  Writer.AddSourceLocation(S->getExceptLoc(), Record);
1668  Writer.AddStmt(S->getFilterExpr());
1669  Writer.AddStmt(S->getBlock());
1671 }
1672 
1673 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1674  VisitStmt(S);
1675  Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1676  Writer.AddStmt(S->getBlock());
1678 }
1679 
1680 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1681  VisitStmt(S);
1682  Record.push_back(S->getIsCXXTry());
1683  Writer.AddSourceLocation(S->getTryLoc(), Record);
1684  Writer.AddStmt(S->getTryBlock());
1685  Writer.AddStmt(S->getHandler());
1687 }
1688 
1689 void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1690  VisitStmt(S);
1691  Writer.AddSourceLocation(S->getLeaveLoc(), Record);
1693 }
1694 
1695 //===----------------------------------------------------------------------===//
1696 // OpenMP Clauses.
1697 //===----------------------------------------------------------------------===//
1698 
1699 namespace clang {
1700 class OMPClauseWriter : public OMPClauseVisitor<OMPClauseWriter> {
1701  ASTStmtWriter *Writer;
1702  ASTWriter::RecordData &Record;
1703 public:
1705  : Writer(W), Record(Record) { }
1706 #define OPENMP_CLAUSE(Name, Class) \
1707  void Visit##Class(Class *S);
1708 #include "clang/Basic/OpenMPKinds.def"
1709  void writeClause(OMPClause *C);
1710 };
1711 }
1712 
1714  Record.push_back(C->getClauseKind());
1715  Visit(C);
1716  Writer->Writer.AddSourceLocation(C->getLocStart(), Record);
1717  Writer->Writer.AddSourceLocation(C->getLocEnd(), Record);
1718 }
1719 
1720 void OMPClauseWriter::VisitOMPIfClause(OMPIfClause *C) {
1721  Writer->Writer.AddStmt(C->getCondition());
1722  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1723 }
1724 
1725 void OMPClauseWriter::VisitOMPFinalClause(OMPFinalClause *C) {
1726  Writer->Writer.AddStmt(C->getCondition());
1727  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1728 }
1729 
1730 void OMPClauseWriter::VisitOMPNumThreadsClause(OMPNumThreadsClause *C) {
1731  Writer->Writer.AddStmt(C->getNumThreads());
1732  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1733 }
1734 
1735 void OMPClauseWriter::VisitOMPSafelenClause(OMPSafelenClause *C) {
1736  Writer->Writer.AddStmt(C->getSafelen());
1737  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1738 }
1739 
1740 void OMPClauseWriter::VisitOMPCollapseClause(OMPCollapseClause *C) {
1741  Writer->Writer.AddStmt(C->getNumForLoops());
1742  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1743 }
1744 
1745 void OMPClauseWriter::VisitOMPDefaultClause(OMPDefaultClause *C) {
1746  Record.push_back(C->getDefaultKind());
1747  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1748  Writer->Writer.AddSourceLocation(C->getDefaultKindKwLoc(), Record);
1749 }
1750 
1751 void OMPClauseWriter::VisitOMPProcBindClause(OMPProcBindClause *C) {
1752  Record.push_back(C->getProcBindKind());
1753  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1754  Writer->Writer.AddSourceLocation(C->getProcBindKindKwLoc(), Record);
1755 }
1756 
1757 void OMPClauseWriter::VisitOMPScheduleClause(OMPScheduleClause *C) {
1758  Record.push_back(C->getScheduleKind());
1759  Writer->Writer.AddStmt(C->getChunkSize());
1760  Writer->Writer.AddStmt(C->getHelperChunkSize());
1761  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1762  Writer->Writer.AddSourceLocation(C->getScheduleKindLoc(), Record);
1763  Writer->Writer.AddSourceLocation(C->getCommaLoc(), Record);
1764 }
1765 
1766 void OMPClauseWriter::VisitOMPOrderedClause(OMPOrderedClause *) {}
1767 
1768 void OMPClauseWriter::VisitOMPNowaitClause(OMPNowaitClause *) {}
1769 
1770 void OMPClauseWriter::VisitOMPUntiedClause(OMPUntiedClause *) {}
1771 
1772 void OMPClauseWriter::VisitOMPMergeableClause(OMPMergeableClause *) {}
1773 
1774 void OMPClauseWriter::VisitOMPReadClause(OMPReadClause *) {}
1775 
1776 void OMPClauseWriter::VisitOMPWriteClause(OMPWriteClause *) {}
1777 
1778 void OMPClauseWriter::VisitOMPUpdateClause(OMPUpdateClause *) {}
1779 
1780 void OMPClauseWriter::VisitOMPCaptureClause(OMPCaptureClause *) {}
1781 
1782 void OMPClauseWriter::VisitOMPSeqCstClause(OMPSeqCstClause *) {}
1783 
1784 void OMPClauseWriter::VisitOMPPrivateClause(OMPPrivateClause *C) {
1785  Record.push_back(C->varlist_size());
1786  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1787  for (auto *VE : C->varlists()) {
1788  Writer->Writer.AddStmt(VE);
1789  }
1790  for (auto *VE : C->private_copies()) {
1791  Writer->Writer.AddStmt(VE);
1792  }
1793 }
1794 
1795 void OMPClauseWriter::VisitOMPFirstprivateClause(OMPFirstprivateClause *C) {
1796  Record.push_back(C->varlist_size());
1797  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1798  for (auto *VE : C->varlists()) {
1799  Writer->Writer.AddStmt(VE);
1800  }
1801  for (auto *VE : C->private_copies()) {
1802  Writer->Writer.AddStmt(VE);
1803  }
1804  for (auto *VE : C->inits()) {
1805  Writer->Writer.AddStmt(VE);
1806  }
1807 }
1808 
1809 void OMPClauseWriter::VisitOMPLastprivateClause(OMPLastprivateClause *C) {
1810  Record.push_back(C->varlist_size());
1811  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1812  for (auto *VE : C->varlists())
1813  Writer->Writer.AddStmt(VE);
1814  for (auto *E : C->private_copies())
1815  Writer->Writer.AddStmt(E);
1816  for (auto *E : C->source_exprs())
1817  Writer->Writer.AddStmt(E);
1818  for (auto *E : C->destination_exprs())
1819  Writer->Writer.AddStmt(E);
1820  for (auto *E : C->assignment_ops())
1821  Writer->Writer.AddStmt(E);
1822 }
1823 
1824 void OMPClauseWriter::VisitOMPSharedClause(OMPSharedClause *C) {
1825  Record.push_back(C->varlist_size());
1826  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1827  for (auto *VE : C->varlists())
1828  Writer->Writer.AddStmt(VE);
1829 }
1830 
1831 void OMPClauseWriter::VisitOMPReductionClause(OMPReductionClause *C) {
1832  Record.push_back(C->varlist_size());
1833  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1834  Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1835  Writer->Writer.AddNestedNameSpecifierLoc(C->getQualifierLoc(), Record);
1836  Writer->Writer.AddDeclarationNameInfo(C->getNameInfo(), Record);
1837  for (auto *VE : C->varlists())
1838  Writer->Writer.AddStmt(VE);
1839  for (auto *E : C->lhs_exprs())
1840  Writer->Writer.AddStmt(E);
1841  for (auto *E : C->rhs_exprs())
1842  Writer->Writer.AddStmt(E);
1843  for (auto *E : C->reduction_ops())
1844  Writer->Writer.AddStmt(E);
1845 }
1846 
1847 void OMPClauseWriter::VisitOMPLinearClause(OMPLinearClause *C) {
1848  Record.push_back(C->varlist_size());
1849  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1850  Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1851  for (auto *VE : C->varlists()) {
1852  Writer->Writer.AddStmt(VE);
1853  }
1854  for (auto *VE : C->inits()) {
1855  Writer->Writer.AddStmt(VE);
1856  }
1857  for (auto *VE : C->updates()) {
1858  Writer->Writer.AddStmt(VE);
1859  }
1860  for (auto *VE : C->finals()) {
1861  Writer->Writer.AddStmt(VE);
1862  }
1863  Writer->Writer.AddStmt(C->getStep());
1864  Writer->Writer.AddStmt(C->getCalcStep());
1865 }
1866 
1867 void OMPClauseWriter::VisitOMPAlignedClause(OMPAlignedClause *C) {
1868  Record.push_back(C->varlist_size());
1869  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1870  Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1871  for (auto *VE : C->varlists())
1872  Writer->Writer.AddStmt(VE);
1873  Writer->Writer.AddStmt(C->getAlignment());
1874 }
1875 
1876 void OMPClauseWriter::VisitOMPCopyinClause(OMPCopyinClause *C) {
1877  Record.push_back(C->varlist_size());
1878  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1879  for (auto *VE : C->varlists())
1880  Writer->Writer.AddStmt(VE);
1881  for (auto *E : C->source_exprs())
1882  Writer->Writer.AddStmt(E);
1883  for (auto *E : C->destination_exprs())
1884  Writer->Writer.AddStmt(E);
1885  for (auto *E : C->assignment_ops())
1886  Writer->Writer.AddStmt(E);
1887 }
1888 
1889 void OMPClauseWriter::VisitOMPCopyprivateClause(OMPCopyprivateClause *C) {
1890  Record.push_back(C->varlist_size());
1891  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1892  for (auto *VE : C->varlists())
1893  Writer->Writer.AddStmt(VE);
1894  for (auto *E : C->source_exprs())
1895  Writer->Writer.AddStmt(E);
1896  for (auto *E : C->destination_exprs())
1897  Writer->Writer.AddStmt(E);
1898  for (auto *E : C->assignment_ops())
1899  Writer->Writer.AddStmt(E);
1900 }
1901 
1902 void OMPClauseWriter::VisitOMPFlushClause(OMPFlushClause *C) {
1903  Record.push_back(C->varlist_size());
1904  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1905  for (auto *VE : C->varlists())
1906  Writer->Writer.AddStmt(VE);
1907 }
1908 
1909 void OMPClauseWriter::VisitOMPDependClause(OMPDependClause *C) {
1910  Record.push_back(C->varlist_size());
1911  Writer->Writer.AddSourceLocation(C->getLParenLoc(), Record);
1912  Record.push_back(C->getDependencyKind());
1913  Writer->Writer.AddSourceLocation(C->getDependencyLoc(), Record);
1914  Writer->Writer.AddSourceLocation(C->getColonLoc(), Record);
1915  for (auto *VE : C->varlists())
1916  Writer->Writer.AddStmt(VE);
1917 }
1918 
1919 //===----------------------------------------------------------------------===//
1920 // OpenMP Directives.
1921 //===----------------------------------------------------------------------===//
1922 void ASTStmtWriter::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
1923  Writer.AddSourceLocation(E->getLocStart(), Record);
1924  Writer.AddSourceLocation(E->getLocEnd(), Record);
1925  OMPClauseWriter ClauseWriter(this, Record);
1926  for (unsigned i = 0; i < E->getNumClauses(); ++i) {
1927  ClauseWriter.writeClause(E->getClause(i));
1928  }
1929  if (E->hasAssociatedStmt())
1930  Writer.AddStmt(E->getAssociatedStmt());
1931 }
1932 
1933 void ASTStmtWriter::VisitOMPLoopDirective(OMPLoopDirective *D) {
1934  VisitStmt(D);
1935  Record.push_back(D->getNumClauses());
1936  Record.push_back(D->getCollapsedNumber());
1937  VisitOMPExecutableDirective(D);
1938  Writer.AddStmt(D->getIterationVariable());
1939  Writer.AddStmt(D->getLastIteration());
1940  Writer.AddStmt(D->getCalcLastIteration());
1941  Writer.AddStmt(D->getPreCond());
1942  Writer.AddStmt(D->getCond());
1943  Writer.AddStmt(D->getInit());
1944  Writer.AddStmt(D->getInc());
1946  Writer.AddStmt(D->getIsLastIterVariable());
1947  Writer.AddStmt(D->getLowerBoundVariable());
1948  Writer.AddStmt(D->getUpperBoundVariable());
1949  Writer.AddStmt(D->getStrideVariable());
1950  Writer.AddStmt(D->getEnsureUpperBound());
1951  Writer.AddStmt(D->getNextLowerBound());
1952  Writer.AddStmt(D->getNextUpperBound());
1953  }
1954  for (auto I : D->counters()) {
1955  Writer.AddStmt(I);
1956  }
1957  for (auto I : D->inits()) {
1958  Writer.AddStmt(I);
1959  }
1960  for (auto I : D->updates()) {
1961  Writer.AddStmt(I);
1962  }
1963  for (auto I : D->finals()) {
1964  Writer.AddStmt(I);
1965  }
1966 }
1967 
1968 void ASTStmtWriter::VisitOMPParallelDirective(OMPParallelDirective *D) {
1969  VisitStmt(D);
1970  Record.push_back(D->getNumClauses());
1971  VisitOMPExecutableDirective(D);
1973 }
1974 
1975 void ASTStmtWriter::VisitOMPSimdDirective(OMPSimdDirective *D) {
1976  VisitOMPLoopDirective(D);
1978 }
1979 
1980 void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {
1981  VisitOMPLoopDirective(D);
1983 }
1984 
1985 void ASTStmtWriter::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
1986  VisitOMPLoopDirective(D);
1988 }
1989 
1990 void ASTStmtWriter::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
1991  VisitStmt(D);
1992  Record.push_back(D->getNumClauses());
1993  VisitOMPExecutableDirective(D);
1995 }
1996 
1997 void ASTStmtWriter::VisitOMPSectionDirective(OMPSectionDirective *D) {
1998  VisitStmt(D);
1999  VisitOMPExecutableDirective(D);
2001 }
2002 
2003 void ASTStmtWriter::VisitOMPSingleDirective(OMPSingleDirective *D) {
2004  VisitStmt(D);
2005  Record.push_back(D->getNumClauses());
2006  VisitOMPExecutableDirective(D);
2008 }
2009 
2010 void ASTStmtWriter::VisitOMPMasterDirective(OMPMasterDirective *D) {
2011  VisitStmt(D);
2012  VisitOMPExecutableDirective(D);
2014 }
2015 
2016 void ASTStmtWriter::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2017  VisitStmt(D);
2018  VisitOMPExecutableDirective(D);
2019  Writer.AddDeclarationNameInfo(D->getDirectiveName(), Record);
2021 }
2022 
2023 void ASTStmtWriter::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2024  VisitOMPLoopDirective(D);
2026 }
2027 
2028 void ASTStmtWriter::VisitOMPParallelForSimdDirective(
2030  VisitOMPLoopDirective(D);
2032 }
2033 
2034 void ASTStmtWriter::VisitOMPParallelSectionsDirective(
2036  VisitStmt(D);
2037  Record.push_back(D->getNumClauses());
2038  VisitOMPExecutableDirective(D);
2040 }
2041 
2042 void ASTStmtWriter::VisitOMPTaskDirective(OMPTaskDirective *D) {
2043  VisitStmt(D);
2044  Record.push_back(D->getNumClauses());
2045  VisitOMPExecutableDirective(D);
2047 }
2048 
2049 void ASTStmtWriter::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2050  VisitStmt(D);
2051  Record.push_back(D->getNumClauses());
2052  VisitOMPExecutableDirective(D);
2053  Writer.AddStmt(D->getX());
2054  Writer.AddStmt(D->getV());
2055  Writer.AddStmt(D->getExpr());
2056  Writer.AddStmt(D->getUpdateExpr());
2057  Record.push_back(D->isXLHSInRHSPart() ? 1 : 0);
2058  Record.push_back(D->isPostfixUpdate() ? 1 : 0);
2060 }
2061 
2062 void ASTStmtWriter::VisitOMPTargetDirective(OMPTargetDirective *D) {
2063  VisitStmt(D);
2064  Record.push_back(D->getNumClauses());
2065  VisitOMPExecutableDirective(D);
2067 }
2068 
2069 void ASTStmtWriter::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2070  VisitStmt(D);
2071  VisitOMPExecutableDirective(D);
2073 }
2074 
2075 void ASTStmtWriter::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2076  VisitStmt(D);
2077  VisitOMPExecutableDirective(D);
2079 }
2080 
2081 void ASTStmtWriter::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2082  VisitStmt(D);
2083  VisitOMPExecutableDirective(D);
2085 }
2086 
2087 void ASTStmtWriter::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2088  VisitStmt(D);
2089  VisitOMPExecutableDirective(D);
2091 }
2092 
2093 void ASTStmtWriter::VisitOMPFlushDirective(OMPFlushDirective *D) {
2094  VisitStmt(D);
2095  Record.push_back(D->getNumClauses());
2096  VisitOMPExecutableDirective(D);
2098 }
2099 
2100 void ASTStmtWriter::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2101  VisitStmt(D);
2102  VisitOMPExecutableDirective(D);
2104 }
2105 
2106 void ASTStmtWriter::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2107  VisitStmt(D);
2108  Record.push_back(D->getNumClauses());
2109  VisitOMPExecutableDirective(D);
2111 }
2112 
2113 void ASTStmtWriter::VisitOMPCancellationPointDirective(
2115  VisitStmt(D);
2116  VisitOMPExecutableDirective(D);
2117  Record.push_back(D->getCancelRegion());
2119 }
2120 
2121 void ASTStmtWriter::VisitOMPCancelDirective(OMPCancelDirective *D) {
2122  VisitStmt(D);
2123  VisitOMPExecutableDirective(D);
2124  Record.push_back(D->getCancelRegion());
2126 }
2127 
2128 //===----------------------------------------------------------------------===//
2129 // ASTWriter Implementation
2130 //===----------------------------------------------------------------------===//
2131 
2133  assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
2134  "SwitchCase recorded twice");
2135  unsigned NextID = SwitchCaseIDs.size();
2136  SwitchCaseIDs[S] = NextID;
2137  return NextID;
2138 }
2139 
2141  assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
2142  "SwitchCase hasn't been seen yet");
2143  return SwitchCaseIDs[S];
2144 }
2145 
2147  SwitchCaseIDs.clear();
2148 }
2149 
2150 /// \brief Write the given substatement or subexpression to the
2151 /// bitstream.
2152 void ASTWriter::WriteSubStmt(Stmt *S,
2153  llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries,
2154  llvm::DenseSet<Stmt *> &ParentStmts) {
2155  RecordData Record;
2156  ASTStmtWriter Writer(*this, Record);
2157  ++NumStatements;
2158 
2159  if (!S) {
2160  Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
2161  return;
2162  }
2163 
2164  llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
2165  if (I != SubStmtEntries.end()) {
2166  Record.push_back(I->second);
2167  Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
2168  return;
2169  }
2170 
2171 #ifndef NDEBUG
2172  assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
2173 
2174  struct ParentStmtInserterRAII {
2175  Stmt *S;
2176  llvm::DenseSet<Stmt *> &ParentStmts;
2177 
2178  ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
2179  : S(S), ParentStmts(ParentStmts) {
2180  ParentStmts.insert(S);
2181  }
2182  ~ParentStmtInserterRAII() {
2183  ParentStmts.erase(S);
2184  }
2185  };
2186 
2187  ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
2188 #endif
2189 
2190  // Redirect ASTWriter::AddStmt to collect sub-stmts.
2191  SmallVector<Stmt *, 16> SubStmts;
2192  CollectedStmts = &SubStmts;
2193 
2194  Writer.Code = serialization::STMT_NULL_PTR;
2195  Writer.AbbrevToUse = 0;
2196  Writer.Visit(S);
2197 
2198 #ifndef NDEBUG
2199  if (Writer.Code == serialization::STMT_NULL_PTR) {
2200  SourceManager &SrcMgr
2201  = DeclIDs.begin()->first->getASTContext().getSourceManager();
2202  S->dump(SrcMgr);
2203  llvm_unreachable("Unhandled sub-statement writing AST file");
2204  }
2205 #endif
2206 
2207  // Revert ASTWriter::AddStmt.
2208  CollectedStmts = &StmtsToEmit;
2209 
2210  // Write the sub-stmts in reverse order, last to first. When reading them back
2211  // we will read them in correct order by "pop"ing them from the Stmts stack.
2212  // This simplifies reading and allows to store a variable number of sub-stmts
2213  // without knowing it in advance.
2214  while (!SubStmts.empty())
2215  WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts);
2216 
2217  Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
2218 
2219  SubStmtEntries[S] = Stream.GetCurrentBitNo();
2220 }
2221 
2222 /// \brief Flush all of the statements that have been added to the
2223 /// queue via AddStmt().
2225  RecordData Record;
2226 
2227  // We expect to be the only consumer of the two temporary statement maps,
2228  // assert that they are empty.
2229  assert(SubStmtEntries.empty() && "unexpected entries in sub-stmt map");
2230  assert(ParentStmts.empty() && "unexpected entries in parent stmt map");
2231 
2232  for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
2233  WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts);
2234 
2235  assert(N == StmtsToEmit.size() &&
2236  "Substatement written via AddStmt rather than WriteSubStmt!");
2237 
2238  // Note that we are at the end of a full expression. Any
2239  // expression records that follow this one are part of a different
2240  // expression.
2241  Stream.EmitRecord(serialization::STMT_STOP, Record);
2242 
2243  SubStmtEntries.clear();
2244  ParentStmts.clear();
2245  }
2246 
2247  StmtsToEmit.clear();
2248 }
void AddTemplateArgument(const TemplateArgument &Arg, RecordDataImpl &Record)
Emit a template argument.
Definition: ASTWriter.cpp:5293
SourceLocation getRParenLoc() const
Definition: Expr.h:3421
Expr * getInc()
Definition: Stmt.h:1178
A PredefinedExpr record.
Definition: ASTBitCodes.h:1169
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:54
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1006
Represents a single C99 designator.
Definition: Expr.h:4035
ValueDecl * getMemberDecl() const
Retrieve the member declaration to which this expression refers.
Definition: Expr.h:2411
SourceRange getParenOrBraceRange() const
Definition: ExprCXX.h:1218
Defines the clang::ASTContext interface.
A CompoundLiteralExpr record.
Definition: ASTBitCodes.h:1209
unsigned getNumInits() const
Definition: Expr.h:3789
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:989
SourceLocation getEnd() const
const SwitchCase * getNextSwitchCase() const
Definition: Stmt.h:667
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
Definition: Expr.h:1137
const Expr * getBase() const
Definition: ExprObjC.h:504
ParmVarDecl *const * iterator
Iterators over the parameters which the parameter pack expanded into.
Definition: ExprCXX.h:3706
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:466
CastKind getCastKind() const
Definition: Expr.h:2709
ExprObjectKind getObjectKind() const
Definition: Expr.h:411
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:1295
serialization::StmtCode Code
TypeSourceInfo * getDestroyedTypeInfo() const
Retrieve the source location information for the type being destroyed.
Definition: ExprCXX.h:2034
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
Definition: Stmt.h:2104
NamedDecl * getFoundDecl()
Get the NamedDecl through which this reference occurred.
Definition: Expr.h:1034
unsigned arg_size() const
Retrieve the number of arguments.
Definition: ExprCXX.h:2900
unsigned getNumOutputs() const
Definition: Stmt.h:1447
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:2627
The receiver is an object instance.
Definition: ExprObjC.h:1002
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprCXX.h:3363
bool isXLHSInRHSPart() const
Return true if helper update expression has form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' and...
Definition: StmtOpenMP.h:1743
Expr * getSyntacticForm()
Definition: Expr.h:4756
bool isFPContractable() const
Definition: ExprCXX.h:110
void AddDeclarationNameInfo(const DeclarationNameInfo &NameInfo, RecordDataImpl &Record)
Definition: ASTWriter.cpp:5123
const DeclGroupRef getDeclGroup() const
Definition: Stmt.h:470
An IndirectGotoStmt record.
Definition: ASTBitCodes.h:1153
This represents clause 'copyin' in the '#pragma omp ...' directives.
bool isFileScope() const
Definition: Expr.h:2621
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:224
SourceLocation getColonLoc() const
Get colon location.
helper_expr_const_range source_exprs() const
bool containsUnexpandedParameterPack() const
Whether this expression contains an unexpanded parameter pack (for C++11 variadic templates)...
Definition: Expr.h:215
An AddrLabelExpr record.
Definition: ASTBitCodes.h:1225
NameKind
NameKind - The kind of name this object contains.
SourceLocation getLParenLoc() const
Retrieve the location of the left parentheses ('(') that precedes the argument list.
Definition: ExprCXX.h:2891
bool isResultDependent() const
Whether this generic selection is result-dependent.
Definition: Expr.h:4502
bool getValue() const
Definition: ExprCXX.h:446
bool isPascal() const
Definition: Expr.h:1569
SourceLocation getOperatorLoc() const
Retrieve the location of the '->' or '.' operator.
Definition: ExprCXX.h:3288
SourceLocation getThrowLoc() const
Definition: ExprCXX.h:831
void AddToken(const Token &Tok, RecordDataImpl &Record)
Emit a token.
Definition: ASTWriter.cpp:3947
SourceLocation getLParenLoc() const
Definition: Stmt.h:1193
SourceLocation getCommaLoc()
Get location of ','.
Definition: OpenMPClause.h:655
SourceLocation getLocation() const
Definition: ExprObjC.h:513
bool isElidable() const
Whether this construction is elidable.
Definition: ExprCXX.h:1144
Expr * getCond()
Definition: Stmt.h:1066
Expr * getExpr(unsigned Index)
getExpr - Return the Expr at the specified index.
Definition: Expr.h:3479
bool isDelegateInitCall() const
Definition: ExprObjC.h:1303
A CXXStaticCastExpr record.
Definition: ASTBitCodes.h:1311
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2083
An AttributedStmt record.
Definition: ASTBitCodes.h:1139
void AddAPInt(const llvm::APInt &Value, RecordDataImpl &Record)
Emit an integral value.
Definition: ASTWriter.cpp:4741
CompoundStmt * getSubStmt()
Definition: Expr.h:3412
A CXXReinterpretCastExpr record.
Definition: ASTBitCodes.h:1315
SourceLocation getTemplateKeywordLoc() const
Retrieve the location of the template keyword preceding the member name, if any.
Definition: Expr.h:2466
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the member name, with source location information...
Definition: ExprCXX.h:3060
unsigned getNumAsmToks()
Definition: Stmt.h:1760
A ObjCBoolLiteralExpr record.
Definition: ASTBitCodes.h:1291
private_copies_range private_copies()
CharacterKind getKind() const
Definition: Expr.h:1342
Expr *const * semantics_iterator
Definition: Expr.h:4778
TypeSourceInfo * getScopeTypeInfo() const
Retrieve the scope type in a qualified pseudo-destructor expression.
Definition: ExprCXX.h:2018
CXXCatchStmt * getHandler(unsigned i)
Definition: StmtCXX.h:104
bool isArgumentType() const
Definition: Expr.h:2013
bool isGlobalDelete() const
Definition: ExprCXX.h:1852
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:765
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:543
SourceLocation getForLoc() const
Definition: StmtObjC.h:53
OpenMPProcBindClauseKind getProcBindKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:546
TypeSourceInfo * getTypeSourceInfo() const
Definition: Expr.h:1918
SourceRange getTypeIdParens() const
Definition: ExprCXX.h:1736
An ImplicitValueInitExpr record.
Definition: ASTBitCodes.h:1219
iterator end()
Definition: DeclGroup.h:109
SourceLocation getLParenLoc() const
Definition: Expr.h:3419
AccessSpecifier getAccess() const
ObjCMethodDecl * getAtIndexMethodDecl() const
Definition: ExprObjC.h:815
An ImplicitCastExpr record.
Definition: ASTBitCodes.h:1205
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2500
This represents 'if' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:154
Defines the C++ template declaration subclasses.
Represents an attribute applied to a statement.
Definition: Stmt.h:833
TypeSourceInfo * getArg(unsigned I) const
Retrieve the Ith argument.
Definition: ExprCXX.h:2135
SourceLocation getRParenLoc() const
Definition: ExprObjC.h:412
capture_init_range capture_inits() const
Definition: Stmt.h:2167
A CXXOperatorCallExpr record.
Definition: ASTBitCodes.h:1303
SourceLocation getBuiltinLoc() const
getBuiltinLoc - Return the location of the __builtin_astype token.
Definition: Expr.h:4668
A CXXTemporaryObjectExpr record.
Definition: ASTBitCodes.h:1309
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:313
unsigned getDeclRefExprAbbrev() const
Definition: ASTWriter.h:827
unsigned getResultIndex() const
Definition: Expr.h:4507
SourceLocation getLabelLoc() const
Definition: Expr.h:3373
void AddTypeSourceInfo(TypeSourceInfo *TInfo, RecordDataImpl &Record)
Emits a reference to a declarator info.
Definition: ASTWriter.cpp:4887
InitListExpr * getSyntacticForm() const
Definition: Expr.h:3891
SourceLocation getIfLoc() const
Definition: Stmt.h:925
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1075
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1604
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2182
SourceLocation getColonLoc() const
Returns the location of ':'.
This represents 'update' clause in the '#pragma omp atomic' directive.
Definition: OpenMPClause.h:866
const Stmt * getElse() const
Definition: Stmt.h:918
SourceLocation getOperatorLoc() const
Definition: Expr.h:2958
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:1102
void AddTypeRef(QualType T, RecordDataImpl &Record)
Emit a reference to a type.
Definition: ASTWriter.cpp:4905
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "for" statement, if any.
Definition: Stmt.cpp:925
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:134
iterator begin() const
Definition: ExprCXX.h:3707
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:3746
Expr * getAlignment()
Returns alignment.
SourceLocation getEndLoc() const
Definition: Stmt.h:1755
CompoundStmt * getBlock() const
Definition: Stmt.h:1895
IdentType getIdentType() const
Definition: Expr.h:1201
bool doesUsualArrayDeleteWantSize() const
Definition: ExprCXX.h:1860
bool isConditionTrue() const
Definition: Expr.h:3592
Expr * getIndexExpr(unsigned Idx)
Definition: Expr.h:1939
bool hadArrayRangeDesignator() const
Definition: Expr.h:3902
ObjCDictionaryElement getKeyValueElement(unsigned Index) const
Definition: ExprObjC.h:316
Stmt * getSubStmt()
Definition: Stmt.h:763
bool isImplicit() const
Definition: ExprCXX.h:792
This represents 'read' clause in the '#pragma omp atomic' directive.
Definition: OpenMPClause.h:808
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprCXX.h:1801
Expr * getOperand() const
Definition: ExprCXX.h:3359
SourceLocation getReturnLoc() const
Definition: Stmt.h:1370
This represents clause 'private' in the '#pragma omp ...' directives.
Definition: OpenMPClause.h:956
This represents 'num_threads' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:261
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprCXX.h:601
const Expr * getCallee() const
Definition: Expr.h:2188
varlist_range varlists()
Definition: OpenMPClause.h:119
StringRef getInputConstraint(unsigned i) const
Definition: Stmt.h:1784
unsigned size() const
Definition: Stmt.h:580
SourceLocation getLocation() const
Retrieve the location of the literal.
Definition: Expr.h:1304
const TypeSourceInfo * getAssocTypeSourceInfo(unsigned i) const
Definition: Expr.h:4484
void AddCXXTemporary(const CXXTemporary *Temp, RecordDataImpl &Record)
Emit a CXXTemporary.
Definition: ASTWriter.cpp:4821
SourceLocation getDoLoc() const
Definition: Stmt.h:1118
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:492
SourceLocation getRParenLoc() const
Definition: Stmt.h:1572
Expr * getInc() const
Definition: StmtOpenMP.h:537
UnaryExprOrTypeTrait getKind() const
Definition: Expr.h:2008
This represents implicit clause 'flush' for the '#pragma omp flush' directive. This clause does not e...
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:1800
Expr * getCond() const
getCond - Return the condition expression; this is defined in terms of the opaque value...
Definition: Expr.h:3305
capture_iterator capture_begin()
Retrieve an iterator pointing to the first capture.
Definition: Stmt.h:2151
A CXXConstructExpr record.
Definition: ASTBitCodes.h:1307
const ParmVarDecl * getParam() const
Definition: ExprCXX.h:907
SourceLocation getLParenLoc() const
Definition: ExprObjC.h:1526
raw_arg_iterator raw_arg_begin()
Definition: ExprCXX.h:1787
unsigned getValue() const
Definition: Expr.h:1349
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:808
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprObjC.h:117
QualType getBaseType() const
Definition: ExprCXX.h:3277
unsigned path_size() const
Definition: Expr.h:2728
SourceLocation getLocation() const
Definition: Expr.h:1002
bool isArrow() const
Definition: ExprObjC.h:1397
SourceLocation getEllipsisLoc() const
Definition: Stmt.h:712
SourceLocation getAtLoc() const
Definition: ExprObjC.h:372
void AddIdentifierRef(const IdentifierInfo *II, RecordDataImpl &Record)
Emit a reference to an identifier.
Definition: ASTWriter.cpp:4756
ArrayTypeTrait getTrait() const
Definition: ExprCXX.h:2225
bool getIsCXXTry() const
Definition: Stmt.h:1934
TypeSourceInfo * getTypeSourceInfo() const
Retrieve the type source information for the type being constructed.
Definition: ExprCXX.h:2887
A ShuffleVectorExpr record.
Definition: ASTBitCodes.h:1233
This represents 'safelen' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:319
SourceLocation getDestroyedTypeLoc() const
Retrieve the starting location of the type being destroyed.
Definition: ExprCXX.h:2049
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:238
OpenMPDirectiveKind getDirectiveKind() const
Definition: StmtOpenMP.h:189
SourceLocation getRParenLoc() const
Return the location of the right parentheses.
Definition: Expr.h:1915
Represents a C99 designated initializer expression.
Definition: Expr.h:3961
SourceLocation getIsaMemberLoc() const
Definition: ExprObjC.h:1402
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:240
Expr * getNumThreads() const
Returns number of threads.
Definition: OpenMPClause.h:297
An OffsetOfExpr record.
Definition: ASTBitCodes.h:1189
Stmt * getBody()
Definition: Stmt.h:1114
An ObjCAtThrowStmt record.
Definition: ASTBitCodes.h:1287
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:450
CompoundStmt * getSubStmt() const
Retrieve the compound statement that will be included in the program only if the existence of the sym...
Definition: StmtCXX.h:274
Expr * getSubExpr(unsigned Idx) const
Definition: Expr.h:4239
An element in an Objective-C dictionary literal.
Definition: ExprObjC.h:207
A DesignatedInitExpr record.
Definition: ASTBitCodes.h:1215
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:219
unsigned getNumInputs() const
Definition: Stmt.h:1469
ObjCInterfaceDecl * getClassReceiver() const
Definition: ExprObjC.h:691
unsigned getNumSemanticExprs() const
Definition: Expr.h:4776
unsigned getNumAssocs() const
Definition: Expr.h:4473
bool getValue() const
Definition: ExprCXX.h:3365
SourceLocation getAmpAmpLoc() const
Definition: Expr.h:3371
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:3268
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4279
unsigned getManglingNumber() const
Definition: ExprCXX.h:3810
SourceLocation getLocStart() const
Returns the starting location of the clause.
Definition: OpenMPClause.h:46
StringLiteral * getString()
Definition: ExprObjC.h:40
SourceLocation getRParen() const
Get the location of the right parentheses ')'.
Definition: Expr.h:1650
const TemplateArgumentLoc * getTemplateArgs() const
Retrieve the template arguments provided as part of this template-id.
Definition: Expr.h:2524
ASTTemplateKWAndArgsInfo * getTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
Definition: ExprCXX.h:3454
IdentifierInfo * getFieldName() const
For a field or identifier offsetof node, returns the name of the field.
Definition: Expr.cpp:1333
ArrayRef< Expr * > updates()
Definition: StmtOpenMP.h:606
TypeSourceInfo * getTypeSourceInfo() const
Definition: ExprCXX.h:1310
DeclarationNameInfo getNameInfo() const
Retrieve the name of the entity we're testing for, along with location information.
Definition: StmtCXX.h:270
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3209
SourceLocation getAtLoc() const
Definition: ExprObjC.h:44
IdentifierInfo & getAccessor() const
Definition: Expr.h:4565
SourceLocation getLBracLoc() const
Definition: Stmt.h:633
Expr * getSubExpr()
Definition: Expr.h:2713
SourceLocation getLBraceLoc() const
Definition: Stmt.h:1753
This represents '#pragma omp barrier' directive.
Definition: StmtOpenMP.h:1395
const DeclarationNameInfo & getNameInfo() const
Gets the name info for specified reduction identifier.
SourceLocation getLAngleLoc() const
Retrieve the location of the left angle bracket starting the explicit template argument list followin...
Definition: Expr.h:2473
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc...
Definition: StmtOpenMP.h:268
SourceLocation getRAngleLoc() const
Retrieve the location of the right angle bracket ending the explicit template argument list following...
Definition: Expr.h:2480
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:3613
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:1036
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:1986
SourceLocation getRParenLoc() const
Definition: Expr.h:2283
Expr * getFilterExpr() const
Definition: Stmt.h:1855
bool isFPContractable() const
Definition: Expr.h:3082
SourceLocation getSuperLoc() const
Retrieve the location of the 'super' keyword for a class or instance message to 'super', otherwise an invalid source location.
Definition: ExprObjC.h:1193
Expr * getLHS() const
Definition: Expr.h:2964
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:94
bool isOverloaded() const
True if this lookup is overloaded.
Definition: ExprCXX.h:2570
SourceLocation getWhileLoc() const
Definition: Stmt.h:1073
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:74
const CompoundStmt * getSynchBody() const
Definition: StmtObjC.h:282
const VarDecl * getNRVOCandidate() const
Retrieve the variable that might be used for the named return value optimization. ...
Definition: Stmt.h:1378
This represents clause 'copyprivate' in the '#pragma omp ...' directives.
Describes an C or C++ initializer list.
Definition: Expr.h:3759
SmallVector< uint64_t, 64 > RecordData
Definition: ASTWriter.h:85
ObjCMethodDecl * getBoxingMethod() const
Definition: ExprObjC.h:109
IdentifierInfo * getOutputIdentifier(unsigned i) const
Definition: Stmt.h:1640
const Stmt * getFinallyBody() const
Definition: StmtObjC.h:132
ArrayRef< Expr * > finals()
Definition: StmtOpenMP.h:612
ObjCBridgeCastKind getBridgeKind() const
Determine which kind of bridge is being performed via this cast.
Definition: ExprObjC.h:1529
IdentifierInfo * getDestroyedTypeIdentifier() const
In a dependent pseudo-destructor expression for which we do not have full type information on the des...
Definition: ExprCXX.h:2041
helper_expr_const_range private_copies() const
const ValueDecl * getExtendingDecl() const
Get the declaration which triggered the lifetime-extension of this temporary, if any.
Definition: ExprCXX.h:3803
SourceLocation getAtFinallyLoc() const
Definition: StmtObjC.h:141
Expr * getX()
Get 'x' part of the associated expression/statement.
Definition: StmtOpenMP.h:1727
QualType getSuperType() const
Retrieve the type referred to by 'super'.
Definition: ExprObjC.h:1228
bool isSuperReceiver() const
Definition: ExprObjC.h:695
SourceLocation getRParenLoc() const
Definition: Stmt.h:1123
capture_init_iterator capture_init_end() const
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1518
A reference to a previously [de]serialized Stmt record.
Definition: ASTBitCodes.h:1127
Stmt * getHandlerBlock() const
Definition: StmtCXX.h:52
Expr * getExprOperand() const
Definition: ExprCXX.h:589
path_iterator path_begin()
Definition: Expr.h:2729
Stmt * getBody()
Definition: Stmt.h:1179
SourceLocation getLParen() const
Get the location of the left parentheses '('.
Definition: Expr.h:1646
helper_expr_const_range source_exprs() const
OpenMPScheduleClauseKind getScheduleKind() const
Get kind of the clause.
Definition: OpenMPClause.h:646
const Expr * getSubExpr() const
Definition: Expr.h:3690
semantics_iterator semantics_end()
Definition: Expr.h:4786
SourceLocation getRParenLoc() const
Definition: Expr.h:3700
void AddSourceRange(SourceRange Range, RecordDataImpl &Record)
Emit a source range.
Definition: ASTWriter.cpp:4736
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:2918
SourceLocation getLocation() const
Definition: ExprCXX.h:452
Selector getSelector() const
Definition: Expr.cpp:3718
SourceLocation RAngleLoc
The source location of the right angle bracket ('>').
Definition: TemplateBase.h:569
SourceLocation getRBraceLoc() const
Definition: Expr.h:3884
bool isValueDependent() const
Definition: Expr.h:146
Stmt * getInit()
Definition: Stmt.h:1158
Expr * getOutputExpr(unsigned i)
Definition: Stmt.cpp:395
iterator begin()
Definition: DeclGroup.h:103
bool requiresADL() const
Definition: ExprCXX.h:2567
void AddSelectorRef(Selector, RecordDataImpl &Record)
Emit a Selector (which is a smart pointer reference).
Definition: ASTWriter.cpp:4798
SourceLocation getThrowLoc()
Definition: StmtObjC.h:329
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:1885
This represents 'default' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:426
Expr * getBaseExpr() const
Definition: ExprCXX.h:666
const Stmt * getCatchBody() const
Definition: StmtObjC.h:90
This represents 'final' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:207
This represents 'mergeable' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:779
Expr * getCond()
Definition: Stmt.h:1177
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:1828
Expr * getLHS() const
Definition: Expr.h:3233
bool isConditionDependent() const
Definition: Expr.h:3599
This represents clause 'reduction' in the '#pragma omp ...' directives.
void AddTemplateArgumentLoc(const TemplateArgumentLoc &Arg, RecordDataImpl &Record)
Emits a template argument location.
Definition: ASTWriter.cpp:4872
FieldDecl * getField()
Get the field whose initializer will be used.
Definition: ExprCXX.h:973
A marker record that indicates that we are at the end of an expression.
Definition: ASTBitCodes.h:1123
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1032
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:206
StringLiteral * getClobberStringLiteral(unsigned i)
Definition: Stmt.h:1714
Expr * Key
The key for the dictionary element.
Definition: ExprObjC.h:209
CXXTemporary * getTemporary()
Definition: ExprCXX.h:1052
bool isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a worksharing directive.
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1343
TypeSourceInfo * getTypeInfoAsWritten() const
Definition: Expr.h:2844
const RecordDecl * getCapturedRecordDecl() const
Retrieve the record declaration for captured variables.
Definition: Stmt.h:2126
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:2954
const Expr * getBase() const
Definition: ExprObjC.h:677
CleanupObject getObject(unsigned i) const
Definition: ExprCXX.h:2801
bool isArrow() const
Determine whether this pseudo-destructor expression was written using an '->' (otherwise, it used a '.').
Definition: ExprCXX.h:2004
ASTTemplateKWAndArgsInfo * getTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
Definition: Expr.h:1049
bool hadMultipleCandidates() const
Returns true if this member expression refers to a method that was resolved from an overloaded set ha...
Definition: Expr.h:2568
SourceLocation getLocation() const
Definition: Expr.h:1203
ObjCMethodDecl * setAtIndexMethodDecl() const
Definition: ExprObjC.h:819
SourceLocation getUsedLocation() const
Retrieve the location where this default argument was actually used.
Definition: ExprCXX.h:924
SourceLocation getDefaultLoc() const
Definition: Expr.h:4476
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:862
ExpressionTrait getTrait() const
Definition: ExprCXX.h:2286
SourceLocation getSwitchLoc() const
Definition: Stmt.h:998
Represents the this expression in C++.
Definition: ExprCXX.h:770
bool hadMultipleCandidates() const
Whether the referred constructor was resolved from an overloaded set having size greater than 1...
Definition: ExprCXX.h:1149
Expr * getCond() const
Definition: StmtOpenMP.h:529
arg_iterator arg_end()
Definition: Expr.h:2247
MSPropertyDecl * getPropertyDecl() const
Definition: ExprCXX.h:667
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:500
Extends ASTTemplateArgumentListInfo with the source location information for the template keyword; th...
Definition: TemplateBase.h:611
OpenMPDefaultClauseKind getDefaultKind() const
Returns kind of the clause.
Definition: OpenMPClause.h:475
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
Definition: Expr.h:3542
SourceLocation getBuiltinLoc() const
Definition: Expr.h:3697
unsigned RecordSwitchCaseID(SwitchCase *S)
Record an ID for the given switch-case statement.
Expr * getRHS() const
Definition: Expr.h:3234
OpenMPClauseKind getClauseKind() const
Returns kind of OpenMP clause (private, shared, reduction, etc.).
Definition: OpenMPClause.h:56
SourceLocation getReceiverLocation() const
Definition: ExprObjC.h:686
SourceLocation getOperatorLoc() const LLVM_READONLY
Definition: Expr.h:2546
OpenMPDependClauseKind getDependencyKind() const
Get dependency type.
CXXBaseSpecifier * getBase() const
For a base class node, returns the base specifier.
Definition: Expr.h:1865
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:1864
SourceLocation getColonColonLoc() const
Retrieve the location of the '::' in a qualified pseudo-destructor expression.
Definition: ExprCXX.h:2022
void AddNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS, RecordDataImpl &Record)
Emit a nested name specifier with source-location information.
Definition: ASTWriter.cpp:5185
SourceLocation getRParenLoc() const
Definition: ExprObjC.h:455
SourceLocation getLocEnd() const
Returns the ending location of the clause.
Definition: OpenMPClause.h:48
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:2398
SourceLocation getTryLoc() const
Definition: StmtCXX.h:91
OpenMPDirectiveKind getCancelRegion() const
Get cancellation region for the current cancellation point.
Definition: StmtOpenMP.h:1929
Expr * getLHS() const
Definition: Expr.h:3611
llvm::APInt getValue() const
Definition: Expr.h:1262
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:1940
SourceLocation getMemberLoc() const
Definition: ExprCXX.h:669
SourceLocation getTokenLocation() const
getTokenLocation - The location of the __null token.
Definition: Expr.h:3655
SourceLocation getAsmLoc() const
Definition: Stmt.h:1428
StringRef getAsmString() const
Definition: Stmt.h:1764
Expr ** getSubExprs()
Definition: Expr.h:4896
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:1483
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2132
SourceLocation getDefaultKindKwLoc() const
Returns location of clause kind.
Definition: OpenMPClause.h:478
unsigned getNumObjects() const
Definition: ExprCXX.h:2799
const Expr * getControllingExpr() const
Definition: Expr.h:4496
OMPClauseWriter(ASTStmtWriter *W, ASTWriter::RecordData &Record)
capture_init_iterator capture_init_begin() const
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1512
This represents clause 'aligned' in the '#pragma omp ...' directives.
unsigned getNumExpansions() const
Get the number of parameters in this parameter pack.
Definition: ExprCXX.h:3711
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprObjC.h:165
Expr * getQueriedExpression() const
Definition: ExprCXX.h:2288
NestedNameSpecifierLoc getQualifierLoc() const
Definition: ExprCXX.h:670
Stmt * getHandler() const
Definition: Stmt.h:1940
unsigned getCharacterLiteralAbbrev() const
Definition: ASTWriter.h:828
TypeSourceInfo * getEncodedTypeSourceInfo() const
Definition: ExprObjC.h:379
NamedDecl * getDecl() const
bool isPostfixUpdate() const
Return true if 'v' expression must be updated to original value of 'x', false if 'v' must be updated ...
Definition: StmtOpenMP.h:1746
A field in a dependent type, known only by its name.
Definition: Expr.h:1797
unsigned getSwitchCaseID(SwitchCase *S)
Retrieve the ID for the given switch-case statement.
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on a template...
Definition: Expr.h:192
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
VAArgExpr, used for the builtin function __builtin_va_arg.
Definition: Expr.h:3670
bool HasTemplateKWAndArgsInfo
Whether the name includes info for explicit template keyword and arguments.
Definition: ExprCXX.h:2322
Expr * getCond() const
Definition: Expr.h:3222
FunctionDecl * getOperatorDelete() const
Definition: ExprCXX.h:1710
NamedDecl * getFirstQualifierFoundInScope() const
Retrieve the first part of the nested-name-specifier that was found in the scope of the member access...
Definition: ExprCXX.h:3074
SourceLocation getOpLoc() const
Definition: ExprObjC.h:521
NameKind getNameKind() const
getNameKind - Determine what kind of name this is.
static unsigned getNumSubExprs(AtomicOp Op)
Determine the number of arguments the specified atomic builtin should have.
Definition: Expr.cpp:4331
bool requiresZeroInitialization() const
Whether this construction first requires zero-initialization before the initializer is called...
Definition: ExprCXX.h:1165
This represents implicit clause 'depend' for the '#pragma omp task' directive.
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1248
designators_iterator designators_begin()
Definition: Expr.h:4165
LabelDecl * getDecl() const
Definition: Stmt.h:809
OMPClause * getClause(unsigned i) const
Returns specified clause.
Definition: StmtOpenMP.h:178
SourceLocation getColonLoc() const
Gets location of ':' symbol in clause.
IdentifierInfo * getInputIdentifier(unsigned i) const
Definition: Stmt.h:1668
unsigned getArrayExprIndex() const
For an array element node, returns the index into the array of expressions.
Definition: Expr.h:1849
This represents 'proc_bind' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:496
This represents 'capture' clause in the '#pragma omp atomic' directive.
Definition: OpenMPClause.h:896
SourceLocation getRParenLoc() const
Definition: Expr.h:2047
void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args)
SourceLocation getRParenLoc() const
Definition: Expr.h:4477
helper_expr_const_range assignment_ops() const
NestedNameSpecifierLoc getQualifierLoc() const
Fetches the nested-name qualifier with source-location information, if one was given.
Definition: ExprCXX.h:2416
decls_iterator decls_end() const
Definition: ExprCXX.h:2390
SourceLocation getScheduleKindLoc()
Get kind location.
Definition: OpenMPClause.h:652
bool isListInitialization() const
Whether this constructor call was written as list-initialization.
Definition: ExprCXX.h:1153
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "while" statement, if any.
Definition: Stmt.cpp:985
SourceLocation getLocation() const
Retrieve the location of this expression.
Definition: Expr.h:846
TypeSourceInfo * getTypeSourceInfo() const
getTypeSourceInfo - Return the destination type.
Definition: Expr.h:3531
unsigned NumTemplateArgs
The number of template arguments in TemplateArgs. The actual template arguments (if any) are stored a...
Definition: TemplateBase.h:575
Expr * getCondition() const
Returns condition.
Definition: OpenMPClause.h:243
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1295
unsigned getExprImplicitCastAbbrev() const
Definition: ASTWriter.h:830
SourceLocation getLBraceLoc() const
Definition: Expr.h:3882
SourceLocation getRParenLoc() const
Definition: StmtObjC.h:55
A C++ const_cast expression (C++ [expr.const.cast]).
Definition: ExprCXX.h:340
unsigned getNumExpressions() const
Definition: Expr.h:1954
Field designator where only the field name is known.
Definition: ASTBitCodes.h:1416
Expr * getIterationVariable() const
Definition: StmtOpenMP.h:513
SourceLocation getGotoLoc() const
Definition: Stmt.h:1229
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source location information.
Definition: ExprCXX.h:2662
ObjCMethodDecl * getImplicitPropertyGetter() const
Definition: ExprObjC.h:633
raw_arg_iterator raw_arg_end()
Definition: ExprCXX.h:1788
SourceLocation getLocation() const
Definition: ExprCXX.h:1140
SourceLocation getEqualOrColonLoc() const
Retrieve the location of the '=' that precedes the initializer value itself, if present.
Definition: Expr.h:4216
Stmt * getBody()
Definition: Stmt.h:1069
Expr * getRHS()
Definition: Stmt.h:718
ConstructionKind getConstructionKind() const
Determine whether this constructor is actually constructing a base class (rather than a complete obje...
Definition: ExprCXX.h:1172
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:262
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:396
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:1357
A CXXStdInitializerListExpr record.
Definition: ASTBitCodes.h:1323
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3473
An ArraySubscriptExpr record.
Definition: ASTBitCodes.h:1193
void AddString(StringRef Str, RecordDataImpl &Record)
Add a string to the given record.
Definition: ASTWriter.cpp:3960
This represents 'ordered' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:691
Selector getSelector() const
Definition: ExprObjC.h:408
A PseudoObjectExpr record.
Definition: ASTBitCodes.h:1241
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:180
NonTypeTemplateParmDecl * getParameterPack() const
Retrieve the non-type template parameter pack being substituted.
Definition: ExprCXX.h:3639
SourceRange getAngleBrackets() const LLVM_READONLY
Definition: ExprCXX.h:219
SourceLocation getEndLoc() const
Definition: Stmt.h:476
const SwitchCase * getSwitchCaseList() const
Definition: Stmt.h:987
void AddCXXBaseSpecifier(const CXXBaseSpecifier &Base, RecordDataImpl &Record)
Emit a C++ base specifier.
Definition: ASTWriter.cpp:5380
SourceLocation getQuestionLoc() const
Definition: Expr.h:3177
SourceLocation getLocation() const
Definition: ExprObjC.h:684
Expr * getSubExpr() const
Definition: Expr.h:1699
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:701
An ObjCIndirectCopyRestoreExpr record.
Definition: ASTBitCodes.h:1274
SourceLocation getLabelLoc() const
Definition: Stmt.h:1231
Expr * getElement(unsigned Index)
getExpr - Return the Expr at the specified index.
Definition: ExprObjC.h:183
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:187
Optional< unsigned > NumExpansions
The number of elements this pack expansion will expand to, if this is a pack expansion and is known...
Definition: ExprObjC.h:219
Stmt * getTemporary() const
Definition: ExprCXX.h:3780
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:3849
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:3528
Expr * getIsLastIterVariable() const
Definition: StmtOpenMP.h:541
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:858
unsigned getNumComponents() const
Definition: Expr.h:1935
A DesignatedInitUpdateExpr record.
Definition: ASTBitCodes.h:1217
Expr * getInputExpr(unsigned i)
Definition: Stmt.cpp:671
Expr * getOutputExpr(unsigned i)
Definition: Stmt.cpp:667
Expr * getCond() const
Definition: Expr.h:3609
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:621
Expr * getNextUpperBound() const
Definition: StmtOpenMP.h:577
DeclarationName getDeclName() const
Definition: Decl.h:189
TemplateArgumentLoc * getTemplateArgs()
Retrieve the template arguments.
Definition: TemplateBase.h:584
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:3558
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:1943
This represents 'collapse' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:374
SourceLocation getKeywordLoc() const
Retrieve the location of the __if_exists or __if_not_exists keyword.
Definition: StmtCXX.h:256
This represents clause 'firstprivate' in the '#pragma omp ...' directives.
ValueDecl * getDecl()
Definition: Expr.h:994
QualType getComputationLHSType() const
Definition: Expr.h:3133
SourceLocation getProcBindKindKwLoc() const
Returns location of clause kind.
Definition: OpenMPClause.h:549
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprCXX.h:738
unsigned getNumClauses() const
Get number of clauses.
Definition: StmtOpenMP.h:172
NestedNameSpecifierLoc getQualifierLoc() const
Gets the nested name specifier.
NestedNameSpecifierLoc getQualifierLoc() const
If the name was qualified, retrieves the nested-name-specifier that precedes the name, with source-location information.
Definition: Expr.h:1022
AtomicOp getOp() const
Definition: Expr.h:4893
SourceLocation getLParenLoc() const
Definition: Expr.h:2624
SourceLocation getSemiLoc() const
Definition: Stmt.h:535
APFloatSemantics getRawSemantics() const
Definition: Expr.h:1387
SourceLocation getAtLoc() const
Definition: StmtObjC.h:363
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:1534
An ObjCForCollectionStmt record.
Definition: ASTBitCodes.h:1277
helper_expr_const_range destination_exprs() const
SourceLocation getParameterPackLocation() const
Retrieve the location of the parameter pack name.
Definition: ExprCXX.h:3642
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression, including the actual initialized value and any expressions that occur within array and array-range designators.
Definition: Expr.h:4237
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:1169
InitListExpr * getUpdater() const
Definition: Expr.h:4332
This represents 'seq_cst' clause in the '#pragma omp atomic' directive.
Definition: OpenMPClause.h:926
SourceLocation getRightLoc() const
Definition: ExprObjC.h:1307
This represents 'untied' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:749
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:294
SourceLocation getLocStart() const
Returns starting location of directive kind.
Definition: StmtOpenMP.h:156
QualType getComputationResultType() const
Definition: Expr.h:3136
A MS-style AsmStmt record.
Definition: ASTBitCodes.h:1167
unsigned getNumSubExprs() const
Definition: Expr.h:3473
LabelDecl * getLabel() const
Definition: Stmt.h:1226
void AddSourceLocation(SourceLocation Loc, RecordDataImpl &Record)
Emit a source location.
Definition: ASTWriter.cpp:4732
decls_iterator decls_begin() const
Definition: ExprCXX.h:2389
Expr * getBase() const
Definition: ExprObjC.h:1395
SourceLocation getOperatorLoc() const
Definition: Expr.h:2044
Expr * getArgument()
Definition: ExprCXX.h:1866
SourceLocation getLParenLoc()
Get location of '('.
Definition: OpenMPClause.h:649
bool isArray() const
Definition: ExprCXX.h:1713
bool isArrayForm() const
Definition: ExprCXX.h:1853
SourceLocation getAtLoc() const
Definition: ExprObjC.h:411
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:269
SourceLocation getGotoLoc() const
Definition: Stmt.h:1262
const StringLiteral * getAsmString() const
Definition: Stmt.h:1577
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2305
This captures a statement into a function. For example, the following pragma annotated compound state...
Definition: Stmt.h:1989
Token * getAsmToks()
Definition: Stmt.h:1761
bool getValue() const
Definition: ExprObjC.h:71
SourceLocation getRBracket() const
Definition: ExprObjC.h:797
Expr * getNumForLoops() const
Return the number of associated for-loops.
Definition: OpenMPClause.h:409
unsigned getResultExprIndex() const
Definition: Expr.h:4761
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:934
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
SourceLocation getLeaveLoc() const
Definition: Stmt.h:1966
body_range body()
Definition: Stmt.h:585
helper_expr_const_range reduction_ops() const
Expr * getSourceExpr() const
Definition: Expr.h:869
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:1911
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
private_copies_range private_copies()
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies this name, if any.
Definition: StmtCXX.h:266
NonTypeTemplateParmDecl * getParameter() const
Definition: ExprCXX.h:3591
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:1623
SourceLocation getOperatorLoc() const
Retrieve the location of the '.' or '->' operator.
Definition: ExprCXX.h:2007
Expr * getLHS()
Definition: Stmt.h:717
Expr * getLowerBoundVariable() const
Definition: StmtOpenMP.h:547
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Definition: ExprCXX.h:372
Expr * getCondition() const
Returns condition.
Definition: OpenMPClause.h:190
helper_expr_const_range lhs_exprs() const
This represents 'schedule' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:566
Expr * getExpr()
Get 'expr' part of the associated expression/statement.
Definition: StmtOpenMP.h:1753
unsigned getCollapsedNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:511
SourceLocation getKeywordLoc() const
Definition: Stmt.h:673
SourceRange getSourceRange() const LLVM_READONLY
Definition: ExprObjC.h:334
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1158
SourceLocation getRParenLoc() const
Definition: ExprCXX.h:1608
bool isFreeIvar() const
Definition: ExprObjC.h:509
CompoundStmt * getBlock() const
Definition: Stmt.h:1859
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
Definition: Expr.h:2533
This represents clause 'shared' in the '#pragma omp ...' directives.
const Expr * getCond() const
Definition: Stmt.h:985
TemplateArgument getArgumentPack() const
Retrieve the template argument pack containing the substituted template arguments.
Definition: ExprCXX.cpp:1441
SourceLocation getIdentLoc() const
Definition: Stmt.h:808
A CXXFunctionalCastExpr record.
Definition: ASTBitCodes.h:1319
Expr * getSrcExpr() const
getSrcExpr - Return the Expr to be converted.
Definition: Expr.h:4665
SourceLocation getTryLoc() const
Definition: Stmt.h:1931
TypeSourceInfo * getClassReceiverTypeInfo() const
Returns a type-source information of a class message send, or NULL if the message is not a class mess...
Definition: ExprObjC.h:1180
An ObjCEncodeExpr record.
Definition: ASTBitCodes.h:1256
SourceLocation getGenericLoc() const
Definition: Expr.h:4475
SourceLocation getAtLoc() const
Definition: ExprObjC.h:454
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:1439
bool isImplicitAccess() const
True if this is an implicit access, i.e. one in which the member being accessed was not written in th...
Definition: ExprCXX.cpp:1303
SourceLocation getStrTokenLoc(unsigned TokNum) const
Definition: Expr.h:1583
This is a basic class for representing single OpenMP clause.
Definition: OpenMPClause.h:32
bool getValue() const
Definition: ExprCXX.h:2290
unsigned getIntegerLiteralAbbrev() const
Definition: ASTWriter.h:829
SourceLocation getContinueLoc() const
Definition: Stmt.h:1299
QualType getBaseType() const
Definition: ExprCXX.h:3043
StringLiteral * getFunctionName()
Definition: Expr.cpp:449
SourceLocation getOperatorLoc() const
Retrieve the location of the cast operator keyword, e.g., static_cast.
Definition: ExprCXX.h:212
An ObjCIsa Expr record.
Definition: ASTBitCodes.h:1272
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "switch" statement, if any.
Definition: Stmt.cpp:951
capture_iterator capture_end() const
Retrieve an iterator pointing past the end of the sequence of captures.
Definition: Stmt.h:2156
Stmt * getCapturedStmt()
Retrieve the statement being captured.
Definition: Stmt.h:2098
ParmVarDecl * getParameterPack() const
Get the parameter pack which this expression refers to.
Definition: ExprCXX.h:3699
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:1771
Expr * getInputExpr(unsigned i)
Definition: Stmt.cpp:406
SourceLocation getBegin() const
bool isTypeDependent() const
Definition: Expr.h:166
Expr * getUpperBoundVariable() const
Definition: StmtOpenMP.h:553
SourceLocation getDependencyLoc() const
Get dependency type location.
bool isAllEnumCasesCovered() const
Definition: Stmt.h:1018
Expr * getV()
Get 'v' part of the associated expression/statement.
Definition: StmtOpenMP.h:1748
void AddDeclRef(const Decl *D, RecordDataImpl &Record)
Emit a reference to a declaration.
Definition: ASTWriter.cpp:4945
bool isArrow() const
Determine whether this member expression used the '->' operator; otherwise, it used the '...
Definition: ExprCXX.h:3285
StringRef getOutputConstraint(unsigned i) const
Definition: Stmt.h:1771
Expr * getSubExpr()
Definition: ExprObjC.h:106
An expression trait intrinsic.
Definition: ExprCXX.h:2252
StringRef getClobber(unsigned i) const
Definition: Stmt.h:1809
An AtomicExpr record.
Definition: ASTBitCodes.h:1243
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:579
SourceLocation getAtSynchronizedLoc() const
Definition: StmtObjC.h:279
uint64_t getValue() const
Definition: ExprCXX.h:2231
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.h:1589
const Expr * getBase() const
Definition: Expr.h:4561
Expr * getArrayFiller()
If this initializer list initializes an array with more elements than there are initializers in the l...
Definition: Expr.h:3840
const BlockDecl * getBlockDecl() const
Definition: Expr.h:4616
bool isObjectReceiver() const
Definition: ExprObjC.h:694
iterator end() const
Definition: ExprCXX.h:3708
SourceLocation getForLoc() const
Definition: StmtCXX.h:185
SourceLocation getRParenLoc() const
Definition: Expr.h:3619
Opcode getOpcode() const
Definition: Expr.h:1696
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name...
Definition: StmtCXX.h:234
const OffsetOfNode & getComponent(unsigned Idx) const
Definition: Expr.h:1925
Expr * getPreCond() const
Definition: StmtOpenMP.h:525
SourceLocation getExprLoc() const LLVM_READONLY
Definition: Expr.cpp:193
SourceLocation getNameLoc() const
Definition: ExprCXX.h:3585
void VisitStmt(Stmt *S)
SourceLocation getOperatorLoc() const
getOperatorLoc - Return the location of the operator.
Definition: Expr.h:1703
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:2609
Expr * Value
The value of the dictionary element.
Definition: ExprObjC.h:212
SourceLocation getRBracketLoc() const
Definition: Expr.h:2128
Represents a C11 generic selection.
Definition: Expr.h:4446
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1152
bool isArrow() const
Definition: Expr.h:2548
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3357
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
Definition: ExprObjC.h:1506
QualType getType() const
Definition: Expr.h:125
SourceLocation getEllipsisLoc() const
Retrieve the location of the ellipsis that describes this pack expansion.
Definition: ExprCXX.h:3428
Represents a reference to a function parameter pack that has been substituted but not yet expanded...
Definition: ExprCXX.h:3673
void AddDeclarationNameLoc(const DeclarationNameLoc &DNLoc, DeclarationName Name, RecordDataImpl &Record)
Definition: ASTWriter.cpp:5090
SourceLocation getLocation() const
Definition: Expr.h:1341
arg_iterator arg_end()
Definition: ExprObjC.h:1354
VarDecl * getConditionVariable() const
Retrieve the variable declared in this "if" statement, if any.
Definition: Stmt.cpp:894
Expr * getCommon() const
getCommon - Return the common expression, written to the left of the condition. The opaque value will...
Definition: Expr.h:3298
const Expr * getSubExpr() const
Definition: ExprCXX.h:828
bool isImplicitProperty() const
Definition: ExprObjC.h:625
void writeClause(OMPClause *C)
SourceLocation getLParenLoc() const
Definition: Expr.h:2884
const Expr * getAssocExpr(unsigned i) const
Definition: Expr.h:4479
helper_expr_const_range rhs_exprs() const
An InitListExpr record.
Definition: ASTBitCodes.h:1213
const Expr * getExpr() const
Definition: ExprCXX.h:911
bool hadMultipleCandidates() const
Returns true if this expression refers to a function that was resolved from an overloaded set having ...
Definition: Expr.h:1146
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1174
unsigned getByteLength() const
Definition: Expr.h:1553
A CXXBoolLiteralExpr record.
Definition: ASTBitCodes.h:1325
Represents a delete expression for memory deallocation and destructor calls, e.g. "delete[] pArray"...
Definition: ExprCXX.h:1819
SourceLocation getStarLoc() const
Definition: Stmt.h:1264
TypeSourceInfo * getTypeOperandSourceInfo() const
Retrieve source information for the type operand.
Definition: ExprCXX.h:714
SourceLocation getOpLoc() const
Definition: ExprObjC.h:1405
const Stmt * getBody() const
Definition: Stmt.h:986
An ExtVectorElementExpr record.
Definition: ASTBitCodes.h:1211
NestedNameSpecifierLoc getQualifierLoc() const
Retrieves the nested-name-specifier that qualifies the type name, with source-location information...
Definition: ExprCXX.h:1993
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:885
bool isThrownVariableInScope() const
Determines whether the variable thrown by this expression (if any!) is within the innermost try block...
Definition: ExprCXX.h:838
NestedNameSpecifierLoc getQualifierLoc() const
If the member name was qualified, retrieves the nested-name-specifier that precedes the member name...
Definition: Expr.h:2440
SourceLocation getLParenLoc() const
Definition: ExprCXX.h:1267
SourceLocation EllipsisLoc
The location of the ellipsis, if this is a pack expansion.
Definition: ExprObjC.h:215
designators_iterator designators_end()
Definition: Expr.h:4166
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:306
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:636
SourceLocation getTildeLoc() const
Retrieve the location of the '~'.
Definition: ExprCXX.h:2025
An ObjCAutoreleasePoolStmt record.
Definition: ASTBitCodes.h:1289
const Expr * getSynchExpr() const
Definition: StmtObjC.h:290
unsigned getNumHandlers() const
Definition: StmtCXX.h:103
Kind getKind() const
Determine what kind of offsetof node this is.
Definition: Expr.h:1843
const StringLiteral * getOutputConstraintLiteral(unsigned i) const
Definition: Stmt.h:1653
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3392
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:1721
A CXXDynamicCastExpr record.
Definition: ASTBitCodes.h:1313
StringRef getBytes() const
Definition: Expr.h:1529
SourceLocation getWhileLoc() const
Definition: Stmt.h:1120
This represents clause 'linear' in the '#pragma omp ...' directives.
DeclarationNameInfo getDirectiveName() const
Return name of the directive.
Definition: StmtOpenMP.h:1086
StringKind getKind() const
Definition: Expr.h:1561
SourceLocation LAngleLoc
The source location of the left angle bracket ('<').
Definition: TemplateBase.h:566
bool isTypeOperand() const
Definition: ExprCXX.h:707
ObjCMethodDecl * getArrayWithObjectsMethod() const
Definition: ExprObjC.h:192
Expr * getEnsureUpperBound() const
Definition: StmtOpenMP.h:565
Expr * getUpdateExpr()
Get helper expression of the form 'OpaqueValueExpr(x) binop OpaqueValueExpr(expr)' or 'OpaqueValueExp...
Definition: StmtOpenMP.h:1734
bool usesGNUSyntax() const
Determines whether this designated initializer used the deprecated GNU syntax for designated initiali...
Definition: Expr.h:4221
semantics_iterator semantics_begin()
Definition: Expr.h:4780
const Expr * getRetValue() const
Definition: Stmt.cpp:1013
unsigned getNumArgs() const
Definition: Expr.h:2205
SourceLocation getLocation() const
Definition: ExprCXX.h:786
unsigned getNumArgs() const
Definition: ExprCXX.h:1198
unsigned getNumConcatenated() const
Definition: Expr.h:1581
This represents '#pragma omp atomic' directive.
Definition: StmtOpenMP.h:1637
SourceLocation getParameterPackLocation() const
Get the location of the parameter pack.
Definition: ExprCXX.h:3702
Expr * getBaseExpr() const
Definition: ExprObjC.h:809
CXXRecordDecl * getNamingClass() const
Definition: ExprCXX.h:2575
An ObjCAtFinallyStmt record.
Definition: ASTBitCodes.h:1281
Expr * getCalcLastIteration() const
Definition: StmtOpenMP.h:521
ObjCMethodDecl * getDictWithObjectsMethod() const
Definition: ExprObjC.h:329
llvm::APFloat getValue() const
Definition: Expr.h:1377
FieldDecl * getField() const
For a field offsetof node, returns the field.
Definition: Expr.h:1855
const Stmt * getThen() const
Definition: Stmt.h:916
ArrayRef< Expr * > counters()
Definition: StmtOpenMP.h:594
path_iterator path_end()
Definition: Expr.h:2730
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3337
SourceLocation getMemberLoc() const
Definition: Expr.h:2553
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier, e.g., N::foo.
Definition: Expr.h:1009
SourceLocation getAtCatchLoc() const
Definition: StmtObjC.h:102
SourceLocation getRParenLoc() const
getRParenLoc - Return the location of final right parenthesis.
Definition: Expr.h:4671
arg_iterator arg_begin()
Definition: ExprObjC.h:1353
SourceLocation getRParenLoc() const
Definition: StmtObjC.h:104
Expr * getSafelen() const
Return safe iteration space distance.
Definition: OpenMPClause.h:353
SourceLocation getLeftLoc() const
Definition: ExprObjC.h:1306
Expr * getRHS() const
Definition: Expr.h:3613
Expr * getBase() const
Retrieve the base object of this member expressions, e.g., the x in x.m.
Definition: ExprCXX.h:3038
SourceLocation getOperatorLoc() const
Retrieve the location of the '->' or '.' operator.
Definition: ExprCXX.h:3050
FunctionDecl * getOperatorNew() const
Definition: ExprCXX.h:1708
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2066
DeclStmt * getBeginEndStmt()
Definition: StmtCXX.h:151
const Stmt * getSubStmt() const
Definition: StmtObjC.h:356
Represents Objective-C's collection statement.
Definition: StmtObjC.h:24
OpaqueValueExpr * getOpaqueValue() const
getOpaqueValue - Return the opaque value placeholder.
Definition: Expr.h:3301
An ObjCAtSynchronizedStmt record.
Definition: ASTBitCodes.h:1285
SourceLocation getBridgeKeywordLoc() const
The location of the bridge keyword.
Definition: ExprObjC.h:1537
arg_iterator arg_begin()
Definition: Expr.h:2246
ArrayRef< Expr * > inits()
Definition: StmtOpenMP.h:600
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:472
SourceLocation getBuiltinLoc() const
Definition: Expr.h:3616
SourceLocation getAtTryLoc() const
Retrieve the location of the @ in the @try.
Definition: StmtObjC.h:193
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:406
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:155
TypeSourceInfo * getWrittenTypeInfo() const
Definition: Expr.h:3694
A CXXMemberCallExpr record.
Definition: ASTBitCodes.h:1305
Expr * getArg(unsigned Arg)
Return the specified argument.
Definition: ExprCXX.h:1201
CXXConstructorDecl * getConstructor() const
Definition: ExprCXX.h:1137
Expr * getExprOperand() const
Definition: ExprCXX.h:724
bool isVolatile() const
Definition: Stmt.h:1434
Represents Objective-C's @finally statement.
Definition: StmtObjC.h:120
const Expr * getSubExpr() const
Definition: Expr.h:1442
SourceLocation getRParenLoc() const
Retrieve the location of the right parentheses (')') that follows the argument list.
Definition: ExprCXX.h:2896
QualType getSuperReceiverType() const
Definition: ExprObjC.h:687
SourceLocation getRParenLoc() const
Definition: ExprCXX.h:1269
SourceLocation getBuiltinLoc() const
getBuiltinLoc - Return the location of the __builtin_convertvector token.
Definition: Expr.h:3539
Expr * getKeyExpr() const
Definition: ExprObjC.h:812
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver. ...
Definition: ExprObjC.h:1274
LabelDecl * getLabel() const
Definition: Expr.h:3379
SourceLocation getAccessorLoc() const
Definition: Expr.h:4568
An index into an array.
Definition: Expr.h:1793
Represents a base class of a C++ class.
Definition: DeclCXX.h:157
This represents 'write' clause in the '#pragma omp atomic' directive.
Definition: OpenMPClause.h:836
ObjCPropertyDecl * getExplicitProperty() const
Definition: ExprObjC.h:628
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:203
const Expr * getInitializer() const
Definition: Expr.h:2617
SourceRange getDirectInitRange() const
Definition: ExprCXX.h:1799
SourceLocation getRParenLoc() const
Definition: Expr.h:2887
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:474
SourceLocation getForLoc() const
Definition: Stmt.h:1191
SourceLocation getLocation() const
Definition: ExprCXX.h:480
DeclStmt * getRangeStmt()
Definition: StmtCXX.h:150
A ConvertVectorExpr record.
Definition: ASTBitCodes.h:1235
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:181
Expr * getFalseExpr() const
getFalseExpr - Return the subexpression which will be evaluated if the condnition evaluates to false;...
Definition: Expr.h:3317
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:2848
ArrayRef< const Attr * > getAttrs() const
Definition: Stmt.h:863
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:952
Expr * getTarget()
Definition: Stmt.h:1266
Expr * getBase() const
Definition: Expr.h:2405
SourceLocation getColonLoc() const
Definition: Stmt.h:675
SourceLocation getAttrLoc() const
Definition: Stmt.h:862
SourceLocation getLParenLoc() const
Returns the location of '('.
Definition: OpenMPClause.h:350
Expr * getCond()
Definition: Stmt.h:1111
helper_expr_const_range destination_exprs() const
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:1681
ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
bool isArrayFormAsWritten() const
Definition: ExprCXX.h:1854
GNU array range designator.
Definition: ASTBitCodes.h:1423
OverloadedOperatorKind getOperator() const
Returns the kind of overloaded operator that this expression refers to.
Definition: ExprCXX.h:80
Expr * getNextLowerBound() const
Definition: StmtOpenMP.h:571
SourceLocation getFinallyLoc() const
Definition: Stmt.h:1892
const Expr * getSubExpr() const
Definition: Expr.h:1638
void AddStmt(Stmt *S)
Add the given statement or expression to the queue of statements to emit.
Definition: ASTWriter.h:779
A GCC-style AsmStmt record.
Definition: ASTBitCodes.h:1165
SourceLocation getBuiltinLoc() const
Definition: Expr.h:4909
SourceLocation getRParenLoc() const
Retrieve the location of the closing parenthesis.
Definition: ExprCXX.h:215
This represents 'nowait' clause in the '#pragma omp ...' directive.
Definition: OpenMPClause.h:720
void FlushStmts()
Flush all of the statements and expressions that have been added to the queue via AddStmt()...
SourceLocation getRParenLoc() const
Definition: Stmt.h:1195
bool isGlobalNew() const
Definition: ExprCXX.h:1738
Opcode getOpcode() const
Definition: Expr.h:2961
SourceLocation getBreakLoc() const
Definition: Stmt.h:1327
SourceLocation getBuiltinLoc() const
Definition: Expr.h:3457
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
Definition: ExprCXX.h:1241
bool hasQualifier() const
Determines whether this member expression actually had a C++ nested-name-specifier prior to the name ...
Definition: Expr.h:2425
An ObjCAtCatchStmt record.
Definition: ASTBitCodes.h:1279
bool doesUsualArrayDeleteWantSize() const
Definition: ExprCXX.h:1766
Field designator where the field has been resolved to a declaration.
Definition: ASTBitCodes.h:1419
const Expr * getCond() const
Definition: Stmt.h:914
CapturedRegionKind getCapturedRegionKind() const
Retrieve the captured region kind.
Definition: Stmt.h:2116
SourceLocation getElseLoc() const
Definition: Stmt.h:927
TypeSourceInfo * getQueriedTypeSourceInfo() const
Definition: ExprCXX.h:2229
helper_expr_const_range assignment_ops() const
CompoundStmt * getTryBlock()
Definition: StmtCXX.h:96
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:82
The receiver is a class.
Definition: ExprObjC.h:1000
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:154
bool isSimple() const
Definition: Stmt.h:1431
const Expr * getThrowExpr() const
Definition: StmtObjC.h:325
bool hasTemplateKWAndArgsInfo() const
Definition: Expr.h:1044
SourceLocation getLocation() const
Definition: ExprObjC.h:77
SourceLocation getTemplateKeywordLoc() const
Get the source location of the template keyword.
Definition: TemplateBase.h:618
Expr * getRHS() const
Definition: Expr.h:2966
bool isExact() const
Definition: Expr.h:1403
Expr * getPattern()
Retrieve the pattern of the pack expansion.
Definition: ExprCXX.h:3421
Expr * getHelperChunkSize()
Get helper chunk size.
Definition: OpenMPClause.h:666
bool isIfExists() const
Determine whether this is an __if_exists statement.
Definition: StmtCXX.h:259
SourceLocation getRBracLoc() const
Definition: Stmt.h:634
SourceLocation getColonLoc() const
Definition: StmtCXX.h:187
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:187
bool isStdInitListInitialization() const
Whether this constructor call was written as list-initialization, but was interpreted as forming a st...
Definition: ExprCXX.h:1160
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:830
Expr * getBase() const
Definition: Expr.h:4329
const Stmt * getTryBody() const
Retrieve the @try body.
Definition: StmtObjC.h:197
VarDecl * getExceptionDecl() const
Definition: StmtCXX.h:50
capture_range captures()
Definition: Stmt.h:2143
A reference to a declared variable, function, enum, etc. [C99 6.5.1p2].
Definition: Expr.h:899
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:404
Expr * getLastIteration() const
Definition: StmtOpenMP.h:517
Expr * getChunkSize()
Get chunk size.
Definition: OpenMPClause.h:658
const Expr * getInit(unsigned Init) const
Definition: Expr.h:3794
const Expr * getSubExpr() const
Definition: ExprCXX.h:1056
FieldDecl * getInitializedFieldInUnion()
If this initializes a union, specifies which field in the union to initialize.
Definition: Expr.h:3858
TypeSourceInfo * getAllocatedTypeSourceInfo() const
Definition: ExprCXX.h:1687
Stmt * getSubStmt()
Definition: Stmt.h:812
DeclStmt * getLoopVarStmt()
Definition: StmtCXX.h:156
unsigned getNumClobbers() const
Definition: Stmt.h:1479
Expr * getTrueExpr() const
getTrueExpr - Return the subexpression which will be evaluated if the condition evaluates to true; th...
Definition: Expr.h:3310
SourceLocation getRParenLoc() const
Definition: StmtCXX.h:189
A trivial tuple used to represent a source range.
helper_expr_const_range destination_exprs() const
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:1351
SourceLocation getRParenLoc() const
Definition: Expr.h:4910
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:434
CompoundStmt * getTryBlock() const
Definition: Stmt.h:1936
This represents '#pragma omp parallel sections' directive.
Definition: StmtOpenMP.h:1237
SourceRange getSourceRange() const LLVM_READONLY
Retrieve the source range that covers this offsetof node.
Definition: Expr.h:1876
bool isArrow() const
Definition: ExprCXX.h:668
SourceLocation getStartLoc() const
Definition: Stmt.h:474
const CallExpr * getConfig() const
Definition: ExprCXX.h:170
SourceLocation getLocation() const
Definition: Expr.h:1411
SourceLocation getLocEnd() const
Returns ending location of directive.
Definition: StmtOpenMP.h:158
bool isTypeOperand() const
Definition: ExprCXX.h:572
Expr * getInit() const
Definition: StmtOpenMP.h:533
The receiver is a superclass.
Definition: ExprObjC.h:1004
Stmt * getAssociatedStmt() const
Returns statement associated with the directive.
Definition: StmtOpenMP.h:184
SourceLocation getExceptLoc() const
Definition: Stmt.h:1852
SourceLocation getCatchLoc() const
Definition: StmtCXX.h:49
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1133
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:3047
unsigned varlist_size() const
Definition: OpenMPClause.h:116
StmtCode
Record codes for each kind of statement or expression.
Definition: ASTBitCodes.h:1120
This class handles loading and caching of source files into memory.
Stmt * getSubStmt()
Definition: Stmt.h:866
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:4352
ObjCMethodDecl * getImplicitPropertySetter() const
Definition: ExprObjC.h:638
unsigned getNumElements() const
Definition: ExprObjC.h:314
A GenericSelectionExpr record.
Definition: ASTBitCodes.h:1239
SourceLocation getRParenLoc() const
Definition: ExprObjC.h:374
SourceLocation getRParenLoc() const
Definition: Expr.h:3460
helper_expr_const_range assignment_ops() const
SourceLocation getColonLoc() const
Definition: Expr.h:3178
Expr * getStrideVariable() const
Definition: StmtOpenMP.h:559
bool isArrow() const
Definition: ExprObjC.h:508
void AddAPFloat(const llvm::APFloat &Value, RecordDataImpl &Record)
Emit a floating-point value.
Definition: ASTWriter.cpp:4752
DeclAccessPair getFoundDecl() const
Retrieves the declaration found by lookup.
Definition: Expr.h:2415
bool hasUnresolvedUsing() const
Determine whether the lookup results contain an unresolved using declaration.
Definition: ExprCXX.h:3281
TypeSourceInfo * getArgumentTypeInfo() const
Definition: Expr.h:2017
helper_expr_const_range source_exprs() const
Stmt * getSubStmt()
Definition: Stmt.h:719