clang  10.0.0svn
ASTReaderStmt.cpp
Go to the documentation of this file.
1 //===- ASTReaderStmt.cpp - Stmt/Expr Deserialization ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Statement/expression deserialization. This implements the
10 // ASTReader::ReadStmt method.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/AttrIterator.h"
17 #include "clang/AST/Decl.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclGroup.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/ExprObjC.h"
27 #include "clang/AST/ExprOpenMP.h"
29 #include "clang/AST/OpenMPClause.h"
31 #include "clang/AST/Stmt.h"
32 #include "clang/AST/StmtCXX.h"
33 #include "clang/AST/StmtObjC.h"
34 #include "clang/AST/StmtOpenMP.h"
35 #include "clang/AST/StmtVisitor.h"
36 #include "clang/AST/TemplateBase.h"
37 #include "clang/AST/Type.h"
41 #include "clang/Basic/LLVM.h"
42 #include "clang/Basic/Lambda.h"
47 #include "clang/Basic/Specifiers.h"
48 #include "clang/Basic/TypeTraits.h"
49 #include "clang/Lex/Token.h"
51 #include "llvm/ADT/DenseMap.h"
52 #include "llvm/ADT/SmallString.h"
53 #include "llvm/ADT/SmallVector.h"
54 #include "llvm/ADT/StringRef.h"
55 #include "llvm/Bitstream/BitstreamReader.h"
56 #include "llvm/Support/Casting.h"
57 #include "llvm/Support/ErrorHandling.h"
58 #include <algorithm>
59 #include <cassert>
60 #include <cstdint>
61 #include <string>
62 
63 using namespace clang;
64 using namespace serialization;
65 
66 namespace clang {
67 
68  class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
69  friend class OMPClauseReader;
70 
71  ASTRecordReader &Record;
72  llvm::BitstreamCursor &DeclsCursor;
73 
74  SourceLocation ReadSourceLocation() {
75  return Record.readSourceLocation();
76  }
77 
78  SourceRange ReadSourceRange() {
79  return Record.readSourceRange();
80  }
81 
82  std::string ReadString() {
83  return Record.readString();
84  }
85 
86  TypeSourceInfo *GetTypeSourceInfo() {
87  return Record.getTypeSourceInfo();
88  }
89 
90  Decl *ReadDecl() {
91  return Record.readDecl();
92  }
93 
94  template<typename T>
95  T *ReadDeclAs() {
96  return Record.readDeclAs<T>();
97  }
98 
99  void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc,
100  DeclarationName Name) {
101  Record.readDeclarationNameLoc(DNLoc, Name);
102  }
103 
104  void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo) {
105  Record.readDeclarationNameInfo(NameInfo);
106  }
107 
108  public:
109  ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
110  : Record(Record), DeclsCursor(Cursor) {}
111 
112  /// The number of record fields required for the Stmt class
113  /// itself.
114  static const unsigned NumStmtFields = 1;
115 
116  /// The number of record fields required for the Expr class
117  /// itself.
118  static const unsigned NumExprFields = NumStmtFields + 7;
119 
120  /// Read and initialize a ExplicitTemplateArgumentList structure.
121  void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
122  TemplateArgumentLoc *ArgsLocArray,
123  unsigned NumTemplateArgs);
124 
125  /// Read and initialize a ExplicitTemplateArgumentList structure.
126  void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
127  unsigned NumTemplateArgs);
128 
129  void VisitStmt(Stmt *S);
130 #define STMT(Type, Base) \
131  void Visit##Type(Type *);
132 #include "clang/AST/StmtNodes.inc"
133  };
134 
135 } // namespace clang
136 
138  TemplateArgumentLoc *ArgsLocArray,
139  unsigned NumTemplateArgs) {
140  SourceLocation TemplateKWLoc = ReadSourceLocation();
141  TemplateArgumentListInfo ArgInfo;
142  ArgInfo.setLAngleLoc(ReadSourceLocation());
143  ArgInfo.setRAngleLoc(ReadSourceLocation());
144  for (unsigned i = 0; i != NumTemplateArgs; ++i)
145  ArgInfo.addArgument(Record.readTemplateArgumentLoc());
146  Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
147 }
148 
150  S->setIsOMPStructuredBlock(Record.readInt());
151  assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
152 }
153 
154 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
155  VisitStmt(S);
156  S->setSemiLoc(ReadSourceLocation());
157  S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
158 }
159 
160 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
161  VisitStmt(S);
163  unsigned NumStmts = Record.readInt();
164  while (NumStmts--)
165  Stmts.push_back(Record.readSubStmt());
166  S->setStmts(Stmts);
167  S->CompoundStmtBits.LBraceLoc = ReadSourceLocation();
168  S->RBraceLoc = ReadSourceLocation();
169 }
170 
171 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
172  VisitStmt(S);
173  Record.recordSwitchCaseID(S, Record.readInt());
174  S->setKeywordLoc(ReadSourceLocation());
175  S->setColonLoc(ReadSourceLocation());
176 }
177 
178 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
179  VisitSwitchCase(S);
180  bool CaseStmtIsGNURange = Record.readInt();
181  S->setLHS(Record.readSubExpr());
182  S->setSubStmt(Record.readSubStmt());
183  if (CaseStmtIsGNURange) {
184  S->setRHS(Record.readSubExpr());
185  S->setEllipsisLoc(ReadSourceLocation());
186  }
187 }
188 
189 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
190  VisitSwitchCase(S);
191  S->setSubStmt(Record.readSubStmt());
192 }
193 
194 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
195  VisitStmt(S);
196  auto *LD = ReadDeclAs<LabelDecl>();
197  LD->setStmt(S);
198  S->setDecl(LD);
199  S->setSubStmt(Record.readSubStmt());
200  S->setIdentLoc(ReadSourceLocation());
201 }
202 
203 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
204  VisitStmt(S);
205  // NumAttrs in AttributedStmt is set when creating an empty
206  // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
207  // to allocate the right amount of space for the trailing Attr *.
208  uint64_t NumAttrs = Record.readInt();
209  AttrVec Attrs;
210  Record.readAttributes(Attrs);
211  (void)NumAttrs;
212  assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
213  assert(NumAttrs == Attrs.size());
214  std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
215  S->SubStmt = Record.readSubStmt();
216  S->AttributedStmtBits.AttrLoc = ReadSourceLocation();
217 }
218 
219 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
220  VisitStmt(S);
221 
222  S->setConstexpr(Record.readInt());
223  bool HasElse = Record.readInt();
224  bool HasVar = Record.readInt();
225  bool HasInit = Record.readInt();
226 
227  S->setCond(Record.readSubExpr());
228  S->setThen(Record.readSubStmt());
229  if (HasElse)
230  S->setElse(Record.readSubStmt());
231  if (HasVar)
232  S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
233  if (HasInit)
234  S->setInit(Record.readSubStmt());
235 
236  S->setIfLoc(ReadSourceLocation());
237  if (HasElse)
238  S->setElseLoc(ReadSourceLocation());
239 }
240 
241 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
242  VisitStmt(S);
243 
244  bool HasInit = Record.readInt();
245  bool HasVar = Record.readInt();
246  bool AllEnumCasesCovered = Record.readInt();
247  if (AllEnumCasesCovered)
249 
250  S->setCond(Record.readSubExpr());
251  S->setBody(Record.readSubStmt());
252  if (HasInit)
253  S->setInit(Record.readSubStmt());
254  if (HasVar)
255  S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
256 
257  S->setSwitchLoc(ReadSourceLocation());
258 
259  SwitchCase *PrevSC = nullptr;
260  for (auto E = Record.size(); Record.getIdx() != E; ) {
261  SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
262  if (PrevSC)
263  PrevSC->setNextSwitchCase(SC);
264  else
265  S->setSwitchCaseList(SC);
266 
267  PrevSC = SC;
268  }
269 }
270 
271 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
272  VisitStmt(S);
273 
274  bool HasVar = Record.readInt();
275 
276  S->setCond(Record.readSubExpr());
277  S->setBody(Record.readSubStmt());
278  if (HasVar)
279  S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
280 
281  S->setWhileLoc(ReadSourceLocation());
282 }
283 
284 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
285  VisitStmt(S);
286  S->setCond(Record.readSubExpr());
287  S->setBody(Record.readSubStmt());
288  S->setDoLoc(ReadSourceLocation());
289  S->setWhileLoc(ReadSourceLocation());
290  S->setRParenLoc(ReadSourceLocation());
291 }
292 
293 void ASTStmtReader::VisitForStmt(ForStmt *S) {
294  VisitStmt(S);
295  S->setInit(Record.readSubStmt());
296  S->setCond(Record.readSubExpr());
297  S->setConditionVariable(Record.getContext(), ReadDeclAs<VarDecl>());
298  S->setInc(Record.readSubExpr());
299  S->setBody(Record.readSubStmt());
300  S->setForLoc(ReadSourceLocation());
301  S->setLParenLoc(ReadSourceLocation());
302  S->setRParenLoc(ReadSourceLocation());
303 }
304 
305 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
306  VisitStmt(S);
307  S->setLabel(ReadDeclAs<LabelDecl>());
308  S->setGotoLoc(ReadSourceLocation());
309  S->setLabelLoc(ReadSourceLocation());
310 }
311 
312 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
313  VisitStmt(S);
314  S->setGotoLoc(ReadSourceLocation());
315  S->setStarLoc(ReadSourceLocation());
316  S->setTarget(Record.readSubExpr());
317 }
318 
319 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
320  VisitStmt(S);
321  S->setContinueLoc(ReadSourceLocation());
322 }
323 
324 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
325  VisitStmt(S);
326  S->setBreakLoc(ReadSourceLocation());
327 }
328 
329 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
330  VisitStmt(S);
331 
332  bool HasNRVOCandidate = Record.readInt();
333 
334  S->setRetValue(Record.readSubExpr());
335  if (HasNRVOCandidate)
336  S->setNRVOCandidate(ReadDeclAs<VarDecl>());
337 
338  S->setReturnLoc(ReadSourceLocation());
339 }
340 
341 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
342  VisitStmt(S);
343  S->setStartLoc(ReadSourceLocation());
344  S->setEndLoc(ReadSourceLocation());
345 
346  if (Record.size() - Record.getIdx() == 1) {
347  // Single declaration
348  S->setDeclGroup(DeclGroupRef(ReadDecl()));
349  } else {
351  int N = Record.size() - Record.getIdx();
352  Decls.reserve(N);
353  for (int I = 0; I < N; ++I)
354  Decls.push_back(ReadDecl());
356  Decls.data(),
357  Decls.size())));
358  }
359 }
360 
361 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
362  VisitStmt(S);
363  S->NumOutputs = Record.readInt();
364  S->NumInputs = Record.readInt();
365  S->NumClobbers = Record.readInt();
366  S->setAsmLoc(ReadSourceLocation());
367  S->setVolatile(Record.readInt());
368  S->setSimple(Record.readInt());
369 }
370 
371 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
372  VisitAsmStmt(S);
373  S->NumLabels = Record.readInt();
374  S->setRParenLoc(ReadSourceLocation());
375  S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
376 
377  unsigned NumOutputs = S->getNumOutputs();
378  unsigned NumInputs = S->getNumInputs();
379  unsigned NumClobbers = S->getNumClobbers();
380  unsigned NumLabels = S->getNumLabels();
381 
382  // Outputs and inputs
386  for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
387  Names.push_back(Record.getIdentifierInfo());
388  Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
389  Exprs.push_back(Record.readSubStmt());
390  }
391 
392  // Constraints
394  for (unsigned I = 0; I != NumClobbers; ++I)
395  Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
396 
397  // Labels
398  for (unsigned I = 0, N = NumLabels; I != N; ++I)
399  Exprs.push_back(Record.readSubStmt());
400 
401  S->setOutputsAndInputsAndClobbers(Record.getContext(),
402  Names.data(), Constraints.data(),
403  Exprs.data(), NumOutputs, NumInputs,
404  NumLabels,
405  Clobbers.data(), NumClobbers);
406 }
407 
408 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
409  VisitAsmStmt(S);
410  S->LBraceLoc = ReadSourceLocation();
411  S->EndLoc = ReadSourceLocation();
412  S->NumAsmToks = Record.readInt();
413  std::string AsmStr = ReadString();
414 
415  // Read the tokens.
416  SmallVector<Token, 16> AsmToks;
417  AsmToks.reserve(S->NumAsmToks);
418  for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
419  AsmToks.push_back(Record.readToken());
420  }
421 
422  // The calls to reserve() for the FooData vectors are mandatory to
423  // prevent dead StringRefs in the Foo vectors.
424 
425  // Read the clobbers.
426  SmallVector<std::string, 16> ClobbersData;
428  ClobbersData.reserve(S->NumClobbers);
429  Clobbers.reserve(S->NumClobbers);
430  for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
431  ClobbersData.push_back(ReadString());
432  Clobbers.push_back(ClobbersData.back());
433  }
434 
435  // Read the operands.
436  unsigned NumOperands = S->NumOutputs + S->NumInputs;
438  SmallVector<std::string, 16> ConstraintsData;
439  SmallVector<StringRef, 16> Constraints;
440  Exprs.reserve(NumOperands);
441  ConstraintsData.reserve(NumOperands);
442  Constraints.reserve(NumOperands);
443  for (unsigned i = 0; i != NumOperands; ++i) {
444  Exprs.push_back(cast<Expr>(Record.readSubStmt()));
445  ConstraintsData.push_back(ReadString());
446  Constraints.push_back(ConstraintsData.back());
447  }
448 
449  S->initialize(Record.getContext(), AsmStr, AsmToks,
450  Constraints, Exprs, Clobbers);
451 }
452 
453 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
454  VisitStmt(S);
455  assert(Record.peekInt() == S->NumParams);
456  Record.skipInts(1);
457  auto *StoredStmts = S->getStoredStmts();
458  for (unsigned i = 0;
459  i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
460  StoredStmts[i] = Record.readSubStmt();
461 }
462 
463 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
464  VisitStmt(S);
465  S->CoreturnLoc = Record.readSourceLocation();
466  for (auto &SubStmt: S->SubStmts)
467  SubStmt = Record.readSubStmt();
468  S->IsImplicit = Record.readInt() != 0;
469 }
470 
471 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
472  VisitExpr(E);
473  E->KeywordLoc = ReadSourceLocation();
474  for (auto &SubExpr: E->SubExprs)
475  SubExpr = Record.readSubStmt();
476  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
477  E->setIsImplicit(Record.readInt() != 0);
478 }
479 
480 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
481  VisitExpr(E);
482  E->KeywordLoc = ReadSourceLocation();
483  for (auto &SubExpr: E->SubExprs)
484  SubExpr = Record.readSubStmt();
485  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
486 }
487 
488 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
489  VisitExpr(E);
490  E->KeywordLoc = ReadSourceLocation();
491  for (auto &SubExpr: E->SubExprs)
492  SubExpr = Record.readSubStmt();
493 }
494 
495 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
496  VisitStmt(S);
497  Record.skipInts(1);
498  S->setCapturedDecl(ReadDeclAs<CapturedDecl>());
499  S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
500  S->setCapturedRecordDecl(ReadDeclAs<RecordDecl>());
501 
502  // Capture inits
504  E = S->capture_init_end();
505  I != E; ++I)
506  *I = Record.readSubExpr();
507 
508  // Body
509  S->setCapturedStmt(Record.readSubStmt());
511 
512  // Captures
513  for (auto &I : S->captures()) {
514  I.VarAndKind.setPointer(ReadDeclAs<VarDecl>());
515  I.VarAndKind.setInt(
516  static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
517  I.Loc = ReadSourceLocation();
518  }
519 }
520 
521 void ASTStmtReader::VisitExpr(Expr *E) {
522  VisitStmt(E);
523  E->setType(Record.readType());
524  E->setTypeDependent(Record.readInt());
525  E->setValueDependent(Record.readInt());
526  E->setInstantiationDependent(Record.readInt());
527  E->ExprBits.ContainsUnexpandedParameterPack = Record.readInt();
528  E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
529  E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
530  assert(Record.getIdx() == NumExprFields &&
531  "Incorrect expression field count");
532 }
533 
534 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
535  VisitExpr(E);
536  E->ConstantExprBits.ResultKind = Record.readInt();
537  switch (E->ConstantExprBits.ResultKind) {
539  E->Int64Result() = Record.readInt();
540  uint64_t tmp = Record.readInt();
541  E->ConstantExprBits.IsUnsigned = tmp & 0x1;
542  E->ConstantExprBits.BitWidth = tmp >> 1;
543  break;
544  }
546  E->APValueResult() = Record.readAPValue();
547  }
548  E->setSubExpr(Record.readSubExpr());
549 }
550 
551 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
552  VisitExpr(E);
553  bool HasFunctionName = Record.readInt();
554  E->PredefinedExprBits.HasFunctionName = HasFunctionName;
555  E->PredefinedExprBits.Kind = Record.readInt();
556  E->setLocation(ReadSourceLocation());
557  if (HasFunctionName)
558  E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
559 }
560 
561 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
562  VisitExpr(E);
563 
564  E->DeclRefExprBits.HasQualifier = Record.readInt();
565  E->DeclRefExprBits.HasFoundDecl = Record.readInt();
566  E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
567  E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
568  E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
569  E->DeclRefExprBits.NonOdrUseReason = Record.readInt();
570  unsigned NumTemplateArgs = 0;
571  if (E->hasTemplateKWAndArgsInfo())
572  NumTemplateArgs = Record.readInt();
573 
574  if (E->hasQualifier())
575  new (E->getTrailingObjects<NestedNameSpecifierLoc>())
577 
578  if (E->hasFoundDecl())
579  *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();
580 
581  if (E->hasTemplateKWAndArgsInfo())
582  ReadTemplateKWAndArgsInfo(
583  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
584  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
585 
586  E->setDecl(ReadDeclAs<ValueDecl>());
587  E->setLocation(ReadSourceLocation());
588  ReadDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());
589 }
590 
591 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
592  VisitExpr(E);
593  E->setLocation(ReadSourceLocation());
594  E->setValue(Record.getContext(), Record.readAPInt());
595 }
596 
597 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
598  VisitExpr(E);
599  E->setLocation(ReadSourceLocation());
600  E->setValue(Record.getContext(), Record.readAPInt());
601 }
602 
603 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
604  VisitExpr(E);
605  E->setRawSemantics(
606  static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
607  E->setExact(Record.readInt());
608  E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
609  E->setLocation(ReadSourceLocation());
610 }
611 
612 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
613  VisitExpr(E);
614  E->setSubExpr(Record.readSubExpr());
615 }
616 
617 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
618  VisitExpr(E);
619 
620  // NumConcatenated, Length and CharByteWidth are set by the empty
621  // ctor since they are needed to allocate storage for the trailing objects.
622  unsigned NumConcatenated = Record.readInt();
623  unsigned Length = Record.readInt();
624  unsigned CharByteWidth = Record.readInt();
625  assert((NumConcatenated == E->getNumConcatenated()) &&
626  "Wrong number of concatenated tokens!");
627  assert((Length == E->getLength()) && "Wrong Length!");
628  assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
629  E->StringLiteralBits.Kind = Record.readInt();
630  E->StringLiteralBits.IsPascal = Record.readInt();
631 
632  // The character width is originally computed via mapCharByteWidth.
633  // Check that the deserialized character width is consistant with the result
634  // of calling mapCharByteWidth.
635  assert((CharByteWidth ==
636  StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
637  E->getKind())) &&
638  "Wrong character width!");
639 
640  // Deserialize the trailing array of SourceLocation.
641  for (unsigned I = 0; I < NumConcatenated; ++I)
642  E->setStrTokenLoc(I, ReadSourceLocation());
643 
644  // Deserialize the trailing array of char holding the string data.
645  char *StrData = E->getStrDataAsChar();
646  for (unsigned I = 0; I < Length * CharByteWidth; ++I)
647  StrData[I] = Record.readInt();
648 }
649 
650 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
651  VisitExpr(E);
652  E->setValue(Record.readInt());
653  E->setLocation(ReadSourceLocation());
654  E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
655 }
656 
657 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
658  VisitExpr(E);
659  E->setLParen(ReadSourceLocation());
660  E->setRParen(ReadSourceLocation());
661  E->setSubExpr(Record.readSubExpr());
662 }
663 
664 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
665  VisitExpr(E);
666  unsigned NumExprs = Record.readInt();
667  assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
668  for (unsigned I = 0; I != NumExprs; ++I)
669  E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
670  E->LParenLoc = ReadSourceLocation();
671  E->RParenLoc = ReadSourceLocation();
672 }
673 
674 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
675  VisitExpr(E);
676  E->setSubExpr(Record.readSubExpr());
678  E->setOperatorLoc(ReadSourceLocation());
679  E->setCanOverflow(Record.readInt());
680 }
681 
682 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
683  VisitExpr(E);
684  assert(E->getNumComponents() == Record.peekInt());
685  Record.skipInts(1);
686  assert(E->getNumExpressions() == Record.peekInt());
687  Record.skipInts(1);
688  E->setOperatorLoc(ReadSourceLocation());
689  E->setRParenLoc(ReadSourceLocation());
690  E->setTypeSourceInfo(GetTypeSourceInfo());
691  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
692  auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
693  SourceLocation Start = ReadSourceLocation();
694  SourceLocation End = ReadSourceLocation();
695  switch (Kind) {
696  case OffsetOfNode::Array:
697  E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
698  break;
699 
700  case OffsetOfNode::Field:
701  E->setComponent(
702  I, OffsetOfNode(Start, ReadDeclAs<FieldDecl>(), End));
703  break;
704 
706  E->setComponent(
707  I,
708  OffsetOfNode(Start, Record.getIdentifierInfo(), End));
709  break;
710 
711  case OffsetOfNode::Base: {
712  auto *Base = new (Record.getContext()) CXXBaseSpecifier();
713  *Base = Record.readCXXBaseSpecifier();
715  break;
716  }
717  }
718  }
719 
720  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
721  E->setIndexExpr(I, Record.readSubExpr());
722 }
723 
724 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
725  VisitExpr(E);
726  E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
727  if (Record.peekInt() == 0) {
728  E->setArgument(Record.readSubExpr());
729  Record.skipInts(1);
730  } else {
731  E->setArgument(GetTypeSourceInfo());
732  }
733  E->setOperatorLoc(ReadSourceLocation());
734  E->setRParenLoc(ReadSourceLocation());
735 }
736 
737 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
738  VisitExpr(E);
739  E->setLHS(Record.readSubExpr());
740  E->setRHS(Record.readSubExpr());
741  E->setRBracketLoc(ReadSourceLocation());
742 }
743 
744 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
745  VisitExpr(E);
746  E->setBase(Record.readSubExpr());
747  E->setLowerBound(Record.readSubExpr());
748  E->setLength(Record.readSubExpr());
749  E->setColonLoc(ReadSourceLocation());
750  E->setRBracketLoc(ReadSourceLocation());
751 }
752 
753 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
754  VisitExpr(E);
755  unsigned NumArgs = Record.readInt();
756  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
757  E->setRParenLoc(ReadSourceLocation());
758  E->setCallee(Record.readSubExpr());
759  for (unsigned I = 0; I != NumArgs; ++I)
760  E->setArg(I, Record.readSubExpr());
761  E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt()));
762 }
763 
764 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
765  VisitCallExpr(E);
766 }
767 
768 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
769  VisitExpr(E);
770 
771  bool HasQualifier = Record.readInt();
772  bool HasFoundDecl = Record.readInt();
773  bool HasTemplateInfo = Record.readInt();
774  unsigned NumTemplateArgs = Record.readInt();
775 
776  E->Base = Record.readSubExpr();
777  E->MemberDecl = Record.readDeclAs<ValueDecl>();
778  Record.readDeclarationNameLoc(E->MemberDNLoc, E->MemberDecl->getDeclName());
779  E->MemberLoc = Record.readSourceLocation();
780  E->MemberExprBits.IsArrow = Record.readInt();
781  E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl;
782  E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
783  E->MemberExprBits.HadMultipleCandidates = Record.readInt();
784  E->MemberExprBits.NonOdrUseReason = Record.readInt();
785  E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
786 
787  if (HasQualifier || HasFoundDecl) {
788  DeclAccessPair FoundDecl;
789  if (HasFoundDecl) {
790  auto *FoundD = Record.readDeclAs<NamedDecl>();
791  auto AS = (AccessSpecifier)Record.readInt();
792  FoundDecl = DeclAccessPair::make(FoundD, AS);
793  } else {
794  FoundDecl = DeclAccessPair::make(E->MemberDecl,
795  E->MemberDecl->getAccess());
796  }
797  E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl;
798 
799  NestedNameSpecifierLoc QualifierLoc;
800  if (HasQualifier)
801  QualifierLoc = Record.readNestedNameSpecifierLoc();
802  E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc =
803  QualifierLoc;
804  }
805 
806  if (HasTemplateInfo)
807  ReadTemplateKWAndArgsInfo(
808  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
809  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
810 }
811 
812 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
813  VisitExpr(E);
814  E->setBase(Record.readSubExpr());
815  E->setIsaMemberLoc(ReadSourceLocation());
816  E->setOpLoc(ReadSourceLocation());
817  E->setArrow(Record.readInt());
818 }
819 
820 void ASTStmtReader::
821 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
822  VisitExpr(E);
823  E->Operand = Record.readSubExpr();
824  E->setShouldCopy(Record.readInt());
825 }
826 
827 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
828  VisitExplicitCastExpr(E);
829  E->LParenLoc = ReadSourceLocation();
830  E->BridgeKeywordLoc = ReadSourceLocation();
831  E->Kind = Record.readInt();
832 }
833 
834 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
835  VisitExpr(E);
836  unsigned NumBaseSpecs = Record.readInt();
837  assert(NumBaseSpecs == E->path_size());
838  E->setSubExpr(Record.readSubExpr());
839  E->setCastKind((CastKind)Record.readInt());
840  CastExpr::path_iterator BaseI = E->path_begin();
841  while (NumBaseSpecs--) {
842  auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
843  *BaseSpec = Record.readCXXBaseSpecifier();
844  *BaseI++ = BaseSpec;
845  }
846 }
847 
848 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
849  VisitExpr(E);
850  E->setLHS(Record.readSubExpr());
851  E->setRHS(Record.readSubExpr());
853  E->setOperatorLoc(ReadSourceLocation());
854  E->setFPFeatures(FPOptions(Record.readInt()));
855 }
856 
857 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
858  VisitBinaryOperator(E);
859  E->setComputationLHSType(Record.readType());
860  E->setComputationResultType(Record.readType());
861 }
862 
863 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
864  VisitExpr(E);
865  E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
866  E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
867  E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
868  E->QuestionLoc = ReadSourceLocation();
869  E->ColonLoc = ReadSourceLocation();
870 }
871 
872 void
873 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
874  VisitExpr(E);
875  E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
876  E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
877  E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
878  E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
879  E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
880  E->QuestionLoc = ReadSourceLocation();
881  E->ColonLoc = ReadSourceLocation();
882 }
883 
884 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
885  VisitCastExpr(E);
886  E->setIsPartOfExplicitCast(Record.readInt());
887 }
888 
889 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
890  VisitCastExpr(E);
891  E->setTypeInfoAsWritten(GetTypeSourceInfo());
892 }
893 
894 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
895  VisitExplicitCastExpr(E);
896  E->setLParenLoc(ReadSourceLocation());
897  E->setRParenLoc(ReadSourceLocation());
898 }
899 
900 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
901  VisitExpr(E);
902  E->setLParenLoc(ReadSourceLocation());
903  E->setTypeSourceInfo(GetTypeSourceInfo());
904  E->setInitializer(Record.readSubExpr());
905  E->setFileScope(Record.readInt());
906 }
907 
908 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
909  VisitExpr(E);
910  E->setBase(Record.readSubExpr());
911  E->setAccessor(Record.getIdentifierInfo());
912  E->setAccessorLoc(ReadSourceLocation());
913 }
914 
915 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
916  VisitExpr(E);
917  if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
918  E->setSyntacticForm(SyntForm);
919  E->setLBraceLoc(ReadSourceLocation());
920  E->setRBraceLoc(ReadSourceLocation());
921  bool isArrayFiller = Record.readInt();
922  Expr *filler = nullptr;
923  if (isArrayFiller) {
924  filler = Record.readSubExpr();
925  E->ArrayFillerOrUnionFieldInit = filler;
926  } else
927  E->ArrayFillerOrUnionFieldInit = ReadDeclAs<FieldDecl>();
928  E->sawArrayRangeDesignator(Record.readInt());
929  unsigned NumInits = Record.readInt();
930  E->reserveInits(Record.getContext(), NumInits);
931  if (isArrayFiller) {
932  for (unsigned I = 0; I != NumInits; ++I) {
933  Expr *init = Record.readSubExpr();
934  E->updateInit(Record.getContext(), I, init ? init : filler);
935  }
936  } else {
937  for (unsigned I = 0; I != NumInits; ++I)
938  E->updateInit(Record.getContext(), I, Record.readSubExpr());
939  }
940 }
941 
942 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
944 
945  VisitExpr(E);
946  unsigned NumSubExprs = Record.readInt();
947  assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
948  for (unsigned I = 0; I != NumSubExprs; ++I)
949  E->setSubExpr(I, Record.readSubExpr());
950  E->setEqualOrColonLoc(ReadSourceLocation());
951  E->setGNUSyntax(Record.readInt());
952 
953  SmallVector<Designator, 4> Designators;
954  while (Record.getIdx() < Record.size()) {
955  switch ((DesignatorTypes)Record.readInt()) {
956  case DESIG_FIELD_DECL: {
957  auto *Field = ReadDeclAs<FieldDecl>();
958  SourceLocation DotLoc = ReadSourceLocation();
959  SourceLocation FieldLoc = ReadSourceLocation();
960  Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
961  FieldLoc));
962  Designators.back().setField(Field);
963  break;
964  }
965 
966  case DESIG_FIELD_NAME: {
967  const IdentifierInfo *Name = Record.getIdentifierInfo();
968  SourceLocation DotLoc = ReadSourceLocation();
969  SourceLocation FieldLoc = ReadSourceLocation();
970  Designators.push_back(Designator(Name, DotLoc, FieldLoc));
971  break;
972  }
973 
974  case DESIG_ARRAY: {
975  unsigned Index = Record.readInt();
976  SourceLocation LBracketLoc = ReadSourceLocation();
977  SourceLocation RBracketLoc = ReadSourceLocation();
978  Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
979  break;
980  }
981 
982  case DESIG_ARRAY_RANGE: {
983  unsigned Index = Record.readInt();
984  SourceLocation LBracketLoc = ReadSourceLocation();
985  SourceLocation EllipsisLoc = ReadSourceLocation();
986  SourceLocation RBracketLoc = ReadSourceLocation();
987  Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
988  RBracketLoc));
989  break;
990  }
991  }
992  }
993  E->setDesignators(Record.getContext(),
994  Designators.data(), Designators.size());
995 }
996 
997 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
998  VisitExpr(E);
999  E->setBase(Record.readSubExpr());
1000  E->setUpdater(Record.readSubExpr());
1001 }
1002 
1003 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1004  VisitExpr(E);
1005 }
1006 
1007 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1008  VisitExpr(E);
1009  E->SubExprs[0] = Record.readSubExpr();
1010  E->SubExprs[1] = Record.readSubExpr();
1011 }
1012 
1013 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1014  VisitExpr(E);
1015 }
1016 
1017 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1018  VisitExpr(E);
1019 }
1020 
1021 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1022  VisitExpr(E);
1023  E->setSubExpr(Record.readSubExpr());
1024  E->setWrittenTypeInfo(GetTypeSourceInfo());
1025  E->setBuiltinLoc(ReadSourceLocation());
1026  E->setRParenLoc(ReadSourceLocation());
1027  E->setIsMicrosoftABI(Record.readInt());
1028 }
1029 
1030 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1031  VisitExpr(E);
1032  E->ParentContext = ReadDeclAs<DeclContext>();
1033  E->BuiltinLoc = ReadSourceLocation();
1034  E->RParenLoc = ReadSourceLocation();
1035  E->SourceLocExprBits.Kind =
1036  static_cast<SourceLocExpr::IdentKind>(Record.readInt());
1037 }
1038 
1039 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1040  VisitExpr(E);
1041  E->setAmpAmpLoc(ReadSourceLocation());
1042  E->setLabelLoc(ReadSourceLocation());
1043  E->setLabel(ReadDeclAs<LabelDecl>());
1044 }
1045 
1046 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1047  VisitExpr(E);
1048  E->setLParenLoc(ReadSourceLocation());
1049  E->setRParenLoc(ReadSourceLocation());
1050  E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1051 }
1052 
1053 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1054  VisitExpr(E);
1055  E->setCond(Record.readSubExpr());
1056  E->setLHS(Record.readSubExpr());
1057  E->setRHS(Record.readSubExpr());
1058  E->setBuiltinLoc(ReadSourceLocation());
1059  E->setRParenLoc(ReadSourceLocation());
1060  E->setIsConditionTrue(Record.readInt());
1061 }
1062 
1063 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1064  VisitExpr(E);
1065  E->setTokenLocation(ReadSourceLocation());
1066 }
1067 
1068 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1069  VisitExpr(E);
1071  unsigned NumExprs = Record.readInt();
1072  while (NumExprs--)
1073  Exprs.push_back(Record.readSubExpr());
1074  E->setExprs(Record.getContext(), Exprs);
1075  E->setBuiltinLoc(ReadSourceLocation());
1076  E->setRParenLoc(ReadSourceLocation());
1077 }
1078 
1079 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1080  VisitExpr(E);
1081  E->BuiltinLoc = ReadSourceLocation();
1082  E->RParenLoc = ReadSourceLocation();
1083  E->TInfo = GetTypeSourceInfo();
1084  E->SrcExpr = Record.readSubExpr();
1085 }
1086 
1087 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1088  VisitExpr(E);
1089  E->setBlockDecl(ReadDeclAs<BlockDecl>());
1090 }
1091 
1092 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1093  VisitExpr(E);
1094 
1095  unsigned NumAssocs = Record.readInt();
1096  assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1097  E->ResultIndex = Record.readInt();
1098  E->GenericSelectionExprBits.GenericLoc = ReadSourceLocation();
1099  E->DefaultLoc = ReadSourceLocation();
1100  E->RParenLoc = ReadSourceLocation();
1101 
1102  Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1103  // Add 1 to account for the controlling expression which is the first
1104  // expression in the trailing array of Stmt *. This is not needed for
1105  // the trailing array of TypeSourceInfo *.
1106  for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
1107  Stmts[I] = Record.readSubExpr();
1108 
1109  TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1110  for (unsigned I = 0, N = NumAssocs; I < N; ++I)
1111  TSIs[I] = GetTypeSourceInfo();
1112 }
1113 
1114 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1115  VisitExpr(E);
1116  unsigned numSemanticExprs = Record.readInt();
1117  assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1118  E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1119 
1120  // Read the syntactic expression.
1121  E->getSubExprsBuffer()[0] = Record.readSubExpr();
1122 
1123  // Read all the semantic expressions.
1124  for (unsigned i = 0; i != numSemanticExprs; ++i) {
1125  Expr *subExpr = Record.readSubExpr();
1126  E->getSubExprsBuffer()[i+1] = subExpr;
1127  }
1128 }
1129 
1130 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1131  VisitExpr(E);
1132  E->Op = AtomicExpr::AtomicOp(Record.readInt());
1133  E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1134  for (unsigned I = 0; I != E->NumSubExprs; ++I)
1135  E->SubExprs[I] = Record.readSubExpr();
1136  E->BuiltinLoc = ReadSourceLocation();
1137  E->RParenLoc = ReadSourceLocation();
1138 }
1139 
1140 //===----------------------------------------------------------------------===//
1141 // Objective-C Expressions and Statements
1142 
1143 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1144  VisitExpr(E);
1145  E->setString(cast<StringLiteral>(Record.readSubStmt()));
1146  E->setAtLoc(ReadSourceLocation());
1147 }
1148 
1149 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1150  VisitExpr(E);
1151  // could be one of several IntegerLiteral, FloatLiteral, etc.
1152  E->SubExpr = Record.readSubStmt();
1153  E->BoxingMethod = ReadDeclAs<ObjCMethodDecl>();
1154  E->Range = ReadSourceRange();
1155 }
1156 
1157 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1158  VisitExpr(E);
1159  unsigned NumElements = Record.readInt();
1160  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1161  Expr **Elements = E->getElements();
1162  for (unsigned I = 0, N = NumElements; I != N; ++I)
1163  Elements[I] = Record.readSubExpr();
1164  E->ArrayWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
1165  E->Range = ReadSourceRange();
1166 }
1167 
1168 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1169  VisitExpr(E);
1170  unsigned NumElements = Record.readInt();
1171  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1172  bool HasPackExpansions = Record.readInt();
1173  assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1174  auto *KeyValues =
1175  E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1176  auto *Expansions =
1177  E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1178  for (unsigned I = 0; I != NumElements; ++I) {
1179  KeyValues[I].Key = Record.readSubExpr();
1180  KeyValues[I].Value = Record.readSubExpr();
1181  if (HasPackExpansions) {
1182  Expansions[I].EllipsisLoc = ReadSourceLocation();
1183  Expansions[I].NumExpansionsPlusOne = Record.readInt();
1184  }
1185  }
1186  E->DictWithObjectsMethod = ReadDeclAs<ObjCMethodDecl>();
1187  E->Range = ReadSourceRange();
1188 }
1189 
1190 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1191  VisitExpr(E);
1192  E->setEncodedTypeSourceInfo(GetTypeSourceInfo());
1193  E->setAtLoc(ReadSourceLocation());
1194  E->setRParenLoc(ReadSourceLocation());
1195 }
1196 
1197 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1198  VisitExpr(E);
1199  E->setSelector(Record.readSelector());
1200  E->setAtLoc(ReadSourceLocation());
1201  E->setRParenLoc(ReadSourceLocation());
1202 }
1203 
1204 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1205  VisitExpr(E);
1206  E->setProtocol(ReadDeclAs<ObjCProtocolDecl>());
1207  E->setAtLoc(ReadSourceLocation());
1208  E->ProtoLoc = ReadSourceLocation();
1209  E->setRParenLoc(ReadSourceLocation());
1210 }
1211 
1212 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1213  VisitExpr(E);
1214  E->setDecl(ReadDeclAs<ObjCIvarDecl>());
1215  E->setLocation(ReadSourceLocation());
1216  E->setOpLoc(ReadSourceLocation());
1217  E->setBase(Record.readSubExpr());
1218  E->setIsArrow(Record.readInt());
1219  E->setIsFreeIvar(Record.readInt());
1220 }
1221 
1222 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1223  VisitExpr(E);
1224  unsigned MethodRefFlags = Record.readInt();
1225  bool Implicit = Record.readInt() != 0;
1226  if (Implicit) {
1227  auto *Getter = ReadDeclAs<ObjCMethodDecl>();
1228  auto *Setter = ReadDeclAs<ObjCMethodDecl>();
1229  E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1230  } else {
1231  E->setExplicitProperty(ReadDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1232  }
1233  E->setLocation(ReadSourceLocation());
1234  E->setReceiverLocation(ReadSourceLocation());
1235  switch (Record.readInt()) {
1236  case 0:
1237  E->setBase(Record.readSubExpr());
1238  break;
1239  case 1:
1240  E->setSuperReceiver(Record.readType());
1241  break;
1242  case 2:
1243  E->setClassReceiver(ReadDeclAs<ObjCInterfaceDecl>());
1244  break;
1245  }
1246 }
1247 
1248 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1249  VisitExpr(E);
1250  E->setRBracket(ReadSourceLocation());
1251  E->setBaseExpr(Record.readSubExpr());
1252  E->setKeyExpr(Record.readSubExpr());
1253  E->GetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1254  E->SetAtIndexMethodDecl = ReadDeclAs<ObjCMethodDecl>();
1255 }
1256 
1257 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1258  VisitExpr(E);
1259  assert(Record.peekInt() == E->getNumArgs());
1260  Record.skipInts(1);
1261  unsigned NumStoredSelLocs = Record.readInt();
1262  E->SelLocsKind = Record.readInt();
1263  E->setDelegateInitCall(Record.readInt());
1264  E->IsImplicit = Record.readInt();
1265  auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1266  switch (Kind) {
1268  E->setInstanceReceiver(Record.readSubExpr());
1269  break;
1270 
1272  E->setClassReceiver(GetTypeSourceInfo());
1273  break;
1274 
1277  QualType T = Record.readType();
1278  SourceLocation SuperLoc = ReadSourceLocation();
1279  E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1280  break;
1281  }
1282  }
1283 
1284  assert(Kind == E->getReceiverKind());
1285 
1286  if (Record.readInt())
1287  E->setMethodDecl(ReadDeclAs<ObjCMethodDecl>());
1288  else
1289  E->setSelector(Record.readSelector());
1290 
1291  E->LBracLoc = ReadSourceLocation();
1292  E->RBracLoc = ReadSourceLocation();
1293 
1294  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1295  E->setArg(I, Record.readSubExpr());
1296 
1297  SourceLocation *Locs = E->getStoredSelLocs();
1298  for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1299  Locs[I] = ReadSourceLocation();
1300 }
1301 
1302 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1303  VisitStmt(S);
1304  S->setElement(Record.readSubStmt());
1305  S->setCollection(Record.readSubExpr());
1306  S->setBody(Record.readSubStmt());
1307  S->setForLoc(ReadSourceLocation());
1308  S->setRParenLoc(ReadSourceLocation());
1309 }
1310 
1311 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1312  VisitStmt(S);
1313  S->setCatchBody(Record.readSubStmt());
1314  S->setCatchParamDecl(ReadDeclAs<VarDecl>());
1315  S->setAtCatchLoc(ReadSourceLocation());
1316  S->setRParenLoc(ReadSourceLocation());
1317 }
1318 
1319 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1320  VisitStmt(S);
1321  S->setFinallyBody(Record.readSubStmt());
1322  S->setAtFinallyLoc(ReadSourceLocation());
1323 }
1324 
1325 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1326  VisitStmt(S); // FIXME: no test coverage.
1327  S->setSubStmt(Record.readSubStmt());
1328  S->setAtLoc(ReadSourceLocation());
1329 }
1330 
1331 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1332  VisitStmt(S);
1333  assert(Record.peekInt() == S->getNumCatchStmts());
1334  Record.skipInts(1);
1335  bool HasFinally = Record.readInt();
1336  S->setTryBody(Record.readSubStmt());
1337  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1338  S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1339 
1340  if (HasFinally)
1341  S->setFinallyStmt(Record.readSubStmt());
1342  S->setAtTryLoc(ReadSourceLocation());
1343 }
1344 
1345 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1346  VisitStmt(S); // FIXME: no test coverage.
1347  S->setSynchExpr(Record.readSubStmt());
1348  S->setSynchBody(Record.readSubStmt());
1349  S->setAtSynchronizedLoc(ReadSourceLocation());
1350 }
1351 
1352 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1353  VisitStmt(S); // FIXME: no test coverage.
1354  S->setThrowExpr(Record.readSubStmt());
1355  S->setThrowLoc(ReadSourceLocation());
1356 }
1357 
1358 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1359  VisitExpr(E);
1360  E->setValue(Record.readInt());
1361  E->setLocation(ReadSourceLocation());
1362 }
1363 
1364 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1365  VisitExpr(E);
1366  SourceRange R = Record.readSourceRange();
1367  E->AtLoc = R.getBegin();
1368  E->RParen = R.getEnd();
1369  E->VersionToCheck = Record.readVersionTuple();
1370 }
1371 
1372 //===----------------------------------------------------------------------===//
1373 // C++ Expressions and Statements
1374 //===----------------------------------------------------------------------===//
1375 
1376 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1377  VisitStmt(S);
1378  S->CatchLoc = ReadSourceLocation();
1379  S->ExceptionDecl = ReadDeclAs<VarDecl>();
1380  S->HandlerBlock = Record.readSubStmt();
1381 }
1382 
1383 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1384  VisitStmt(S);
1385  assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1386  Record.skipInts(1);
1387  S->TryLoc = ReadSourceLocation();
1388  S->getStmts()[0] = Record.readSubStmt();
1389  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1390  S->getStmts()[i + 1] = Record.readSubStmt();
1391 }
1392 
1393 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1394  VisitStmt(S);
1395  S->ForLoc = ReadSourceLocation();
1396  S->CoawaitLoc = ReadSourceLocation();
1397  S->ColonLoc = ReadSourceLocation();
1398  S->RParenLoc = ReadSourceLocation();
1399  S->setInit(Record.readSubStmt());
1400  S->setRangeStmt(Record.readSubStmt());
1401  S->setBeginStmt(Record.readSubStmt());
1402  S->setEndStmt(Record.readSubStmt());
1403  S->setCond(Record.readSubExpr());
1404  S->setInc(Record.readSubExpr());
1405  S->setLoopVarStmt(Record.readSubStmt());
1406  S->setBody(Record.readSubStmt());
1407 }
1408 
1409 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1410  VisitStmt(S);
1411  S->KeywordLoc = ReadSourceLocation();
1412  S->IsIfExists = Record.readInt();
1413  S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1414  ReadDeclarationNameInfo(S->NameInfo);
1415  S->SubStmt = Record.readSubStmt();
1416 }
1417 
1418 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1419  VisitCallExpr(E);
1420  E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1421  E->CXXOperatorCallExprBits.FPFeatures = Record.readInt();
1422  E->Range = Record.readSourceRange();
1423 }
1424 
1425 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1426  VisitExpr(E);
1427 
1428  unsigned NumArgs = Record.readInt();
1429  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1430 
1431  E->CXXConstructExprBits.Elidable = Record.readInt();
1432  E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1433  E->CXXConstructExprBits.ListInitialization = Record.readInt();
1434  E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1435  E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1436  E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1437  E->CXXConstructExprBits.Loc = ReadSourceLocation();
1438  E->Constructor = ReadDeclAs<CXXConstructorDecl>();
1439  E->ParenOrBraceRange = ReadSourceRange();
1440 
1441  for (unsigned I = 0; I != NumArgs; ++I)
1442  E->setArg(I, Record.readSubExpr());
1443 }
1444 
1445 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1446  VisitExpr(E);
1447  E->Constructor = ReadDeclAs<CXXConstructorDecl>();
1448  E->Loc = ReadSourceLocation();
1449  E->ConstructsVirtualBase = Record.readInt();
1450  E->InheritedFromVirtualBase = Record.readInt();
1451 }
1452 
1453 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1454  VisitCXXConstructExpr(E);
1455  E->TSI = GetTypeSourceInfo();
1456 }
1457 
1458 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1459  VisitExpr(E);
1460  unsigned NumCaptures = Record.readInt();
1461  assert(NumCaptures == E->NumCaptures);(void)NumCaptures;
1462  E->IntroducerRange = ReadSourceRange();
1463  E->CaptureDefault = static_cast<LambdaCaptureDefault>(Record.readInt());
1464  E->CaptureDefaultLoc = ReadSourceLocation();
1465  E->ExplicitParams = Record.readInt();
1466  E->ExplicitResultType = Record.readInt();
1467  E->ClosingBrace = ReadSourceLocation();
1468 
1469  // Read capture initializers.
1471  CEnd = E->capture_init_end();
1472  C != CEnd; ++C)
1473  *C = Record.readSubExpr();
1474 }
1475 
1476 void
1477 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1478  VisitExpr(E);
1479  E->SubExpr = Record.readSubExpr();
1480 }
1481 
1482 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1483  VisitExplicitCastExpr(E);
1484  SourceRange R = ReadSourceRange();
1485  E->Loc = R.getBegin();
1486  E->RParenLoc = R.getEnd();
1487  R = ReadSourceRange();
1488  E->AngleBrackets = R;
1489 }
1490 
1491 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1492  return VisitCXXNamedCastExpr(E);
1493 }
1494 
1495 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1496  return VisitCXXNamedCastExpr(E);
1497 }
1498 
1499 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1500  return VisitCXXNamedCastExpr(E);
1501 }
1502 
1503 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1504  return VisitCXXNamedCastExpr(E);
1505 }
1506 
1507 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1508  VisitExplicitCastExpr(E);
1509  E->setLParenLoc(ReadSourceLocation());
1510  E->setRParenLoc(ReadSourceLocation());
1511 }
1512 
1513 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1514  VisitExplicitCastExpr(E);
1515  E->KWLoc = ReadSourceLocation();
1516  E->RParenLoc = ReadSourceLocation();
1517 }
1518 
1519 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1520  VisitCallExpr(E);
1521  E->UDSuffixLoc = ReadSourceLocation();
1522 }
1523 
1524 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1525  VisitExpr(E);
1526  E->setValue(Record.readInt());
1527  E->setLocation(ReadSourceLocation());
1528 }
1529 
1530 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1531  VisitExpr(E);
1532  E->setLocation(ReadSourceLocation());
1533 }
1534 
1535 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1536  VisitExpr(E);
1537  E->setSourceRange(ReadSourceRange());
1538  if (E->isTypeOperand()) { // typeid(int)
1540  GetTypeSourceInfo());
1541  return;
1542  }
1543 
1544  // typeid(42+2)
1545  E->setExprOperand(Record.readSubExpr());
1546 }
1547 
1548 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1549  VisitExpr(E);
1550  E->setLocation(ReadSourceLocation());
1551  E->setImplicit(Record.readInt());
1552 }
1553 
1554 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1555  VisitExpr(E);
1556  E->CXXThrowExprBits.ThrowLoc = ReadSourceLocation();
1557  E->Operand = Record.readSubExpr();
1558  E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1559 }
1560 
1561 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1562  VisitExpr(E);
1563  E->Param = ReadDeclAs<ParmVarDecl>();
1564  E->UsedContext = ReadDeclAs<DeclContext>();
1565  E->CXXDefaultArgExprBits.Loc = ReadSourceLocation();
1566 }
1567 
1568 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1569  VisitExpr(E);
1570  E->Field = ReadDeclAs<FieldDecl>();
1571  E->UsedContext = ReadDeclAs<DeclContext>();
1572  E->CXXDefaultInitExprBits.Loc = ReadSourceLocation();
1573 }
1574 
1575 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1576  VisitExpr(E);
1577  E->setTemporary(Record.readCXXTemporary());
1578  E->setSubExpr(Record.readSubExpr());
1579 }
1580 
1581 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1582  VisitExpr(E);
1583  E->TypeInfo = GetTypeSourceInfo();
1584  E->CXXScalarValueInitExprBits.RParenLoc = ReadSourceLocation();
1585 }
1586 
1587 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1588  VisitExpr(E);
1589 
1590  bool IsArray = Record.readInt();
1591  bool HasInit = Record.readInt();
1592  unsigned NumPlacementArgs = Record.readInt();
1593  bool IsParenTypeId = Record.readInt();
1594 
1595  E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1596  E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1597  E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1598  E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1599 
1600  assert((IsArray == E->isArray()) && "Wrong IsArray!");
1601  assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1602  assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1603  "Wrong NumPlacementArgs!");
1604  assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1605  (void)IsArray;
1606  (void)HasInit;
1607  (void)NumPlacementArgs;
1608 
1609  E->setOperatorNew(ReadDeclAs<FunctionDecl>());
1610  E->setOperatorDelete(ReadDeclAs<FunctionDecl>());
1611  E->AllocatedTypeInfo = GetTypeSourceInfo();
1612  if (IsParenTypeId)
1613  E->getTrailingObjects<SourceRange>()[0] = ReadSourceRange();
1614  E->Range = ReadSourceRange();
1615  E->DirectInitRange = ReadSourceRange();
1616 
1617  // Install all the subexpressions.
1619  N = E->raw_arg_end();
1620  I != N; ++I)
1621  *I = Record.readSubStmt();
1622 }
1623 
1624 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1625  VisitExpr(E);
1626  E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1627  E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1628  E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1629  E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1630  E->OperatorDelete = ReadDeclAs<FunctionDecl>();
1631  E->Argument = Record.readSubExpr();
1632  E->CXXDeleteExprBits.Loc = ReadSourceLocation();
1633 }
1634 
1635 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1636  VisitExpr(E);
1637 
1638  E->Base = Record.readSubExpr();
1639  E->IsArrow = Record.readInt();
1640  E->OperatorLoc = ReadSourceLocation();
1641  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1642  E->ScopeType = GetTypeSourceInfo();
1643  E->ColonColonLoc = ReadSourceLocation();
1644  E->TildeLoc = ReadSourceLocation();
1645 
1646  IdentifierInfo *II = Record.getIdentifierInfo();
1647  if (II)
1648  E->setDestroyedType(II, ReadSourceLocation());
1649  else
1650  E->setDestroyedType(GetTypeSourceInfo());
1651 }
1652 
1653 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1654  VisitExpr(E);
1655 
1656  unsigned NumObjects = Record.readInt();
1657  assert(NumObjects == E->getNumObjects());
1658  for (unsigned i = 0; i != NumObjects; ++i)
1659  E->getTrailingObjects<BlockDecl *>()[i] =
1660  ReadDeclAs<BlockDecl>();
1661 
1662  E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1663  E->SubExpr = Record.readSubExpr();
1664 }
1665 
1666 void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
1668  VisitExpr(E);
1669 
1670  bool HasTemplateKWAndArgsInfo = Record.readInt();
1671  unsigned NumTemplateArgs = Record.readInt();
1672  bool HasFirstQualifierFoundInScope = Record.readInt();
1673 
1674  assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
1675  "Wrong HasTemplateKWAndArgsInfo!");
1676  assert(
1677  (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
1678  "Wrong HasFirstQualifierFoundInScope!");
1679 
1680  if (HasTemplateKWAndArgsInfo)
1681  ReadTemplateKWAndArgsInfo(
1682  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1683  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1684 
1685  assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
1686  "Wrong NumTemplateArgs!");
1687 
1688  E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt();
1689  E->CXXDependentScopeMemberExprBits.OperatorLoc = ReadSourceLocation();
1690  E->BaseType = Record.readType();
1691  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1692  E->Base = Record.readSubExpr();
1693 
1694  if (HasFirstQualifierFoundInScope)
1695  *E->getTrailingObjects<NamedDecl *>() = ReadDeclAs<NamedDecl>();
1696 
1697  ReadDeclarationNameInfo(E->MemberNameInfo);
1698 }
1699 
1700 void
1701 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1702  VisitExpr(E);
1703 
1704  if (Record.readInt()) // HasTemplateKWAndArgsInfo
1705  ReadTemplateKWAndArgsInfo(
1706  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1707  E->getTrailingObjects<TemplateArgumentLoc>(),
1708  /*NumTemplateArgs=*/Record.readInt());
1709 
1710  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1711  ReadDeclarationNameInfo(E->NameInfo);
1712 }
1713 
1714 void
1715 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1716  VisitExpr(E);
1717  assert(Record.peekInt() == E->arg_size() &&
1718  "Read wrong record during creation ?");
1719  Record.skipInts(1);
1720  for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
1721  E->setArg(I, Record.readSubExpr());
1722  E->TSI = GetTypeSourceInfo();
1723  E->setLParenLoc(ReadSourceLocation());
1724  E->setRParenLoc(ReadSourceLocation());
1725 }
1726 
1727 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1728  VisitExpr(E);
1729 
1730  unsigned NumResults = Record.readInt();
1731  bool HasTemplateKWAndArgsInfo = Record.readInt();
1732  assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
1733  assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
1734  "Wrong HasTemplateKWAndArgsInfo!");
1735 
1736  if (HasTemplateKWAndArgsInfo) {
1737  unsigned NumTemplateArgs = Record.readInt();
1738  ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
1740  NumTemplateArgs);
1741  assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
1742  "Wrong NumTemplateArgs!");
1743  }
1744 
1745  UnresolvedSet<8> Decls;
1746  for (unsigned I = 0; I != NumResults; ++I) {
1747  auto *D = ReadDeclAs<NamedDecl>();
1748  auto AS = (AccessSpecifier)Record.readInt();
1749  Decls.addDecl(D, AS);
1750  }
1751 
1752  DeclAccessPair *Results = E->getTrailingResults();
1753  UnresolvedSetIterator Iter = Decls.begin();
1754  for (unsigned I = 0; I != NumResults; ++I) {
1755  Results[I] = (Iter + I).getPair();
1756  }
1757 
1758  ReadDeclarationNameInfo(E->NameInfo);
1759  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1760 }
1761 
1762 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1763  VisitOverloadExpr(E);
1764  E->UnresolvedMemberExprBits.IsArrow = Record.readInt();
1765  E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt();
1766  E->Base = Record.readSubExpr();
1767  E->BaseType = Record.readType();
1768  E->OperatorLoc = ReadSourceLocation();
1769 }
1770 
1771 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1772  VisitOverloadExpr(E);
1773  E->UnresolvedLookupExprBits.RequiresADL = Record.readInt();
1774  E->UnresolvedLookupExprBits.Overloaded = Record.readInt();
1775  E->NamingClass = ReadDeclAs<CXXRecordDecl>();
1776 }
1777 
1778 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
1779  VisitExpr(E);
1780  E->TypeTraitExprBits.NumArgs = Record.readInt();
1781  E->TypeTraitExprBits.Kind = Record.readInt();
1782  E->TypeTraitExprBits.Value = Record.readInt();
1783  SourceRange Range = ReadSourceRange();
1784  E->Loc = Range.getBegin();
1785  E->RParenLoc = Range.getEnd();
1786 
1787  auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
1788  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1789  Args[I] = GetTypeSourceInfo();
1790 }
1791 
1792 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1793  VisitExpr(E);
1794  E->ATT = (ArrayTypeTrait)Record.readInt();
1795  E->Value = (unsigned int)Record.readInt();
1796  SourceRange Range = ReadSourceRange();
1797  E->Loc = Range.getBegin();
1798  E->RParen = Range.getEnd();
1799  E->QueriedType = GetTypeSourceInfo();
1800  E->Dimension = Record.readSubExpr();
1801 }
1802 
1803 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1804  VisitExpr(E);
1805  E->ET = (ExpressionTrait)Record.readInt();
1806  E->Value = (bool)Record.readInt();
1807  SourceRange Range = ReadSourceRange();
1808  E->QueriedExpression = Record.readSubExpr();
1809  E->Loc = Range.getBegin();
1810  E->RParen = Range.getEnd();
1811 }
1812 
1813 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1814  VisitExpr(E);
1815  E->CXXNoexceptExprBits.Value = Record.readInt();
1816  E->Range = ReadSourceRange();
1817  E->Operand = Record.readSubExpr();
1818 }
1819 
1820 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
1821  VisitExpr(E);
1822  E->EllipsisLoc = ReadSourceLocation();
1823  E->NumExpansions = Record.readInt();
1824  E->Pattern = Record.readSubExpr();
1825 }
1826 
1827 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1828  VisitExpr(E);
1829  unsigned NumPartialArgs = Record.readInt();
1830  E->OperatorLoc = ReadSourceLocation();
1831  E->PackLoc = ReadSourceLocation();
1832  E->RParenLoc = ReadSourceLocation();
1833  E->Pack = Record.readDeclAs<NamedDecl>();
1834  if (E->isPartiallySubstituted()) {
1835  assert(E->Length == NumPartialArgs);
1836  for (auto *I = E->getTrailingObjects<TemplateArgument>(),
1837  *E = I + NumPartialArgs;
1838  I != E; ++I)
1839  new (I) TemplateArgument(Record.readTemplateArgument());
1840  } else if (!E->isValueDependent()) {
1841  E->Length = Record.readInt();
1842  }
1843 }
1844 
1845 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
1847  VisitExpr(E);
1848  E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
1849  E->SubstNonTypeTemplateParmExprBits.NameLoc = ReadSourceLocation();
1850  E->Replacement = Record.readSubExpr();
1851 }
1852 
1853 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
1855  VisitExpr(E);
1856  E->Param = ReadDeclAs<NonTypeTemplateParmDecl>();
1857  TemplateArgument ArgPack = Record.readTemplateArgument();
1858  if (ArgPack.getKind() != TemplateArgument::Pack)
1859  return;
1860 
1861  E->Arguments = ArgPack.pack_begin();
1862  E->NumArguments = ArgPack.pack_size();
1863  E->NameLoc = ReadSourceLocation();
1864 }
1865 
1866 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
1867  VisitExpr(E);
1868  E->NumParameters = Record.readInt();
1869  E->ParamPack = ReadDeclAs<ParmVarDecl>();
1870  E->NameLoc = ReadSourceLocation();
1871  auto **Parms = E->getTrailingObjects<VarDecl *>();
1872  for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
1873  Parms[i] = ReadDeclAs<VarDecl>();
1874 }
1875 
1876 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1877  VisitExpr(E);
1878  E->State = Record.readSubExpr();
1879  auto *VD = ReadDeclAs<ValueDecl>();
1880  unsigned ManglingNumber = Record.readInt();
1881  E->setExtendingDecl(VD, ManglingNumber);
1882 }
1883 
1884 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
1885  VisitExpr(E);
1886  E->LParenLoc = ReadSourceLocation();
1887  E->EllipsisLoc = ReadSourceLocation();
1888  E->RParenLoc = ReadSourceLocation();
1889  E->NumExpansions = Record.readInt();
1890  E->SubExprs[0] = Record.readSubExpr();
1891  E->SubExprs[1] = Record.readSubExpr();
1892  E->Opcode = (BinaryOperatorKind)Record.readInt();
1893 }
1894 
1895 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1896  VisitExpr(E);
1897  E->SourceExpr = Record.readSubExpr();
1898  E->OpaqueValueExprBits.Loc = ReadSourceLocation();
1899  E->setIsUnique(Record.readInt());
1900 }
1901 
1902 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
1903  llvm_unreachable("Cannot read TypoExpr nodes");
1904 }
1905 
1906 //===----------------------------------------------------------------------===//
1907 // Microsoft Expressions and Statements
1908 //===----------------------------------------------------------------------===//
1909 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
1910  VisitExpr(E);
1911  E->IsArrow = (Record.readInt() != 0);
1912  E->BaseExpr = Record.readSubExpr();
1913  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1914  E->MemberLoc = ReadSourceLocation();
1915  E->TheDecl = ReadDeclAs<MSPropertyDecl>();
1916 }
1917 
1918 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
1919  VisitExpr(E);
1920  E->setBase(Record.readSubExpr());
1921  E->setIdx(Record.readSubExpr());
1922  E->setRBracketLoc(ReadSourceLocation());
1923 }
1924 
1925 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1926  VisitExpr(E);
1927  E->setSourceRange(ReadSourceRange());
1928  std::string UuidStr = ReadString();
1929  E->setUuidStr(StringRef(UuidStr).copy(Record.getContext()));
1930  if (E->isTypeOperand()) { // __uuidof(ComType)
1932  GetTypeSourceInfo());
1933  return;
1934  }
1935 
1936  // __uuidof(expr)
1937  E->setExprOperand(Record.readSubExpr());
1938 }
1939 
1940 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
1941  VisitStmt(S);
1942  S->setLeaveLoc(ReadSourceLocation());
1943 }
1944 
1945 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
1946  VisitStmt(S);
1947  S->Loc = ReadSourceLocation();
1948  S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
1949  S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
1950 }
1951 
1952 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1953  VisitStmt(S);
1954  S->Loc = ReadSourceLocation();
1955  S->Block = Record.readSubStmt();
1956 }
1957 
1958 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
1959  VisitStmt(S);
1960  S->IsCXXTry = Record.readInt();
1961  S->TryLoc = ReadSourceLocation();
1962  S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
1963  S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
1964 }
1965 
1966 //===----------------------------------------------------------------------===//
1967 // CUDA Expressions and Statements
1968 //===----------------------------------------------------------------------===//
1969 
1970 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1971  VisitCallExpr(E);
1972  E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
1973 }
1974 
1975 //===----------------------------------------------------------------------===//
1976 // OpenCL Expressions and Statements.
1977 //===----------------------------------------------------------------------===//
1978 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
1979  VisitExpr(E);
1980  E->BuiltinLoc = ReadSourceLocation();
1981  E->RParenLoc = ReadSourceLocation();
1982  E->SrcExpr = Record.readSubExpr();
1983 }
1984 
1985 //===----------------------------------------------------------------------===//
1986 // OpenMP Directives.
1987 //===----------------------------------------------------------------------===//
1988 
1989 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
1990  E->setLocStart(ReadSourceLocation());
1991  E->setLocEnd(ReadSourceLocation());
1992  OMPClauseReader ClauseReader(Record);
1994  for (unsigned i = 0; i < E->getNumClauses(); ++i)
1995  Clauses.push_back(ClauseReader.readClause());
1996  E->setClauses(Clauses);
1997  if (E->hasAssociatedStmt())
1998  E->setAssociatedStmt(Record.readSubStmt());
1999 }
2000 
2001 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2002  VisitStmt(D);
2003  // Two fields (NumClauses and CollapsedNum) were read in ReadStmtFromStream.
2004  Record.skipInts(2);
2005  VisitOMPExecutableDirective(D);
2006  D->setIterationVariable(Record.readSubExpr());
2007  D->setLastIteration(Record.readSubExpr());
2008  D->setCalcLastIteration(Record.readSubExpr());
2009  D->setPreCond(Record.readSubExpr());
2010  D->setCond(Record.readSubExpr());
2011  D->setInit(Record.readSubExpr());
2012  D->setInc(Record.readSubExpr());
2013  D->setPreInits(Record.readSubStmt());
2017  D->setIsLastIterVariable(Record.readSubExpr());
2018  D->setLowerBoundVariable(Record.readSubExpr());
2019  D->setUpperBoundVariable(Record.readSubExpr());
2020  D->setStrideVariable(Record.readSubExpr());
2021  D->setEnsureUpperBound(Record.readSubExpr());
2022  D->setNextLowerBound(Record.readSubExpr());
2023  D->setNextUpperBound(Record.readSubExpr());
2024  D->setNumIterations(Record.readSubExpr());
2025  }
2029  D->setDistInc(Record.readSubExpr());
2030  D->setPrevEnsureUpperBound(Record.readSubExpr());
2034  D->setCombinedInit(Record.readSubExpr());
2035  D->setCombinedCond(Record.readSubExpr());
2038  D->setCombinedDistCond(Record.readSubExpr());
2040  }
2042  unsigned CollapsedNum = D->getCollapsedNumber();
2043  Sub.reserve(CollapsedNum);
2044  for (unsigned i = 0; i < CollapsedNum; ++i)
2045  Sub.push_back(Record.readSubExpr());
2046  D->setCounters(Sub);
2047  Sub.clear();
2048  for (unsigned i = 0; i < CollapsedNum; ++i)
2049  Sub.push_back(Record.readSubExpr());
2050  D->setPrivateCounters(Sub);
2051  Sub.clear();
2052  for (unsigned i = 0; i < CollapsedNum; ++i)
2053  Sub.push_back(Record.readSubExpr());
2054  D->setInits(Sub);
2055  Sub.clear();
2056  for (unsigned i = 0; i < CollapsedNum; ++i)
2057  Sub.push_back(Record.readSubExpr());
2058  D->setUpdates(Sub);
2059  Sub.clear();
2060  for (unsigned i = 0; i < CollapsedNum; ++i)
2061  Sub.push_back(Record.readSubExpr());
2062  D->setFinals(Sub);
2063  Sub.clear();
2064  for (unsigned i = 0; i < CollapsedNum; ++i)
2065  Sub.push_back(Record.readSubExpr());
2066  D->setDependentCounters(Sub);
2067  Sub.clear();
2068  for (unsigned i = 0; i < CollapsedNum; ++i)
2069  Sub.push_back(Record.readSubExpr());
2070  D->setDependentInits(Sub);
2071  Sub.clear();
2072  for (unsigned i = 0; i < CollapsedNum; ++i)
2073  Sub.push_back(Record.readSubExpr());
2074  D->setFinalsConditions(Sub);
2075 }
2076 
2077 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2078  VisitStmt(D);
2079  // The NumClauses field was read in ReadStmtFromStream.
2080  Record.skipInts(1);
2081  VisitOMPExecutableDirective(D);
2082  D->setHasCancel(Record.readInt());
2083 }
2084 
2085 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2086  VisitOMPLoopDirective(D);
2087 }
2088 
2089 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2090  VisitOMPLoopDirective(D);
2091  D->setHasCancel(Record.readInt());
2092 }
2093 
2094 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2095  VisitOMPLoopDirective(D);
2096 }
2097 
2098 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2099  VisitStmt(D);
2100  // The NumClauses field was read in ReadStmtFromStream.
2101  Record.skipInts(1);
2102  VisitOMPExecutableDirective(D);
2103  D->setHasCancel(Record.readInt());
2104 }
2105 
2106 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2107  VisitStmt(D);
2108  VisitOMPExecutableDirective(D);
2109  D->setHasCancel(Record.readInt());
2110 }
2111 
2112 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2113  VisitStmt(D);
2114  // The NumClauses field was read in ReadStmtFromStream.
2115  Record.skipInts(1);
2116  VisitOMPExecutableDirective(D);
2117 }
2118 
2119 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2120  VisitStmt(D);
2121  VisitOMPExecutableDirective(D);
2122 }
2123 
2124 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2125  VisitStmt(D);
2126  // The NumClauses field was read in ReadStmtFromStream.
2127  Record.skipInts(1);
2128  VisitOMPExecutableDirective(D);
2129  ReadDeclarationNameInfo(D->DirName);
2130 }
2131 
2132 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2133  VisitOMPLoopDirective(D);
2134  D->setHasCancel(Record.readInt());
2135 }
2136 
2137 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2139  VisitOMPLoopDirective(D);
2140 }
2141 
2142 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2144  VisitStmt(D);
2145  // The NumClauses field was read in ReadStmtFromStream.
2146  Record.skipInts(1);
2147  VisitOMPExecutableDirective(D);
2148  D->setHasCancel(Record.readInt());
2149 }
2150 
2151 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2152  VisitStmt(D);
2153  // The NumClauses field was read in ReadStmtFromStream.
2154  Record.skipInts(1);
2155  VisitOMPExecutableDirective(D);
2156  D->setHasCancel(Record.readInt());
2157 }
2158 
2159 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2160  VisitStmt(D);
2161  VisitOMPExecutableDirective(D);
2162 }
2163 
2164 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2165  VisitStmt(D);
2166  VisitOMPExecutableDirective(D);
2167 }
2168 
2169 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2170  VisitStmt(D);
2171  VisitOMPExecutableDirective(D);
2172 }
2173 
2174 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2175  VisitStmt(D);
2176  // The NumClauses field was read in ReadStmtFromStream.
2177  Record.skipInts(1);
2178  VisitOMPExecutableDirective(D);
2179  D->setReductionRef(Record.readSubExpr());
2180 }
2181 
2182 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2183  VisitStmt(D);
2184  // The NumClauses field was read in ReadStmtFromStream.
2185  Record.skipInts(1);
2186  VisitOMPExecutableDirective(D);
2187 }
2188 
2189 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2190  VisitStmt(D);
2191  // The NumClauses field was read in ReadStmtFromStream.
2192  Record.skipInts(1);
2193  VisitOMPExecutableDirective(D);
2194 }
2195 
2196 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2197  VisitStmt(D);
2198  // The NumClauses field was read in ReadStmtFromStream.
2199  Record.skipInts(1);
2200  VisitOMPExecutableDirective(D);
2201  D->setX(Record.readSubExpr());
2202  D->setV(Record.readSubExpr());
2203  D->setExpr(Record.readSubExpr());
2204  D->setUpdateExpr(Record.readSubExpr());
2205  D->IsXLHSInRHSPart = Record.readInt() != 0;
2206  D->IsPostfixUpdate = Record.readInt() != 0;
2207 }
2208 
2209 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2210  VisitStmt(D);
2211  // The NumClauses field was read in ReadStmtFromStream.
2212  Record.skipInts(1);
2213  VisitOMPExecutableDirective(D);
2214 }
2215 
2216 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2217  VisitStmt(D);
2218  Record.skipInts(1);
2219  VisitOMPExecutableDirective(D);
2220 }
2221 
2222 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2224  VisitStmt(D);
2225  Record.skipInts(1);
2226  VisitOMPExecutableDirective(D);
2227 }
2228 
2229 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2231  VisitStmt(D);
2232  Record.skipInts(1);
2233  VisitOMPExecutableDirective(D);
2234 }
2235 
2236 void ASTStmtReader::VisitOMPTargetParallelDirective(
2238  VisitStmt(D);
2239  Record.skipInts(1);
2240  VisitOMPExecutableDirective(D);
2241 }
2242 
2243 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2245  VisitOMPLoopDirective(D);
2246  D->setHasCancel(Record.readInt());
2247 }
2248 
2249 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2250  VisitStmt(D);
2251  // The NumClauses field was read in ReadStmtFromStream.
2252  Record.skipInts(1);
2253  VisitOMPExecutableDirective(D);
2254 }
2255 
2256 void ASTStmtReader::VisitOMPCancellationPointDirective(
2258  VisitStmt(D);
2259  VisitOMPExecutableDirective(D);
2260  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2261 }
2262 
2263 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2264  VisitStmt(D);
2265  // The NumClauses field was read in ReadStmtFromStream.
2266  Record.skipInts(1);
2267  VisitOMPExecutableDirective(D);
2268  D->setCancelRegion(static_cast<OpenMPDirectiveKind>(Record.readInt()));
2269 }
2270 
2271 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2272  VisitOMPLoopDirective(D);
2273 }
2274 
2275 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2276  VisitOMPLoopDirective(D);
2277 }
2278 
2279 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2280  VisitOMPLoopDirective(D);
2281 }
2282 
2283 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2284  VisitStmt(D);
2285  Record.skipInts(1);
2286  VisitOMPExecutableDirective(D);
2287 }
2288 
2289 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2291  VisitOMPLoopDirective(D);
2292  D->setHasCancel(Record.readInt());
2293 }
2294 
2295 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2297  VisitOMPLoopDirective(D);
2298 }
2299 
2300 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2302  VisitOMPLoopDirective(D);
2303 }
2304 
2305 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2307  VisitOMPLoopDirective(D);
2308 }
2309 
2310 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2311  VisitOMPLoopDirective(D);
2312 }
2313 
2314 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2316  VisitOMPLoopDirective(D);
2317 }
2318 
2319 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2321  VisitOMPLoopDirective(D);
2322 }
2323 
2324 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2326  VisitOMPLoopDirective(D);
2327 }
2328 
2329 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2331  VisitOMPLoopDirective(D);
2332  D->setHasCancel(Record.readInt());
2333 }
2334 
2335 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2336  VisitStmt(D);
2337  // The NumClauses field was read in ReadStmtFromStream.
2338  Record.skipInts(1);
2339  VisitOMPExecutableDirective(D);
2340 }
2341 
2342 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2344  VisitOMPLoopDirective(D);
2345 }
2346 
2347 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2349  VisitOMPLoopDirective(D);
2350  D->setHasCancel(Record.readInt());
2351 }
2352 
2353 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2355  VisitOMPLoopDirective(D);
2356 }
2357 
2358 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2360  VisitOMPLoopDirective(D);
2361 }
2362 
2363 //===----------------------------------------------------------------------===//
2364 // ASTReader Implementation
2365 //===----------------------------------------------------------------------===//
2366 
2368  switch (ReadingKind) {
2369  case Read_None:
2370  llvm_unreachable("should not call this when not reading anything");
2371  case Read_Decl:
2372  case Read_Type:
2373  return ReadStmtFromStream(F);
2374  case Read_Stmt:
2375  return ReadSubStmt();
2376  }
2377 
2378  llvm_unreachable("ReadingKind not set ?");
2379 }
2380 
2382  return cast_or_null<Expr>(ReadStmt(F));
2383 }
2384 
2386  return cast_or_null<Expr>(ReadSubStmt());
2387 }
2388 
2389 // Within the bitstream, expressions are stored in Reverse Polish
2390 // Notation, with each of the subexpressions preceding the
2391 // expression they are stored in. Subexpressions are stored from last to first.
2392 // To evaluate expressions, we continue reading expressions and placing them on
2393 // the stack, with expressions having operands removing those operands from the
2394 // stack. Evaluation terminates when we see a STMT_STOP record, and
2395 // the single remaining expression on the stack is our result.
2396 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2397  ReadingKindTracker ReadingKind(Read_Stmt, *this);
2398  llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2399 
2400  // Map of offset to previously deserialized stmt. The offset points
2401  // just after the stmt record.
2402  llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2403 
2404 #ifndef NDEBUG
2405  unsigned PrevNumStmts = StmtStack.size();
2406 #endif
2407 
2408  ASTRecordReader Record(*this, F);
2409  ASTStmtReader Reader(Record, Cursor);
2410  Stmt::EmptyShell Empty;
2411 
2412  while (true) {
2414  Cursor.advanceSkippingSubblocks();
2415  if (!MaybeEntry) {
2416  Error(toString(MaybeEntry.takeError()));
2417  return nullptr;
2418  }
2419  llvm::BitstreamEntry Entry = MaybeEntry.get();
2420 
2421  switch (Entry.Kind) {
2422  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2424  Error("malformed block record in AST file");
2425  return nullptr;
2426  case llvm::BitstreamEntry::EndBlock:
2427  goto Done;
2428  case llvm::BitstreamEntry::Record:
2429  // The interesting case.
2430  break;
2431  }
2432 
2433  ASTContext &Context = getContext();
2434  Stmt *S = nullptr;
2435  bool Finished = false;
2436  bool IsStmtReference = false;
2437  Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID);
2438  if (!MaybeStmtCode) {
2439  Error(toString(MaybeStmtCode.takeError()));
2440  return nullptr;
2441  }
2442  switch ((StmtCode)MaybeStmtCode.get()) {
2443  case STMT_STOP:
2444  Finished = true;
2445  break;
2446 
2447  case STMT_REF_PTR:
2448  IsStmtReference = true;
2449  assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2450  "No stmt was recorded for this offset reference!");
2451  S = StmtEntries[Record.readInt()];
2452  break;
2453 
2454  case STMT_NULL_PTR:
2455  S = nullptr;
2456  break;
2457 
2458  case STMT_NULL:
2459  S = new (Context) NullStmt(Empty);
2460  break;
2461 
2462  case STMT_COMPOUND:
2464  Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]);
2465  break;
2466 
2467  case STMT_CASE:
2469  Context,
2470  /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
2471  break;
2472 
2473  case STMT_DEFAULT:
2474  S = new (Context) DefaultStmt(Empty);
2475  break;
2476 
2477  case STMT_LABEL:
2478  S = new (Context) LabelStmt(Empty);
2479  break;
2480 
2481  case STMT_ATTRIBUTED:
2483  Context,
2484  /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2485  break;
2486 
2487  case STMT_IF:
2488  S = IfStmt::CreateEmpty(
2489  Context,
2490  /* HasElse=*/Record[ASTStmtReader::NumStmtFields + 1],
2491  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 2],
2492  /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 3]);
2493  break;
2494 
2495  case STMT_SWITCH:
2497  Context,
2498  /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
2499  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
2500  break;
2501 
2502  case STMT_WHILE:
2504  Context,
2505  /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
2506  break;
2507 
2508  case STMT_DO:
2509  S = new (Context) DoStmt(Empty);
2510  break;
2511 
2512  case STMT_FOR:
2513  S = new (Context) ForStmt(Empty);
2514  break;
2515 
2516  case STMT_GOTO:
2517  S = new (Context) GotoStmt(Empty);
2518  break;
2519 
2520  case STMT_INDIRECT_GOTO:
2521  S = new (Context) IndirectGotoStmt(Empty);
2522  break;
2523 
2524  case STMT_CONTINUE:
2525  S = new (Context) ContinueStmt(Empty);
2526  break;
2527 
2528  case STMT_BREAK:
2529  S = new (Context) BreakStmt(Empty);
2530  break;
2531 
2532  case STMT_RETURN:
2534  Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
2535  break;
2536 
2537  case STMT_DECL:
2538  S = new (Context) DeclStmt(Empty);
2539  break;
2540 
2541  case STMT_GCCASM:
2542  S = new (Context) GCCAsmStmt(Empty);
2543  break;
2544 
2545  case STMT_MSASM:
2546  S = new (Context) MSAsmStmt(Empty);
2547  break;
2548 
2549  case STMT_CAPTURED:
2551  Context, Record[ASTStmtReader::NumStmtFields]);
2552  break;
2553 
2554  case EXPR_CONSTANT:
2556  Context,
2557  static_cast<ConstantExpr::ResultStorageKind>(
2559  Empty);
2560  break;
2561 
2562  case EXPR_PREDEFINED:
2564  Context,
2565  /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
2566  break;
2567 
2568  case EXPR_DECL_REF:
2570  Context,
2571  /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2572  /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2573  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2574  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2575  Record[ASTStmtReader::NumExprFields + 6] : 0);
2576  break;
2577 
2578  case EXPR_INTEGER_LITERAL:
2579  S = IntegerLiteral::Create(Context, Empty);
2580  break;
2581 
2582  case EXPR_FLOATING_LITERAL:
2583  S = FloatingLiteral::Create(Context, Empty);
2584  break;
2585 
2587  S = new (Context) ImaginaryLiteral(Empty);
2588  break;
2589 
2590  case EXPR_STRING_LITERAL:
2592  Context,
2593  /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
2594  /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
2595  /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
2596  break;
2597 
2599  S = new (Context) CharacterLiteral(Empty);
2600  break;
2601 
2602  case EXPR_PAREN:
2603  S = new (Context) ParenExpr(Empty);
2604  break;
2605 
2606  case EXPR_PAREN_LIST:
2608  Context,
2609  /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
2610  break;
2611 
2612  case EXPR_UNARY_OPERATOR:
2613  S = new (Context) UnaryOperator(Empty);
2614  break;
2615 
2616  case EXPR_OFFSETOF:
2617  S = OffsetOfExpr::CreateEmpty(Context,
2618  Record[ASTStmtReader::NumExprFields],
2619  Record[ASTStmtReader::NumExprFields + 1]);
2620  break;
2621 
2622  case EXPR_SIZEOF_ALIGN_OF:
2623  S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2624  break;
2625 
2626  case EXPR_ARRAY_SUBSCRIPT:
2627  S = new (Context) ArraySubscriptExpr(Empty);
2628  break;
2629 
2631  S = new (Context) OMPArraySectionExpr(Empty);
2632  break;
2633 
2634  case EXPR_CALL:
2636  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
2637  break;
2638 
2639  case EXPR_MEMBER:
2640  S = MemberExpr::CreateEmpty(Context, Record[ASTStmtReader::NumExprFields],
2641  Record[ASTStmtReader::NumExprFields + 1],
2642  Record[ASTStmtReader::NumExprFields + 2],
2643  Record[ASTStmtReader::NumExprFields + 3]);
2644  break;
2645 
2646  case EXPR_BINARY_OPERATOR:
2647  S = new (Context) BinaryOperator(Empty);
2648  break;
2649 
2651  S = new (Context) CompoundAssignOperator(Empty);
2652  break;
2653 
2655  S = new (Context) ConditionalOperator(Empty);
2656  break;
2657 
2659  S = new (Context) BinaryConditionalOperator(Empty);
2660  break;
2661 
2662  case EXPR_IMPLICIT_CAST:
2663  S = ImplicitCastExpr::CreateEmpty(Context,
2664  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2665  break;
2666 
2667  case EXPR_CSTYLE_CAST:
2668  S = CStyleCastExpr::CreateEmpty(Context,
2669  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
2670  break;
2671 
2672  case EXPR_COMPOUND_LITERAL:
2673  S = new (Context) CompoundLiteralExpr(Empty);
2674  break;
2675 
2677  S = new (Context) ExtVectorElementExpr(Empty);
2678  break;
2679 
2680  case EXPR_INIT_LIST:
2681  S = new (Context) InitListExpr(Empty);
2682  break;
2683 
2684  case EXPR_DESIGNATED_INIT:
2685  S = DesignatedInitExpr::CreateEmpty(Context,
2686  Record[ASTStmtReader::NumExprFields] - 1);
2687 
2688  break;
2689 
2691  S = new (Context) DesignatedInitUpdateExpr(Empty);
2692  break;
2693 
2695  S = new (Context) ImplicitValueInitExpr(Empty);
2696  break;
2697 
2698  case EXPR_NO_INIT:
2699  S = new (Context) NoInitExpr(Empty);
2700  break;
2701 
2702  case EXPR_ARRAY_INIT_LOOP:
2703  S = new (Context) ArrayInitLoopExpr(Empty);
2704  break;
2705 
2706  case EXPR_ARRAY_INIT_INDEX:
2707  S = new (Context) ArrayInitIndexExpr(Empty);
2708  break;
2709 
2710  case EXPR_VA_ARG:
2711  S = new (Context) VAArgExpr(Empty);
2712  break;
2713 
2714  case EXPR_SOURCE_LOC:
2715  S = new (Context) SourceLocExpr(Empty);
2716  break;
2717 
2718  case EXPR_ADDR_LABEL:
2719  S = new (Context) AddrLabelExpr(Empty);
2720  break;
2721 
2722  case EXPR_STMT:
2723  S = new (Context) StmtExpr(Empty);
2724  break;
2725 
2726  case EXPR_CHOOSE:
2727  S = new (Context) ChooseExpr(Empty);
2728  break;
2729 
2730  case EXPR_GNU_NULL:
2731  S = new (Context) GNUNullExpr(Empty);
2732  break;
2733 
2734  case EXPR_SHUFFLE_VECTOR:
2735  S = new (Context) ShuffleVectorExpr(Empty);
2736  break;
2737 
2738  case EXPR_CONVERT_VECTOR:
2739  S = new (Context) ConvertVectorExpr(Empty);
2740  break;
2741 
2742  case EXPR_BLOCK:
2743  S = new (Context) BlockExpr(Empty);
2744  break;
2745 
2748  Context,
2749  /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
2750  break;
2751 
2753  S = new (Context) ObjCStringLiteral(Empty);
2754  break;
2755 
2757  S = new (Context) ObjCBoxedExpr(Empty);
2758  break;
2759 
2761  S = ObjCArrayLiteral::CreateEmpty(Context,
2762  Record[ASTStmtReader::NumExprFields]);
2763  break;
2764 
2767  Record[ASTStmtReader::NumExprFields],
2768  Record[ASTStmtReader::NumExprFields + 1]);
2769  break;
2770 
2771  case EXPR_OBJC_ENCODE:
2772  S = new (Context) ObjCEncodeExpr(Empty);
2773  break;
2774 
2776  S = new (Context) ObjCSelectorExpr(Empty);
2777  break;
2778 
2780  S = new (Context) ObjCProtocolExpr(Empty);
2781  break;
2782 
2784  S = new (Context) ObjCIvarRefExpr(Empty);
2785  break;
2786 
2788  S = new (Context) ObjCPropertyRefExpr(Empty);
2789  break;
2790 
2792  S = new (Context) ObjCSubscriptRefExpr(Empty);
2793  break;
2794 
2796  llvm_unreachable("mismatching AST file");
2797 
2799  S = ObjCMessageExpr::CreateEmpty(Context,
2800  Record[ASTStmtReader::NumExprFields],
2801  Record[ASTStmtReader::NumExprFields + 1]);
2802  break;
2803 
2804  case EXPR_OBJC_ISA:
2805  S = new (Context) ObjCIsaExpr(Empty);
2806  break;
2807 
2809  S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
2810  break;
2811 
2813  S = new (Context) ObjCBridgedCastExpr(Empty);
2814  break;
2815 
2817  S = new (Context) ObjCForCollectionStmt(Empty);
2818  break;
2819 
2820  case STMT_OBJC_CATCH:
2821  S = new (Context) ObjCAtCatchStmt(Empty);
2822  break;
2823 
2824  case STMT_OBJC_FINALLY:
2825  S = new (Context) ObjCAtFinallyStmt(Empty);
2826  break;
2827 
2828  case STMT_OBJC_AT_TRY:
2829  S = ObjCAtTryStmt::CreateEmpty(Context,
2830  Record[ASTStmtReader::NumStmtFields],
2831  Record[ASTStmtReader::NumStmtFields + 1]);
2832  break;
2833 
2835  S = new (Context) ObjCAtSynchronizedStmt(Empty);
2836  break;
2837 
2838  case STMT_OBJC_AT_THROW:
2839  S = new (Context) ObjCAtThrowStmt(Empty);
2840  break;
2841 
2843  S = new (Context) ObjCAutoreleasePoolStmt(Empty);
2844  break;
2845 
2847  S = new (Context) ObjCBoolLiteralExpr(Empty);
2848  break;
2849 
2851  S = new (Context) ObjCAvailabilityCheckExpr(Empty);
2852  break;
2853 
2854  case STMT_SEH_LEAVE:
2855  S = new (Context) SEHLeaveStmt(Empty);
2856  break;
2857 
2858  case STMT_SEH_EXCEPT:
2859  S = new (Context) SEHExceptStmt(Empty);
2860  break;
2861 
2862  case STMT_SEH_FINALLY:
2863  S = new (Context) SEHFinallyStmt(Empty);
2864  break;
2865 
2866  case STMT_SEH_TRY:
2867  S = new (Context) SEHTryStmt(Empty);
2868  break;
2869 
2870  case STMT_CXX_CATCH:
2871  S = new (Context) CXXCatchStmt(Empty);
2872  break;
2873 
2874  case STMT_CXX_TRY:
2875  S = CXXTryStmt::Create(Context, Empty,
2876  /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
2877  break;
2878 
2879  case STMT_CXX_FOR_RANGE:
2880  S = new (Context) CXXForRangeStmt(Empty);
2881  break;
2882 
2884  S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
2887  nullptr);
2888  break;
2889 
2891  S =
2893  Record[ASTStmtReader::NumStmtFields],
2894  Empty);
2895  break;
2896 
2897  case STMT_OMP_SIMD_DIRECTIVE: {
2898  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2899  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2900  S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
2901  CollapsedNum, Empty);
2902  break;
2903  }
2904 
2905  case STMT_OMP_FOR_DIRECTIVE: {
2906  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2907  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2908  S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
2909  Empty);
2910  break;
2911  }
2912 
2914  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2915  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2916  S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
2917  Empty);
2918  break;
2919  }
2920 
2923  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2924  break;
2925 
2927  S = OMPSectionDirective::CreateEmpty(Context, Empty);
2928  break;
2929 
2932  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2933  break;
2934 
2936  S = OMPMasterDirective::CreateEmpty(Context, Empty);
2937  break;
2938 
2941  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2942  break;
2943 
2945  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2946  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2947  S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
2948  CollapsedNum, Empty);
2949  break;
2950  }
2951 
2953  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
2954  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
2955  S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
2956  CollapsedNum, Empty);
2957  break;
2958  }
2959 
2962  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2963  break;
2964 
2967  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2968  break;
2969 
2971  S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
2972  break;
2973 
2975  S = OMPBarrierDirective::CreateEmpty(Context, Empty);
2976  break;
2977 
2979  S = OMPTaskwaitDirective::CreateEmpty(Context, Empty);
2980  break;
2981 
2984  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2985  break;
2986 
2989  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2990  break;
2991 
2994  Context, Record[ASTStmtReader::NumStmtFields], Empty);
2995  break;
2996 
2999  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3000  break;
3001 
3004  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3005  break;
3006 
3009  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3010  break;
3011 
3014  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3015  break;
3016 
3019  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3020  break;
3021 
3024  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3025  break;
3026 
3028  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3029  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3030  S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3031  CollapsedNum, Empty);
3032  break;
3033  }
3034 
3037  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3038  break;
3039 
3042  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3043  break;
3044 
3046  S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3047  break;
3048 
3051  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3052  break;
3053 
3055  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3056  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3057  S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3058  Empty);
3059  break;
3060  }
3061 
3063  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3064  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3065  S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3066  CollapsedNum, Empty);
3067  break;
3068  }
3069 
3071  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3072  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3073  S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3074  Empty);
3075  break;
3076  }
3077 
3079  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3080  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3081  S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3082  CollapsedNum, Empty);
3083  break;
3084  }
3085 
3087  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3088  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3090  CollapsedNum,
3091  Empty);
3092  break;
3093  }
3094 
3096  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3097  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3098  S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3099  CollapsedNum, Empty);
3100  break;
3101  }
3102 
3104  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3105  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3106  S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3107  CollapsedNum, Empty);
3108  break;
3109  }
3110 
3112  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3113  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3114  S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3115  Empty);
3116  break;
3117  }
3118 
3120  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3121  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3122  S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3123  CollapsedNum, Empty);
3124  break;
3125  }
3126 
3128  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3129  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3130  S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3131  CollapsedNum, Empty);
3132  break;
3133  }
3134 
3136  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3137  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3139  Context, NumClauses, CollapsedNum, Empty);
3140  break;
3141  }
3142 
3144  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3145  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3147  Context, NumClauses, CollapsedNum, Empty);
3148  break;
3149  }
3150 
3153  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3154  break;
3155 
3157  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3158  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3159  S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3160  CollapsedNum, Empty);
3161  break;
3162  }
3163 
3165  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3166  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3168  Context, NumClauses, CollapsedNum, Empty);
3169  break;
3170  }
3171 
3173  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3174  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3176  Context, NumClauses, CollapsedNum, Empty);
3177  break;
3178  }
3179 
3181  auto NumClauses = Record[ASTStmtReader::NumStmtFields];
3182  auto CollapsedNum = Record[ASTStmtReader::NumStmtFields + 1];
3184  Context, NumClauses, CollapsedNum, Empty);
3185  break;
3186  }
3187 
3190  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3191  break;
3192 
3193  case EXPR_CXX_MEMBER_CALL:
3195  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3196  break;
3197 
3198  case EXPR_CXX_CONSTRUCT:
3200  Context,
3201  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3202  break;
3203 
3205  S = new (Context) CXXInheritedCtorInitExpr(Empty);
3206  break;
3207 
3210  Context,
3211  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3212  break;
3213 
3214  case EXPR_CXX_STATIC_CAST:
3215  S = CXXStaticCastExpr::CreateEmpty(Context,
3216  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3217  break;
3218 
3219  case EXPR_CXX_DYNAMIC_CAST:
3220  S = CXXDynamicCastExpr::CreateEmpty(Context,
3221  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3222  break;
3223 
3226  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3227  break;
3228 
3229  case EXPR_CXX_CONST_CAST:
3230  S = CXXConstCastExpr::CreateEmpty(Context);
3231  break;
3232 
3235  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3236  break;
3237 
3240  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3241  break;
3242 
3244  S = new (Context) CXXStdInitializerListExpr(Empty);
3245  break;
3246 
3247  case EXPR_CXX_BOOL_LITERAL:
3248  S = new (Context) CXXBoolLiteralExpr(Empty);
3249  break;
3250 
3252  S = new (Context) CXXNullPtrLiteralExpr(Empty);
3253  break;
3254 
3255  case EXPR_CXX_TYPEID_EXPR:
3256  S = new (Context) CXXTypeidExpr(Empty, true);
3257  break;
3258 
3259  case EXPR_CXX_TYPEID_TYPE:
3260  S = new (Context) CXXTypeidExpr(Empty, false);
3261  break;
3262 
3263  case EXPR_CXX_UUIDOF_EXPR:
3264  S = new (Context) CXXUuidofExpr(Empty, true);
3265  break;
3266 
3268  S = new (Context) MSPropertyRefExpr(Empty);
3269  break;
3270 
3272  S = new (Context) MSPropertySubscriptExpr(Empty);
3273  break;
3274 
3275  case EXPR_CXX_UUIDOF_TYPE:
3276  S = new (Context) CXXUuidofExpr(Empty, false);
3277  break;
3278 
3279  case EXPR_CXX_THIS:
3280  S = new (Context) CXXThisExpr(Empty);
3281  break;
3282 
3283  case EXPR_CXX_THROW:
3284  S = new (Context) CXXThrowExpr(Empty);
3285  break;
3286 
3287  case EXPR_CXX_DEFAULT_ARG:
3288  S = new (Context) CXXDefaultArgExpr(Empty);
3289  break;
3290 
3291  case EXPR_CXX_DEFAULT_INIT:
3292  S = new (Context) CXXDefaultInitExpr(Empty);
3293  break;
3294 
3296  S = new (Context) CXXBindTemporaryExpr(Empty);
3297  break;
3298 
3300  S = new (Context) CXXScalarValueInitExpr(Empty);
3301  break;
3302 
3303  case EXPR_CXX_NEW:
3305  Context,
3306  /*IsArray=*/Record[ASTStmtReader::NumExprFields],
3307  /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
3308  /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
3309  /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
3310  break;
3311 
3312  case EXPR_CXX_DELETE:
3313  S = new (Context) CXXDeleteExpr(Empty);
3314  break;
3315 
3317  S = new (Context) CXXPseudoDestructorExpr(Empty);
3318  break;
3319 
3321  S = ExprWithCleanups::Create(Context, Empty,
3322  Record[ASTStmtReader::NumExprFields]);
3323  break;
3324 
3327  Context,
3328  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3329  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
3330  /*HasFirstQualifierFoundInScope=*/
3331  Record[ASTStmtReader::NumExprFields + 2]);
3332  break;
3333 
3336  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3337  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3338  ? Record[ASTStmtReader::NumExprFields + 1]
3339  : 0);
3340  break;
3341 
3344  /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3345  break;
3346 
3349  Context,
3350  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3351  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3352  /*NumTemplateArgs=*/
3353  Record[ASTStmtReader::NumExprFields + 1]
3354  ? Record[ASTStmtReader::NumExprFields + 2]
3355  : 0);
3356  break;
3357 
3360  Context,
3361  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3362  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3363  /*NumTemplateArgs=*/
3364  Record[ASTStmtReader::NumExprFields + 1]
3365  ? Record[ASTStmtReader::NumExprFields + 2]
3366  : 0);
3367  break;
3368 
3369  case EXPR_TYPE_TRAIT:
3371  Record[ASTStmtReader::NumExprFields]);
3372  break;
3373 
3374  case EXPR_ARRAY_TYPE_TRAIT:
3375  S = new (Context) ArrayTypeTraitExpr(Empty);
3376  break;
3377 
3379  S = new (Context) ExpressionTraitExpr(Empty);
3380  break;
3381 
3382  case EXPR_CXX_NOEXCEPT:
3383  S = new (Context) CXXNoexceptExpr(Empty);
3384  break;
3385 
3386  case EXPR_PACK_EXPANSION:
3387  S = new (Context) PackExpansionExpr(Empty);
3388  break;
3389 
3390  case EXPR_SIZEOF_PACK:
3392  Context,
3393  /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3394  break;
3395 
3397  S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3398  break;
3399 
3401  S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3402  break;
3403 
3406  Record[ASTStmtReader::NumExprFields]);
3407  break;
3408 
3410  S = new (Context) MaterializeTemporaryExpr(Empty);
3411  break;
3412 
3413  case EXPR_CXX_FOLD:
3414  S = new (Context) CXXFoldExpr(Empty);
3415  break;
3416 
3417  case EXPR_OPAQUE_VALUE:
3418  S = new (Context) OpaqueValueExpr(Empty);
3419  break;
3420 
3421  case EXPR_CUDA_KERNEL_CALL:
3423  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields], Empty);
3424  break;
3425 
3426  case EXPR_ASTYPE:
3427  S = new (Context) AsTypeExpr(Empty);
3428  break;
3429 
3430  case EXPR_PSEUDO_OBJECT: {
3431  unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3432  S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3433  break;
3434  }
3435 
3436  case EXPR_ATOMIC:
3437  S = new (Context) AtomicExpr(Empty);
3438  break;
3439 
3440  case EXPR_LAMBDA: {
3441  unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3442  S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3443  break;
3444  }
3445 
3446  case STMT_COROUTINE_BODY: {
3447  unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
3448  S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
3449  break;
3450  }
3451 
3452  case STMT_CORETURN:
3453  S = new (Context) CoreturnStmt(Empty);
3454  break;
3455 
3456  case EXPR_COAWAIT:
3457  S = new (Context) CoawaitExpr(Empty);
3458  break;
3459 
3460  case EXPR_COYIELD:
3461  S = new (Context) CoyieldExpr(Empty);
3462  break;
3463 
3465  S = new (Context) DependentCoawaitExpr(Empty);
3466  break;
3467  }
3468 
3469  // We hit a STMT_STOP, so we're done with this expression.
3470  if (Finished)
3471  break;
3472 
3473  ++NumStatementsRead;
3474 
3475  if (S && !IsStmtReference) {
3476  Reader.Visit(S);
3477  StmtEntries[Cursor.GetCurrentBitNo()] = S;
3478  }
3479 
3480  assert(Record.getIdx() == Record.size() &&
3481  "Invalid deserialization of statement");
3482  StmtStack.push_back(S);
3483  }
3484 Done:
3485  assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3486  assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3487  return StmtStack.pop_back_val();
3488 }
void setPreInits(Stmt *PreInits)
Definition: StmtOpenMP.h:603
void setCombinedParForInDistCond(Expr *CombParForInDistCond)
Definition: StmtOpenMP.h:722
static AttributedStmt * CreateEmpty(const ASTContext &C, unsigned NumAttrs)
Definition: Stmt.cpp:364
void setFPFeatures(FPOptions F)
Definition: Expr.h:3582
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
A PredefinedExpr record.
Definition: ASTBitCodes.h:1640
void setCond(Expr *Cond)
Definition: Stmt.h:2257
const uint64_t & readInt()
Returns the current value in this record, and advances to the next value.
Definition: ASTReader.h:2406
A call to an overloaded operator written using operator syntax.
Definition: ExprCXX.h:77
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1577
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1107
Represents a single C99 designator.
Definition: Expr.h:4686
void setConditionVariable(const ASTContext &C, VarDecl *V)
Definition: Stmt.cpp:932
static DependentScopeDeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:494
void setValueDependent(bool VD)
Set whether this expression is value-dependent or not.
Definition: Expr.h:161
Defines the clang::ASTContext interface.
void setIsOMPStructuredBlock(bool IsOMPStructuredBlock)
Definition: Stmt.h:1094
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:1631
A CompoundLiteralExpr record.
Definition: ASTBitCodes.h:1700
This represents &#39;#pragma omp distribute simd&#39; composite directive.
Definition: StmtOpenMP.h:3393
This represents &#39;#pragma omp master&#39; directive.
Definition: StmtOpenMP.h:1576
ConstantExprBitfields ConstantExprBits
Definition: Stmt.h:960
DesignatorTypes
The kinds of designators that can occur in a DesignatedInitExpr.
Definition: ASTBitCodes.h:1996
void setRangeStmt(Stmt *S)
Definition: StmtCXX.h:193
SourceLocation readSourceLocation()
Read a source location, advancing Idx.
Definition: ASTReader.h:2611
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:592
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:2853
This represents &#39;#pragma omp task&#39; directive.
Definition: StmtOpenMP.h:1916
void setEnsureUpperBound(Expr *EUB)
Definition: StmtOpenMP.h:634
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:2852
static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Create an empty C++ construction expression.
Definition: ExprCXX.cpp:1009
Represents a &#39;co_await&#39; expression while the type of the promise is dependent.
Definition: ExprCXX.h:4647
void setSubStmt(CompoundStmt *S)
Definition: Expr.h:3944
The receiver is an object instance.
Definition: ExprObjC.h:1101
unsigned getNumInputs() const
Definition: Stmt.h:2764
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:349
UnresolvedMemberExprBitfields UnresolvedMemberExprBits
Definition: Stmt.h:998
An IndirectGotoStmt record.
Definition: ASTBitCodes.h:1613
A (possibly-)qualified type.
Definition: Type.h:643
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument.
Definition: Stmt.h:3524
StringKind getKind() const
Definition: Expr.h:1801
An AddrLabelExpr record.
Definition: ASTBitCodes.h:1730
void setInc(Expr *E)
Definition: StmtCXX.h:197
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2415
CXXDeleteExprBitfields CXXDeleteExprBits
Definition: Stmt.h:989
void setNRVOCandidate(const VarDecl *Var)
Set the variable that might be used for the named return value optimization.
Definition: Stmt.h:2660
Defines enumerations for the type traits support.
void setLocation(SourceLocation L)
Definition: ExprCXX.h:573
A CXXStaticCastExpr record.
Definition: ASTBitCodes.h:1855
ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
void setCombinedCond(Expr *CombCond)
Definition: StmtOpenMP.h:702
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2533
An AttributedStmt record.
Definition: ASTBitCodes.h:1592
A CXXReinterpretCastExpr record.
Definition: ASTBitCodes.h:1861
An ObjCBoolLiteralExpr record.
Definition: ASTBitCodes.h:1823
void setCombinedLowerBoundVariable(Expr *CombLB)
Definition: StmtOpenMP.h:682
void setRHS(Expr *E)
Definition: Expr.h:2478
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:571
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:767
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1503
Represents a &#39;co_return&#39; statement in the C++ Coroutines TS.
Definition: StmtCXX.h:456
Stmt - This represents one statement.
Definition: Stmt.h:66
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:592
void setLastIteration(Expr *LI)
Definition: StmtOpenMP.h:589
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2664
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1812
void setPrivateCounters(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:50
void setArrow(bool A)
Definition: ExprObjC.h:1521
C Language Family Type Representation.
unsigned getNumOutputs() const
Definition: Stmt.h:2742
This represents &#39;#pragma omp for simd&#39; directive.
Definition: StmtOpenMP.h:1326
void setOpcode(Opcode Opc)
Definition: Expr.h:3447
void setRParenLoc(SourceLocation L)
Definition: Stmt.h:2876
void setContinueLoc(SourceLocation L)
Definition: Stmt.h:2553
void setThrowExpr(Stmt *S)
Definition: StmtObjC.h:346
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:472
An ImplicitValueInitExpr record.
Definition: ASTBitCodes.h:1724
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
void setDeclGroup(DeclGroupRef DGR)
Definition: Stmt.h:1223
An ImplicitCastExpr record.
Definition: ASTBitCodes.h:1694
This represents &#39;#pragma omp teams distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3804
void setRBracket(SourceLocation RB)
Definition: ExprObjC.h:882
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:5054
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
Definition: Lambda.h:22
void setType(QualType t)
Definition: Expr.h:138
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:2943
Defines the C++ template declaration subclasses.
void setPrevEnsureUpperBound(Expr *PrevEUB)
Definition: StmtOpenMP.h:677
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:4861
Represents an attribute applied to a statement.
Definition: Stmt.h:1754
void setUpperBoundVariable(Expr *UB)
Definition: StmtOpenMP.h:620
void setComputationResultType(QualType T)
Definition: Expr.h:3656
llvm::APFloat readAPFloat(const llvm::fltSemantics &Sem)
Read a floating-point value, advancing Idx.
Definition: ASTReader.h:2633
void setNumIterations(Expr *NI)
Definition: StmtOpenMP.h:655
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1969
A CXXOperatorCallExpr record.
Definition: ASTBitCodes.h:1840
void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper)
Definition: ExprObjC.h:1343
This represents &#39;#pragma omp target teams distribute&#39; combined directive.
Definition: StmtOpenMP.h:3941
A CXXTemporaryObjectExpr record.
Definition: ASTBitCodes.h:1852
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:332
void setNextLowerBound(Expr *NLB)
Definition: StmtOpenMP.h:641
DeclRefExprBitfields DeclRefExprBits
Definition: Stmt.h:962
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1331
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:845
void setADLCallKind(ADLCallKind V=UsesADL)
Definition: Expr.h:2645
unsigned NumOutputs
Definition: Stmt.h:2707
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent...
Definition: ExprCXX.h:2621
void setValue(bool V)
Definition: ExprObjC.h:98
A constant expression context.
Definition: ASTBitCodes.h:1637
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:703
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:113
A container of type source information.
Definition: Decl.h:86
void setSwitchCaseList(SwitchCase *SC)
Definition: Stmt.h:2148
Stmt * SubExpr
Definition: Expr.h:927
void setCanOverflow(bool C)
Definition: Expr.h:2065
void setInstanceReceiver(Expr *rec)
Turn this message send into an instance message that computes the receiver object with the given expr...
Definition: ExprObjC.h:1272
Floating point control options.
Definition: LangOptions.h:323
This represents &#39;#pragma omp parallel for&#39; directive.
Definition: StmtOpenMP.h:1697
MS property subscript expression.
Definition: ExprCXX.h:846
void setStartLoc(SourceLocation L)
Definition: Stmt.h:1225
void setForLoc(SourceLocation L)
Definition: Stmt.h:2431
This represents &#39;#pragma omp target teams distribute parallel for&#39; combined directive.
Definition: StmtOpenMP.h:4009
static ObjCDictionaryLiteral * CreateEmpty(const ASTContext &C, unsigned NumElements, bool HasPackExpansions)
Definition: ExprObjC.cpp:104
Represents a prvalue temporary that is written into memory so that a reference can bind to it...
Definition: ExprCXX.h:4325
void setLocation(SourceLocation L)
Definition: ExprObjC.h:590
void setDependentInits(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:82
void setDelegateInitCall(bool isDelegate)
Definition: ExprObjC.h:1414
void setProtocol(ObjCProtocolDecl *P)
Definition: ExprObjC.h:520
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:3345
void setIsLastIterVariable(Expr *IL)
Definition: StmtOpenMP.h:606
This represents &#39;#pragma omp target exit data&#39; directive.
Definition: StmtOpenMP.h:2608
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:574
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
Definition: Expr.cpp:1560
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Represents a variable declaration or definition.
Definition: Decl.h:812
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:109
bool hasTemplateKWAndArgsInfo() const
Definition: Expr.h:1269
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1492
void setIsPartOfExplicitCast(bool PartOfExplicitCast)
Definition: Expr.h:3269
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3052
void setSubExpr(unsigned Idx, Expr *E)
Definition: Expr.h:4868
void setInitializer(Expr *E)
Definition: Expr.h:3080
void setLength(Expr *E)
Set length of the array section.
Definition: ExprOpenMP.h:101
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:1529
void recordSwitchCaseID(SwitchCase *SC, unsigned ID)
Definition: ASTReader.h:2667
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2582
static FunctionParmPackExpr * CreateEmpty(const ASTContext &Context, unsigned NumParams)
Definition: ExprCXX.cpp:1572
void setAsmLoc(SourceLocation L)
Definition: Stmt.h:2724
AttributedStmtBitfields AttributedStmtBits
Definition: Stmt.h:946
QualType readType()
Read a type from the current position in the record.
Definition: ASTReader.h:2510
static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)
Create an empty PredefinedExpr.
Definition: Expr.cpp:639
void setCombinedDistCond(Expr *CombDistCond)
Definition: StmtOpenMP.h:717
void setValue(unsigned Val)
Definition: Expr.h:1543
void setLocation(SourceLocation Location)
Definition: Expr.h:1488
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:603
Implicit construction of a std::initializer_list<T> object from an array temporary within list-initia...
Definition: ExprCXX.h:624
static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Construct an empty declaration reference expression.
Definition: Expr.cpp:583
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2142
void setGNUSyntax(bool GNU)
Definition: Expr.h:4846
Defines the Objective-C statement AST node classes.
A CXXConstructExpr record.
Definition: ASTBitCodes.h:1846
unsigned getNumExpressions() const
Definition: Expr.h:2320
void setBeginStmt(Stmt *S)
Definition: StmtCXX.h:194
void setBase(Expr *E)
Set base of the array section.
Definition: ExprOpenMP.h:84
ReceiverKind
The kind of receiver this message is sending to.
Definition: ExprObjC.h:1096
raw_arg_iterator raw_arg_begin()
Definition: ExprCXX.h:2234
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1049
Represents an expression – generally a full-expression – that introduces cleanups to be run at the ...
Definition: ExprCXX.h:3212
void setInit(Expr *Init)
Definition: StmtOpenMP.h:601
Defines the clang::Expr interface and subclasses for C++ expressions.
void setThen(Stmt *Then)
Definition: Stmt.h:1904
void setTarget(Expr *E)
Definition: Stmt.h:2518
A ShuffleVectorExpr record.
Definition: ASTBitCodes.h:1745
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:318
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:1710
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:887
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:67
Represents a C99 designated initializer expression.
Definition: Expr.h:4611
An OffsetOfExpr record.
Definition: ASTBitCodes.h:1670
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
NestedNameSpecifierLoc readNestedNameSpecifierLoc()
Definition: ASTReader.h:2565
static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
One of these records is kept for each identifier that is lexed.
An ObjCAtThrowStmt record.
Definition: ASTBitCodes.h:1817
T * readDeclAs()
Reads a declaration from the given position in the record, advancing Idx.
Definition: ASTReader.h:2533
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:742
Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(), or __builtin_FILE().
Definition: Expr.h:4267
A DesignatedInitExpr record.
Definition: ASTBitCodes.h:1709
This represents &#39;#pragma omp parallel&#39; directive.
Definition: StmtOpenMP.h:356
ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.
Definition: Expr.h:3971
void setExprOperand(Expr *E)
Definition: ExprCXX.h:960
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:160
A C++ nested-name-specifier augmented with source location information.
void setLHS(Expr *E)
Definition: Expr.h:2474
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Internal struct for storing Key/value pair.
Definition: ExprObjC.h:284
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
void setKeyExpr(Stmt *S)
Definition: ExprObjC.h:894
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:818
static ObjCMessageExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs, unsigned NumStoredSelLocs)
Create an empty Objective-C message expression, to be filled in by subsequent calls.
Definition: ExprObjC.cpp:263
void setIsMicrosoftABI(bool IsMS)
Definition: Expr.h:4240
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:4909
static OMPFlushDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:660
GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...
Definition: Expr.h:4182
void setArg(unsigned I, Expr *E)
Definition: ExprCXX.h:3381
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: Expr.h:2687
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:31
void setRParen(SourceLocation Loc)
Definition: Expr.h:1998
TemplateArgument readTemplateArgument(bool Canonicalize=false)
Read a template argument, advancing Idx.
Definition: ASTReader.h:2575
This represents &#39;#pragma omp target simd&#39; directive.
Definition: StmtOpenMP.h:3529
void setCapturedDecl(CapturedDecl *D)
Set the outlined function declaration.
Definition: Stmt.cpp:1300
void setReturnLoc(SourceLocation L)
Definition: Stmt.h:2667
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3677
Defines some OpenMP-specific enums and functions.
void setCond(Expr *Cond)
Definition: Stmt.h:2085
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5490
OpenMPDirectiveKind getDirectiveKind() const
Definition: StmtOpenMP.h:300
void setIfLoc(SourceLocation IfLoc)
Definition: Stmt.h:1972
This represents &#39;#pragma omp barrier&#39; directive.
Definition: StmtOpenMP.h:2028
void setComponent(unsigned Idx, OffsetOfNode ON)
Definition: Expr.h:2296
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp, [NSNumber numberWithInt:42]];.
Definition: ExprObjC.h:188
TypeSourceInfo * getTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
Definition: ASTReader.h:2495
unsigned getCharByteWidth() const
Definition: Expr.h:1799
This is a common base class for loop directives (&#39;omp simd&#39;, &#39;omp for&#39;, &#39;omp for simd&#39; etc...
Definition: StmtOpenMP.h:418
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:4175
void setSubStmt(Stmt *S)
Definition: Stmt.h:1602
This represents &#39;#pragma omp critical&#39; directive.
Definition: StmtOpenMP.h:1623
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:371
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3952
void setCond(Expr *Cond)
Definition: StmtOpenMP.h:598
size_t size() const
The length of this record.
Definition: ASTReader.h:2396
void setSubExpr(Expr *E)
As with any mutator of the AST, be very careful when modifying an existing AST to preserve its invari...
Definition: Expr.h:943
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:77
void setLBraceLoc(SourceLocation Loc)
Definition: Expr.h:4523
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:961
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:2494
Describes an C or C++ initializer list.
Definition: Expr.h:4375
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:673
This represents &#39;#pragma omp distribute parallel for&#39; composite directive.
Definition: StmtOpenMP.h:3244
void setValue(const ASTContext &C, const llvm::APInt &Val)
Definition: Expr.h:1406
This represents &#39;#pragma omp teams distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3733
void setBuiltinLoc(SourceLocation L)
Definition: Expr.h:3990
BinaryOperatorKind
void setSubExpr(Expr *E)
Definition: Expr.h:1987
void setLHS(Expr *E)
Definition: Expr.h:4150
unsigned getLength() const
Definition: Expr.h:1798
ForStmt - This represents a &#39;for (init;cond;inc)&#39; stmt.
Definition: Stmt.h:2384
void setOperatorNew(FunctionDecl *D)
Definition: ExprCXX.h:2125
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
void setLocation(SourceLocation L)
Definition: ExprCXX.h:607
CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits
Definition: Stmt.h:987
static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setSynchBody(Stmt *S)
Definition: StmtObjC.h:303
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void setSelector(Selector S)
Definition: ExprObjC.h:468
A reference to a previously [de]serialized Stmt record.
Definition: ASTBitCodes.h:1574
void setEndLoc(SourceLocation L)
Definition: Stmt.h:1227
capture_init_iterator capture_init_begin()
Retrieve the first initialization argument for this lambda expression (which initializes the first ca...
Definition: ExprCXX.h:1872
path_iterator path_begin()
Definition: Expr.h:3197
void setLocation(SourceLocation L)
Definition: ExprObjC.h:104
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
Definition: ExprCXX.h:3619
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3409
static OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setAccessor(IdentifierInfo *II)
Definition: Expr.h:5513
CXXForRangeStmt - This represents C++0x [stmt.ranged]&#39;s ranged for statement, represented as &#39;for (ra...
Definition: StmtCXX.h:134
llvm::Error Error
SourceRange readSourceRange()
Read a source range, advancing Idx.
Definition: ASTReader.h:2616
static const unsigned NumStmtFields
The number of record fields required for the Stmt class itself.
This represents &#39;#pragma omp cancellation point&#39; directive.
Definition: StmtOpenMP.h:2863
void setString(StringLiteral *S)
Definition: ExprObjC.h:64
void setAsmString(StringLiteral *E)
Definition: Stmt.h:2882
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:50
CaseStmt - Represent a case statement.
Definition: Stmt.h:1478
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:5936
void setCombinedInit(Expr *CombInit)
Definition: StmtOpenMP.h:697
void setLHS(Expr *Val)
Definition: Stmt.h:1575
This represents &#39;#pragma omp teams&#39; directive.
Definition: StmtOpenMP.h:2806
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2278
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3125
Helper class for OffsetOfExpr.
Definition: Expr.h:2138
A marker record that indicates that we are at the end of an expression.
Definition: ASTBitCodes.h:1568
void setInit(Stmt *Init)
Definition: Stmt.h:2108
This represents &#39;#pragma omp teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:3663
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1282
void setDestroyedType(IdentifierInfo *II, SourceLocation Loc)
Set the name of destroyed type for a dependent pseudo-destructor expression.
Definition: ExprCXX.h:2499
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:90
const llvm::fltSemantics & getSemantics() const
Return the APFloat semantics this literal uses.
Definition: Expr.h:1594
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:1727
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:543
void setCond(Expr *E)
Definition: Stmt.h:2426
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:925
void setOpcode(Opcode Opc)
Definition: Expr.h:2049
void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, TemplateArgumentLoc *ArgsLocArray, unsigned NumTemplateArgs)
Read and initialize a ExplicitTemplateArgumentList structure.
DeclAccessPair * getTrailingResults()
Return the results. Defined after UnresolvedMemberExpr.
Definition: ExprCXX.h:3831
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3417
void setRParenLoc(SourceLocation Loc)
Definition: StmtObjC.h:55
CXXBaseSpecifier readCXXBaseSpecifier()
Read a C++ base specifier, advancing Idx.
Definition: ASTReader.h:2597
void setRParenLoc(SourceLocation R)
Definition: Expr.h:2282
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1111
bool isTypeOperand() const
Definition: ExprCXX.h:938
const uint64_t & peekInt()
Returns the current value in this record, without advancing.
Definition: ASTReader.h:2409
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:971
unsigned NumClobbers
Definition: Stmt.h:2709
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3376
Represents the this expression in C++.
Definition: ExprCXX.h:1006
void setCastKind(CastKind K)
Definition: Expr.h:3172
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:650
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:842
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
PredefinedExprBitfields PredefinedExprBits
Definition: Stmt.h:961
void setEqualOrColonLoc(SourceLocation L)
Definition: Expr.h:4837
This represents &#39;#pragma omp target parallel for simd&#39; directive.
Definition: StmtOpenMP.h:3461
void setDependentCounters(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:75
void setArgument(Expr *E)
Definition: Expr.h:2399
OpenMP 4.0 [2.4, Array Sections].
Definition: ExprOpenMP.h:44
void setTypeSourceInfo(TypeSourceInfo *tsi)
Definition: Expr.h:2287
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3707
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2385
void setAmpAmpLoc(SourceLocation L)
Definition: Expr.h:3897
void setBreakLoc(SourceLocation L)
Definition: Stmt.h:2583
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
Definition: ExprCXX.h:3837
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1310
void setBlockDecl(BlockDecl *BD)
Definition: Expr.h:5567
This represents &#39;#pragma omp taskgroup&#39; directive.
Definition: StmtOpenMP.h:2116
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:328
CastKind
CastKind - The kind of operation required for a conversion.
void setSemiLoc(SourceLocation L)
Definition: Stmt.h:1287
void setSubExpr(Expr *E)
Definition: Expr.h:2052
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2347
void setLParen(SourceLocation Loc)
Definition: Expr.h:1994
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:953
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4216
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:911
void setLeaveLoc(SourceLocation L)
Definition: Stmt.h:3322
void setConditionVariable(const ASTContext &Ctx, VarDecl *V)
Set the condition variable for this if statement.
Definition: Stmt.cpp:893
This represents &#39;#pragma omp distribute&#39; directive.
Definition: StmtOpenMP.h:3117
SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits
Definition: Stmt.h:1000
void setInits(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:57
void setOperatorDelete(FunctionDecl *D)
Definition: ExprCXX.h:2127
void setRParenLoc(SourceLocation L)
Definition: Stmt.h:2362
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type...
Definition: ExprCXX.h:1958
void setLocation(SourceLocation Location)
Definition: Expr.h:1541
void setRParenLoc(SourceLocation Loc)
Definition: StmtObjC.h:108
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3923
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:151
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:636
This represents one expression.
Definition: Expr.h:108
Defines the clang::LangOptions interface.
void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)
Definition: Expr.cpp:4316
void setRBraceLoc(SourceLocation Loc)
Definition: Expr.h:4525
void setInit(Stmt *Init)
Definition: Stmt.h:1965
void setIsImplicit(bool value=true)
Definition: ExprCXX.h:4638
SourceLocation End
void setWhileLoc(SourceLocation L)
Definition: Stmt.h:2302
void setCallee(Expr *F)
Definition: Expr.h:2640
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3993
void setLParenLoc(SourceLocation L)
Definition: Stmt.h:2433
void setBase(Expr *Base)
Definition: Expr.h:4965
Stmt * ReadStmt(ModuleFile &F)
Reads a statement.
static CXXMemberCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, EmptyShell Empty)
Definition: ExprCXX.cpp:631
void setSyntacticForm(InitListExpr *Init)
Definition: Expr.h:4538
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1659
static ReturnStmt * CreateEmpty(const ASTContext &Ctx, bool HasNRVOCandidate)
Create an empty return statement, optionally with storage for an NRVO candidate.
Definition: Stmt.cpp:1094
void setRBracketLoc(SourceLocation L)
Definition: ExprOpenMP.h:112
A C++ const_cast expression (C++ [expr.const.cast]).
Definition: ExprCXX.h:436
void setTypeDependent(bool TD)
Set whether this expression is type-dependent or not.
Definition: Expr.h:179
void setTypeOperandSourceInfo(TypeSourceInfo *TSI)
Definition: ExprCXX.h:950
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5551
Field designator where only the field name is known.
Definition: ASTBitCodes.h:1998
static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Expected< unsigned > readRecord(llvm::BitstreamCursor &Cursor, unsigned AbbrevID)
Reads a record with id AbbrevID from Cursor, resetting the internal state.
Defines an enumeration for C++ overloaded operators.
This represents &#39;#pragma omp target teams distribute parallel for simd&#39; combined directive.
Definition: StmtOpenMP.h:4093
void setRHS(Expr *E)
Definition: Expr.h:3452
void setInc(Expr *E)
Definition: Stmt.h:2427
raw_arg_iterator raw_arg_end()
Definition: ExprCXX.h:2235
static CXXReinterpretCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Definition: ExprCXX.cpp:799
#define bool
Definition: stdbool.h:15
void setUuidStr(StringRef US)
Definition: ExprCXX.h:965
void setWrittenTypeInfo(TypeSourceInfo *TI)
Definition: Expr.h:4243
void setRetValue(Expr *E)
Definition: Stmt.h:2645
void setBody(Stmt *S)
Definition: Stmt.h:2428
unsigned getNumTemplateArgs() const
Definition: ExprCXX.h:2909
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:304
ExprBitfields ExprBits
Definition: Stmt.h:959
void setObjectKind(ExprObjectKind Cat)
setObjectKind - Set the object kind produced by this expression.
Definition: Expr.h:434
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier, e.g., N::foo.
Definition: Expr.h:1237
void setBody(Stmt *Body)
Definition: Stmt.h:2094
static UserDefinedLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, EmptyShell Empty)
Definition: ExprCXX.cpp:871
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:277
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:454
A CXXStdInitializerListExpr record.
Definition: ASTBitCodes.h:1873
void setFinallyBody(Stmt *S)
Definition: StmtObjC.h:141
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:3997
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:68
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:5600
An ArraySubscriptExpr record.
Definition: ASTBitCodes.h:1676
Decl * readDecl()
Reads a declaration from the given position in a record in the given module, advancing Idx...
Definition: ASTReader.h:2523
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:981
This represents &#39;#pragma omp target teams distribute simd&#39; combined directive.
Definition: StmtOpenMP.h:4166
CXXDefaultInitExprBitfields CXXDefaultInitExprBits
Definition: Stmt.h:986
Information about a module that has been loaded by the ASTReader.
Definition: Module.h:107
ExprWithCleanupsBitfields ExprWithCleanupsBits
Definition: Stmt.h:993
An ArrayInitLoopExpr record.
Definition: ASTBitCodes.h:1718
unsigned getNumClauses() const
Get number of clauses.
Definition: StmtOpenMP.h:240
A PseudoObjectExpr record.
Definition: ASTBitCodes.h:1757
void setColonLoc(SourceLocation L)
Definition: ExprOpenMP.h:109
void setFinallyStmt(Stmt *S)
Definition: StmtObjC.h:247
Extra data stored in some MemberExpr objects.
Definition: Expr.h:2799
CompoundStmtBitfields CompoundStmtBits
Definition: Stmt.h:944
An ObjCIndirectCopyRestoreExpr record.
Definition: ASTBitCodes.h:1799
This represents &#39;#pragma omp for&#39; directive.
Definition: StmtOpenMP.h:1249
IdentifierInfo * getIdentifierInfo()
Definition: ASTReader.h:2537
static OMPTargetEnterDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:865
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:431
StringLiteralBitfields StringLiteralBits
Definition: Stmt.h:964
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:526
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Definition: ExprCXX.h:2168
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4441
void setEndStmt(Stmt *S)
Definition: StmtCXX.h:195
ReturnStmt - This represents a return, optionally of an expression: return; return 4;...
Definition: Stmt.h:2610
This represents &#39;#pragma omp target teams&#39; directive.
Definition: StmtOpenMP.h:3882
void setAssociatedStmt(Stmt *S)
Set the associated statement for the directive.
Definition: StmtOpenMP.h:84
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:950
void setBody(Stmt *Body)
Definition: Stmt.h:2266
This represents a Microsoft inline-assembly statement extension.
Definition: Stmt.h:3075
void setColonLoc(SourceLocation L)
Definition: Stmt.h:1460
void setIsArrow(bool A)
Definition: ExprObjC.h:586
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4158
A DesignatedInitUpdateExpr record.
Definition: ASTBitCodes.h:1712
SourceLocation getEnd() const
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:424
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2021
bool isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a taskloop directive.
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1234
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:772
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:474
static UnresolvedLookupExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:359
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4115
void setForLoc(SourceLocation Loc)
Definition: StmtObjC.h:53
This represents &#39;#pragma omp cancel&#39; directive.
Definition: StmtOpenMP.h:2921
void setDistInc(Expr *DistInc)
Definition: StmtOpenMP.h:672
void setBase(Expr *base)
Definition: ExprObjC.h:582
ValueDecl * getDecl()
Definition: Expr.h:1222
An ObjCAvailabilityCheckExpr record.
Definition: ASTBitCodes.h:1826
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:473
std::string readString()
Read a string, advancing Idx.
Definition: ASTReader.h:2638
void setConditionVariable(const ASTContext &Ctx, VarDecl *V)
Set the condition variable of this while statement.
Definition: Stmt.cpp:1050
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
Definition: Expr.h:3346
static OMPDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setClauses(ArrayRef< OMPClause *> Clauses)
Sets the list of variables for this clause.
Definition: StmtOpenMP.cpp:19
void skipInts(unsigned N)
Skips the specified number of values.
Definition: ASTReader.h:2412
This file defines OpenMP AST classes for clauses.
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1...
Definition: Expr.h:1637
An ObjCForCollectionStmt record.
Definition: ASTBitCodes.h:1802
This represents &#39;#pragma omp flush&#39; directive.
Definition: StmtOpenMP.h:2189
This represents &#39;#pragma omp parallel for simd&#39; directive.
Definition: StmtOpenMP.h:1777
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4249
void setAtTryLoc(SourceLocation Loc)
Definition: StmtObjC.h:205
DoStmt - This represents a &#39;do/while&#39; stmt.
Definition: Stmt.h:2328
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
Definition: Stmt.h:2693
void setTypeOperandSourceInfo(TypeSourceInfo *TSI)
Definition: ExprCXX.h:725
void setBody(Stmt *S)
Definition: StmtCXX.h:199
A MS-style AsmStmt record.
Definition: ASTBitCodes.h:1634
void setConditionVariable(const ASTContext &Ctx, VarDecl *VD)
Set the condition variable in this switch statement.
Definition: Stmt.cpp:994
void setLocStart(SourceLocation Loc)
Set starting location of directive kind.
Definition: StmtOpenMP.h:232
OpaqueValueExprBitfields OpaqueValueExprBits
Definition: Stmt.h:1009
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:423
static CoroutineBodyStmt * Create(const ASTContext &C, CtorArgs const &Args)
Definition: StmtCXX.cpp:86
void setSynchExpr(Stmt *S)
Definition: StmtObjC.h:311
This represents &#39;#pragma omp target enter data&#39; directive.
Definition: StmtOpenMP.h:2549
void setUpdates(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:63
void setLowerBoundVariable(Expr *LB)
Definition: StmtOpenMP.h:613
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:1629
void setTypeSourceInfo(TypeSourceInfo *tinfo)
Definition: Expr.h:3091
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:354
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class...
Definition: Expr.h:1050
void setComputationLHSType(QualType T)
Definition: Expr.h:3653
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:4039
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver. ...
Definition: ExprObjC.h:1382
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:305
void setDecl(LabelDecl *D)
Definition: Stmt.h:1728
Kind
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr...
Definition: ExprCXX.h:2750
A field in a dependent type, known only by its name.
Definition: Expr.h:2147
This captures a statement into a function.
Definition: Stmt.h:3350
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1522
unsigned path_size() const
Definition: Expr.h:3196
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5673
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3373
void setSubStmt(Stmt *S)
Definition: Stmt.h:1647
void setAccessorLoc(SourceLocation L)
Definition: Expr.h:5516
void setGotoLoc(SourceLocation L)
Definition: Stmt.h:2509
static CXXDynamicCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Definition: ExprCXX.cpp:741
CXXTemporary * readCXXTemporary()
Definition: ASTReader.h:2606
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Definition: Expr.h:5141
void setLocation(SourceLocation L)
Definition: Expr.h:1231
This represents &#39;#pragma omp single&#39; directive.
Definition: StmtOpenMP.h:1521
Encodes a location in the source.
void setLocation(SourceLocation L)
Definition: Expr.h:1931
void setPrevLowerBoundVariable(Expr *PrevLB)
Definition: StmtOpenMP.h:662
void setIterationVariable(Expr *IV)
Definition: StmtOpenMP.h:586
Defines enumerations for expression traits intrinsics.
PseudoObjectExprBitfields PseudoObjectExprBits
Definition: Stmt.h:976
Stmt * readSubStmt()
Reads a sub-statement operand during statement reading.
Definition: ASTReader.h:2463
static CXXOperatorCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, EmptyShell Empty)
Definition: ExprCXX.cpp:573
UnresolvedLookupExprBitfields UnresolvedLookupExprBits
Definition: Stmt.h:997
unsigned getNumHandlers() const
Definition: StmtCXX.h:106
void setUpdater(Expr *Updater)
Definition: Expr.h:4970
CXXThrowExprBitfields CXXThrowExprBits
Definition: Stmt.h:984
static OMPTaskDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:525
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:32
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setDoLoc(SourceLocation L)
Definition: Stmt.h:2358
static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)
Definition: ExprCXX.cpp:813
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)"...
Definition: ExprCXX.h:2005
void setCombinedNextLowerBound(Expr *CombNLB)
Definition: StmtOpenMP.h:707
void setAtCatchLoc(SourceLocation Loc)
Definition: StmtObjC.h:106
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:358
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit...
Definition: ExprCXX.h:473
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:743
Represents a C++2a __builtin_bit_cast(T, v) expression.
Definition: ExprCXX.h:4724
static ObjCAtTryStmt * CreateEmpty(const ASTContext &Context, unsigned NumCatchStmts, bool HasFinally)
Definition: StmtObjC.cpp:57
void setConstexpr(bool C)
Definition: Stmt.h:1986
Represents a call to a member function that may be written either with member call syntax (e...
Definition: ExprCXX.h:170
static StringLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumConcatenated, unsigned Length, unsigned CharByteWidth)
Construct an empty string literal.
Definition: Expr.cpp:1092
void setIdentLoc(SourceLocation L)
Definition: Stmt.h:1725
GenericSelectionExprBitfields GenericSelectionExprBits
Definition: Stmt.h:975
Defines several types used to describe C++ lambda expressions that are shared between the parser and ...
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:1203
void setInit(Stmt *S)
Definition: StmtCXX.h:191
void setLabelLoc(SourceLocation L)
Definition: Expr.h:3899
void readDeclarationNameInfo(DeclarationNameInfo &NameInfo)
Definition: ASTReader.h:2553
A CXXFunctionalCastExpr record.
Definition: ASTBitCodes.h:1867
void setTemporary(CXXTemporary *T)
Definition: ExprCXX.h:1303
static ExprWithCleanups * Create(const ASTContext &C, EmptyShell empty, unsigned numObjects)
Definition: ExprCXX.cpp:1264
void setAllEnumCasesCovered()
Set a flag in the SwitchStmt indicating that if the &#39;switch (X)&#39; is a switch over an enum value then ...
Definition: Stmt.h:2167
Expr * readSubExpr()
Reads a sub-expression operand during statement reading.
Definition: ASTReader.h:2466
void VisitStmt(Stmt *S)
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:182
void setClassReceiver(TypeSourceInfo *TSInfo)
Definition: ExprObjC.h:1294
void setCatchParamDecl(VarDecl *D)
Definition: StmtObjC.h:103
An ObjCEncodeExpr record.
Definition: ASTBitCodes.h:1772
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:716
This represents &#39;#pragma omp taskwait&#39; directive.
Definition: StmtOpenMP.h:2072
void setLHS(Expr *E)
Definition: Expr.h:3450
void setIsFreeIvar(bool A)
Definition: ExprObjC.h:587
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>, and corresponding __opencl_atomic_* for OpenCL 2.0.
Definition: Expr.h:5807
void readDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name)
Definition: ASTReader.h:2550
void setFinalsConditions(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:88
Expr * updateInit(const ASTContext &C, unsigned Init, Expr *expr)
Updates the initializer at index Init with the new expression expr, and returns the old expression at...
Definition: Expr.cpp:2250
bool isArray() const
Definition: ExprCXX.h:2129
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:685
bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of the composite or combined directives that need loop ...
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:88
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:503
static WhileStmt * CreateEmpty(const ASTContext &Ctx, bool HasVar)
Create an empty while statement optionally with storage for a condition variable. ...
Definition: Stmt.cpp:1036
bool isValueDependent() const
isValueDependent - Determines whether this expression is value-dependent (C++ [temp.dep.constexpr]).
Definition: Expr.h:158
void setDecl(ValueDecl *NewD)
Definition: Expr.h:1224
void setThrowLoc(SourceLocation Loc)
Definition: StmtObjC.h:349
unsigned getIdx() const
The current position in this record.
Definition: ASTReader.h:2393
An ObjCIsa Expr record.
Definition: ASTBitCodes.h:1796
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTReader.h:2390
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3249
Stmt * getCapturedStmt()
Retrieve the statement being captured.
Definition: Stmt.h:3451
This represents &#39;#pragma omp target&#39; directive.
Definition: StmtOpenMP.h:2433
static OMPTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setSubExpr(Expr *E)
Definition: ExprCXX.h:1307
static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)
Definition: Expr.cpp:4309
static DeclGroup * Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.cpp:20
bool isParenTypeId() const
Definition: ExprCXX.h:2159
static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setBaseExpr(Stmt *S)
Definition: ExprObjC.h:891
NullStmtBitfields NullStmtBits
Definition: Stmt.h:943
An expression trait intrinsic.
Definition: ExprCXX.h:2691
void setEncodedTypeSourceInfo(TypeSourceInfo *EncType)
Definition: ExprObjC.h:432
static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)
Definition: ExprCXX.cpp:1385
An AtomicExpr record.
Definition: ASTBitCodes.h:1760
This represents &#39;#pragma omp ordered&#39; directive.
Definition: StmtOpenMP.h:2244
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:3926
void setCond(Expr *E)
Definition: StmtCXX.h:196
static SizeOfPackExpr * CreateDeserialized(ASTContext &Context, unsigned NumPartialArgs)
Definition: ExprCXX.cpp:1529
This represents &#39;#pragma omp target update&#39; directive.
Definition: StmtOpenMP.h:3185
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:124
MemberExprBitfields MemberExprBits
Definition: Stmt.h:970
void setSubExpr(Expr *E)
Definition: Expr.h:4236
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:573
void sawArrayRangeDesignator(bool ARD=true)
Definition: Expr.h:4548
static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Definition: ExprCXX.cpp:975
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:594
void setCapturedRecordDecl(RecordDecl *D)
Set the record declaration for captured variables.
Definition: Stmt.h:3471
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name...
Definition: StmtCXX.h:252
A placeholder type used to construct an empty shell of a type, that will be filled in later (e...
Definition: Stmt.h:1034
void setSimple(bool V)
Definition: Stmt.h:2727
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:3061
void setRBracketLoc(SourceLocation L)
Definition: ExprCXX.h:885
void readAttributes(AttrVec &Attrs)
Reads attributes from the current stream position, advancing Idx.
Definition: ASTReader.h:2658
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:3629
Expr ** getElements()
Retrieve elements of array of literals.
Definition: ExprObjC.h:219
Defines various enumerations that describe declaration and type specifiers.
A POD class for pairing a NamedDecl* with an access specifier.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
Represents a C11 generic selection.
Definition: Expr.h:5206
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:3882
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers...
Definition: ExprObjC.h:1638
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
Definition: ExprCXX.h:4243
Represents a template argument.
Definition: TemplateBase.h:50
void setGotoLoc(SourceLocation L)
Definition: Stmt.h:2472
void setPrevUpperBoundVariable(Expr *PrevUB)
Definition: StmtOpenMP.h:667
static CXXUnresolvedConstructExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs)
Definition: ExprCXX.cpp:1305
void setCombinedEnsureUpperBound(Expr *CombEUB)
Definition: StmtOpenMP.h:692
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:203
void setLocation(SourceLocation L)
Definition: Expr.h:1614
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:1275
void setCounters(ArrayRef< Expr *> A)
Definition: StmtOpenMP.cpp:44
bool isTypeOperand() const
Definition: ExprCXX.h:713
unsigned getNumAssocs() const
The number of association expressions.
Definition: Expr.h:5374
Dataflow Directional Tag Classes.
static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)
Create an empty generic selection expression for deserialization.
Definition: Expr.cpp:4211
void setExtendingDecl(const ValueDecl *ExtendedBy, unsigned ManglingNumber)
Definition: ExprCXX.cpp:1578
An InitListExpr record.
Definition: ASTBitCodes.h:1706
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLS_BLOCK block.
Definition: Module.h:405
void setBuiltinLoc(SourceLocation L)
Definition: Expr.h:4155
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1878
UnaryOperatorKind
void setValue(bool V)
Definition: ExprCXX.h:567
A CXXBoolLiteralExpr record.
Definition: ASTBitCodes.h:1876
Represents a delete expression for memory deallocation and destructor calls, e.g. ...
Definition: ExprCXX.h:2265
void setCombinedUpperBoundVariable(Expr *CombUB)
Definition: StmtOpenMP.h:687
void setRParenLoc(SourceLocation L)
Definition: Expr.h:2765
static CapturedStmt * CreateDeserialized(const ASTContext &Context, unsigned NumCaptures)
Definition: Stmt.cpp:1269
An ExtVectorElementExpr record.
Definition: ASTBitCodes.h:1703
void setLabel(LabelDecl *L)
Definition: Expr.h:3905
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
void setTypeInfoAsWritten(TypeSourceInfo *writtenTy)
Definition: Expr.h:3331
This represents &#39;#pragma omp section&#39; directive.
Definition: StmtOpenMP.h:1459
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:525
This represents &#39;#pragma omp teams distribute&#39; directive.
Definition: StmtOpenMP.h:3595
void setIsUnique(bool V)
Definition: Expr.h:1110
Selector readSelector()
Read a selector from the Record, advancing Idx.
Definition: ASTReader.h:2542
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
void setSubExpr(Expr *E)
Definition: Expr.h:1651
void setExprs(const ASTContext &C, ArrayRef< Expr *> Exprs)
Definition: Expr.cpp:4120
void setSubExpr(Expr *E)
Definition: Expr.h:3179
void setCollection(Expr *E)
Definition: StmtObjC.h:47
void setDecl(ObjCIvarDecl *d)
Definition: ExprObjC.h:578
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
void setFileScope(bool FS)
Definition: Expr.h:3083
void setExact(bool E)
Definition: Expr.h:1606
A runtime availability query.
Definition: ExprObjC.h:1699
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:396
This represents &#39;#pragma omp simd&#39; directive.
Definition: StmtOpenMP.h:1184
Represents a &#39;co_yield&#39; expression.
Definition: ExprCXX.h:4698
An ObjCAutoreleasePoolStmt record.
Definition: ASTBitCodes.h:1820
The name of a declaration.
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:3921
A CXXDynamicCastExpr record.
Definition: ASTBitCodes.h:1858
static LambdaExpr * CreateDeserialized(const ASTContext &C, unsigned NumCaptures)
Construct a new lambda expression that will be deserialized from an external source.
Definition: ExprCXX.cpp:1156
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr *> semantic, unsigned resultIndex)
Definition: Expr.cpp:4482
void setInstantiationDependent(bool ID)
Set whether this expression is instantiation-dependent or not.
Definition: Expr.h:205
void setEllipsisLoc(SourceLocation L)
Set the location of the ...
Definition: Stmt.h:1560
Kind
The kind of offsetof node we have.
Definition: Expr.h:2141
TemplateArgumentLoc readTemplateArgumentLoc()
Reads a TemplateArgumentLoc, advancing Idx.
Definition: ASTReader.h:2485
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3950
void setSelector(Selector S)
Definition: ExprObjC.h:1351
ExplicitCastExpr - An explicit cast written in the source code.
Definition: Expr.h:3312
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
void setMethodDecl(ObjCMethodDecl *MD)
Definition: ExprObjC.h:1370
This represents &#39;#pragma omp atomic&#39; directive.
Definition: StmtOpenMP.h:2299
static CompoundStmt * CreateEmpty(const ASTContext &C, unsigned NumStmts)
Definition: Stmt.cpp:325
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:339
void setImplicit(bool I)
Definition: ExprCXX.h:1028
An ObjCAtFinallyStmt record.
Definition: ASTBitCodes.h:1808
VersionTuple readVersionTuple()
Read a version tuple, advancing Idx.
Definition: ASTReader.h:2648
CXXNewExprBitfields CXXNewExprBits
Definition: Stmt.h:988
Represents a __leave statement.
Definition: Stmt.h:3311
unsigned getCollapsedNumber() const
Get number of collapsed loops.
Definition: StmtOpenMP.h:910
unsigned getNumSubExprs() const
Definition: Expr.h:5872
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2494
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:3864
SwitchStmt - This represents a &#39;switch&#39; stmt.
Definition: Stmt.h:2017
CXXConstructExprBitfields CXXConstructExprBits
Definition: Stmt.h:992
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:255
Represents the body of a coroutine.
Definition: StmtCXX.h:317
void setElement(Stmt *S)
Definition: StmtObjC.h:46
TemplateArgumentLoc * getTrailingTemplateArgumentLoc()
Return the optional template arguments.
Definition: ExprCXX.h:3847
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:449
bool isOpenMPDistributeDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a distribute directive.
static const unsigned NumExprFields
The number of record fields required for the Expr class itself.
void setCatchStmt(unsigned I, ObjCAtCatchStmt *S)
Set a particular catch statement.
Definition: StmtObjC.h:229
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2437
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:227
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:557
This file defines OpenMP AST classes for executable directives and clauses.
Represents Objective-C&#39;s collection statement.
Definition: StmtObjC.h:23
static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, EmptyShell Empty)
Definition: ExprCXX.cpp:1665
void setRHS(Expr *Val)
Definition: Stmt.h:1591
An ObjCAtSynchronizedStmt record.
Definition: ASTBitCodes.h:1814
unsigned getNumObjects() const
Definition: ExprCXX.h:3243
void setIndexExpr(unsigned Idx, Expr *E)
Definition: Expr.h:2315
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:407
void setVolatile(bool V)
Definition: Stmt.h:2730
void setLowerBound(Expr *E)
Set lower bound of the array section.
Definition: ExprOpenMP.h:95
An implicit indirection through a C++ base class, when the field found is in a base class...
Definition: Expr.h:2150
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:223
Represents a &#39;co_await&#39; expression.
Definition: ExprCXX.h:4611
TypeTraitExprBitfields TypeTraitExprBits
Definition: Stmt.h:990
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize)
Definition: Expr.cpp:2000
void setSwitchLoc(SourceLocation L)
Definition: Stmt.h:2151
A CXXMemberCallExpr record.
Definition: ASTBitCodes.h:1843
void setAtFinallyLoc(SourceLocation Loc)
Definition: StmtObjC.h:149
void setArg(unsigned Arg, Expr *ArgExpr)
Set the specified argument.
Definition: ExprCXX.h:1492
void setKind(UnaryExprOrTypeTrait K)
Definition: Expr.h:2381
void setRParenLoc(SourceLocation L)
Definition: Expr.h:2418
static ConstantExpr * CreateEmpty(const ASTContext &Context, ResultStorageKind StorageKind, EmptyShell Empty)
Definition: Expr.cpp:304
void setRHS(Expr *E)
Definition: Expr.h:4152
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:3442
void setBody(Stmt *Body)
Definition: Stmt.h:2355
void setValue(const ASTContext &C, const llvm::APFloat &Val)
Definition: Expr.h:1575
Represents Objective-C&#39;s @finally statement.
Definition: StmtObjC.h:127
void setCatchBody(Stmt *S)
Definition: StmtObjC.h:95
static CXXFunctionalCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize)
Definition: ExprCXX.cpp:833
bool hasAssociatedStmt() const
Returns true if directive has associated statement.
Definition: StmtOpenMP.h:249
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3086
The template argument is actually a parameter pack.
Definition: TemplateBase.h:90
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:426
unsigned getNumClobbers() const
Definition: Stmt.h:2774
static OMPTargetTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
void setAtSynchronizedLoc(SourceLocation Loc)
Definition: StmtObjC.h:295
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Definition: ExprCXX.h:4085
void setElseLoc(SourceLocation ElseLoc)
Definition: Stmt.h:1979
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2056
void setLocation(SourceLocation Location)
Definition: Expr.h:1449
A ConvertVectorExpr record.
Definition: ASTBitCodes.h:1748
unsigned arg_size() const
Retrieve the number of arguments.
Definition: ExprCXX.h:3353
void setStarLoc(SourceLocation L)
Definition: Stmt.h:2511
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:3340
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3296
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2455
A use of a default initializer in a constructor or in aggregate initialization.
Definition: ExprCXX.h:1188
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize)
Definition: Expr.cpp:2022
void setLocation(SourceLocation L)
Definition: ExprCXX.h:1022
void setCond(Expr *Cond)
Definition: Stmt.h:2351
CapturedDecl * getCapturedDecl()
Retrieve the outlined function declaration.
Definition: Stmt.cpp:1291
void setBuiltinLoc(SourceLocation L)
Definition: Expr.h:4246
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2811
GNU array range designator.
Definition: ASTBitCodes.h:2008
void setBase(Expr *E)
Definition: Expr.h:5510
Defines the clang::SourceLocation class and associated facilities.
An ArrayInitIndexExpr record.
Definition: ASTBitCodes.h:1721
A GCC-style AsmStmt record.
Definition: ASTBitCodes.h:1631
This represents &#39;#pragma omp target parallel&#39; directive.
Definition: StmtOpenMP.h:2666
void setStrideVariable(Expr *ST)
Definition: StmtOpenMP.h:627
static MemberExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: Expr.cpp:1718
ContinueStmt - This represents a continue.
Definition: Stmt.h:2543
static CXXStaticCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize)
Definition: ExprCXX.cpp:716
Represents a loop initializing the elements of an array.
Definition: Expr.h:4999
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, Stmt *tryBlock, ArrayRef< Stmt *> handlers)
Definition: StmtCXX.cpp:25
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4102
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:501
CXXDefaultArgExprBitfields CXXDefaultArgExprBits
Definition: Stmt.h:985
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:3780
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
An index into an array.
Definition: Expr.h:2143
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr.type.conv]).
Definition: ExprCXX.h:1597
An ObjCAtCatchStmt record.
Definition: ASTBitCodes.h:1805
static TypeTraitExpr * CreateDeserialized(const ASTContext &C, unsigned NumArgs)
Definition: ExprCXX.cpp:1635
Expr * ReadSubExpr()
Reads a sub-expression operand during statement reading.
WhileStmt - This represents a &#39;while&#39; stmt.
Definition: Stmt.h:2200
CXXOperatorCallExprBitfields CXXOperatorCallExprBits
Definition: Stmt.h:980
static IfStmt * CreateEmpty(const ASTContext &Ctx, bool HasElse, bool HasVar, bool HasInit)
Create an empty IfStmt optionally with storage for an else statement, condition variable and init exp...
Definition: Stmt.cpp:877
void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)
Field designator where the field has been resolved to a declaration.
Definition: ASTBitCodes.h:2002
void setIsaMemberLoc(SourceLocation L)
Definition: ExprObjC.h:1526
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Definition: Expr.h:1828
static CXXNewExpr * CreateEmpty(const ASTContext &Ctx, bool IsArray, bool HasInit, unsigned NumPlacementArgs, bool IsParenTypeId)
Create an empty c++ new expression.
Definition: ExprCXX.cpp:204
static ParenListExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumExprs)
Create an empty paren list.
Definition: Expr.cpp:4450
A CXXInheritedCtorInitExpr record.
Definition: ASTBitCodes.h:1849
void setExprOperand(Expr *E)
Definition: ExprCXX.h:735
void setPreArg(unsigned I, Stmt *PreArg)
Definition: Expr.h:2597
The receiver is a class.
Definition: ExprObjC.h:1098
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:165
void setElse(Stmt *Else)
Definition: Stmt.h:1918
This represents &#39;#pragma omp taskloop simd&#39; directive.
Definition: StmtOpenMP.h:3051
void setTokenLocation(SourceLocation L)
Definition: Expr.h:4197
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:282
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:214
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1686
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2521
llvm::APInt readAPInt()
Read an integral value, advancing Idx.
Definition: ASTReader.h:2623
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:598
void setLoopVarStmt(Stmt *S)
Definition: StmtCXX.h:198
void setTryBody(Stmt *S)
Definition: StmtObjC.h:210
An object for streaming information from a record.
Definition: ASTReader.h:2366
Internal struct to describes an element that is a pack expansion, used if any of the elements in the ...
Definition: ExprObjC.h:292
void setPreCond(Expr *PC)
Definition: StmtOpenMP.h:595
RetTy Visit(PTR(Stmt) S, ParamTys... P)
Definition: StmtVisitor.h:42
void setRParenLoc(SourceLocation L)
Definition: Stmt.h:2435
SourceLocExprBitfields SourceLocExprBits
Definition: Stmt.h:977
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:2241
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:637
bool hasTemplateKWAndArgsInfo() const
Definition: ExprCXX.h:2794
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:262
This represents &#39;#pragma omp sections&#39; directive.
Definition: StmtOpenMP.h:1391
void setNextSwitchCase(SwitchCase *SC)
Definition: Stmt.h:1455
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:85
unsigned getNumComponents() const
Definition: Expr.h:2301
This represents &#39;#pragma omp target data&#39; directive.
Definition: StmtOpenMP.h:2491
void setNextUpperBound(Expr *NUB)
Definition: StmtOpenMP.h:648
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression...
Definition: ExprCXX.h:1884
capture_range captures()
Definition: Stmt.h:3485
void setKind(CharacterKind kind)
Definition: Expr.h:1542
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1146
static CaseStmt * CreateEmpty(const ASTContext &Ctx, bool CaseStmtIsGNURange)
Build an empty case statement.
Definition: Stmt.cpp:1113
Designator - A designator in a C99 designated initializer.
Definition: Designator.h:36
void setRawSemantics(llvm::APFloatBase::Semantics Sem)
Set the raw enumeration value representing the floating-point semantics of this literal (32-bit IEEE...
Definition: Expr.h:1589
void setLabel(LabelDecl *D)
Definition: Stmt.h:2469
Token readToken()
Reads a token out of a record, advancing Idx.
Definition: ASTReader.h:2663
BreakStmt - This represents a break.
Definition: Stmt.h:2573
void setSubStmt(Stmt *SS)
Definition: Stmt.h:1734
unsigned getNumLabels() const
Definition: Stmt.h:3001
static ObjCArrayLiteral * CreateEmpty(const ASTContext &C, unsigned NumElements)
Definition: ExprObjC.cpp:52
void setInc(Expr *Inc)
Definition: StmtOpenMP.h:602
CXXNoexceptExprBitfields CXXNoexceptExprBits
Definition: Stmt.h:999
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1479
static SwitchStmt * CreateEmpty(const ASTContext &Ctx, bool HasInit, bool HasVar)
Create an empty switch statement optionally with storage for an init expression and a condition varia...
Definition: Stmt.cpp:979
A trivial tuple used to represent a source range.
void setInit(Stmt *S)
Definition: Stmt.h:2425
This represents &#39;#pragma omp taskyield&#39; directive.
Definition: StmtOpenMP.h:1984
This represents a decl that may have a name.
Definition: Decl.h:248
unsigned NumInputs
Definition: Stmt.h:2708
This represents &#39;#pragma omp distribute parallel for simd&#39; composite directive.
Definition: StmtOpenMP.h:3324
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:554
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type, member-designator).
Definition: Expr.h:2242
This represents &#39;#pragma omp parallel sections&#39; directive.
Definition: StmtOpenMP.h:1845
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:909
void setCalcLastIteration(Expr *CLI)
Definition: StmtOpenMP.h:592
SwitchCase * getSwitchCaseWithID(unsigned ID)
Retrieve the switch-case statement with the given ID.
Definition: ASTReader.h:2672
static CallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, EmptyShell Empty)
Create an empty call expression, for deserialization.
Definition: Expr.cpp:1403
The receiver is a superclass.
Definition: ExprObjC.h:1104
void setCombinedNextUpperBound(Expr *CombNUB)
Definition: StmtOpenMP.h:712
SourceLocation getBegin() const
Definition: