clang  15.0.0git
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 
14 #include "clang/AST/ASTConcept.h"
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"
25 #include "clang/AST/Expr.h"
26 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ExprObjC.h"
28 #include "clang/AST/ExprOpenMP.h"
30 #include "clang/AST/OpenMPClause.h"
32 #include "clang/AST/Stmt.h"
33 #include "clang/AST/StmtCXX.h"
34 #include "clang/AST/StmtObjC.h"
35 #include "clang/AST/StmtOpenMP.h"
36 #include "clang/AST/StmtVisitor.h"
37 #include "clang/AST/TemplateBase.h"
38 #include "clang/AST/Type.h"
42 #include "clang/Basic/LLVM.h"
43 #include "clang/Basic/Lambda.h"
48 #include "clang/Basic/Specifiers.h"
49 #include "clang/Basic/TypeTraits.h"
50 #include "clang/Lex/Token.h"
53 #include "llvm/ADT/BitmaskEnum.h"
54 #include "llvm/ADT/DenseMap.h"
55 #include "llvm/ADT/SmallString.h"
56 #include "llvm/ADT/SmallVector.h"
57 #include "llvm/ADT/StringRef.h"
58 #include "llvm/Bitstream/BitstreamReader.h"
59 #include "llvm/Support/Casting.h"
60 #include "llvm/Support/ErrorHandling.h"
61 #include <algorithm>
62 #include <cassert>
63 #include <cstdint>
64 #include <string>
65 
66 using namespace clang;
67 using namespace serialization;
68 
69 namespace clang {
70 
71  class ASTStmtReader : public StmtVisitor<ASTStmtReader> {
72  ASTRecordReader &Record;
73  llvm::BitstreamCursor &DeclsCursor;
74 
75  SourceLocation readSourceLocation() {
76  return Record.readSourceLocation();
77  }
78 
79  SourceRange readSourceRange() {
80  return Record.readSourceRange();
81  }
82 
83  std::string readString() {
84  return Record.readString();
85  }
86 
87  TypeSourceInfo *readTypeSourceInfo() {
88  return Record.readTypeSourceInfo();
89  }
90 
91  Decl *readDecl() {
92  return Record.readDecl();
93  }
94 
95  template<typename T>
96  T *readDeclAs() {
97  return Record.readDeclAs<T>();
98  }
99 
100  public:
101  ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
102  : Record(Record), DeclsCursor(Cursor) {}
103 
104  /// The number of record fields required for the Stmt class
105  /// itself.
106  static const unsigned NumStmtFields = 0;
107 
108  /// The number of record fields required for the Expr class
109  /// itself.
110  static const unsigned NumExprFields = NumStmtFields + 4;
111 
112  /// Read and initialize a ExplicitTemplateArgumentList structure.
113  void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args,
114  TemplateArgumentLoc *ArgsLocArray,
115  unsigned NumTemplateArgs);
116 
117  /// Read and initialize a ExplicitTemplateArgumentList structure.
118  void ReadExplicitTemplateArgumentList(ASTTemplateArgumentListInfo &ArgList,
119  unsigned NumTemplateArgs);
120 
121  void VisitStmt(Stmt *S);
122 #define STMT(Type, Base) \
123  void Visit##Type(Type *);
124 #include "clang/AST/StmtNodes.inc"
125  };
126 
127 } // namespace clang
128 
130  TemplateArgumentLoc *ArgsLocArray,
131  unsigned NumTemplateArgs) {
132  SourceLocation TemplateKWLoc = readSourceLocation();
133  TemplateArgumentListInfo ArgInfo;
134  ArgInfo.setLAngleLoc(readSourceLocation());
135  ArgInfo.setRAngleLoc(readSourceLocation());
136  for (unsigned i = 0; i != NumTemplateArgs; ++i)
137  ArgInfo.addArgument(Record.readTemplateArgumentLoc());
138  Args.initializeFrom(TemplateKWLoc, ArgInfo, ArgsLocArray);
139 }
140 
142  assert(Record.getIdx() == NumStmtFields && "Incorrect statement field count");
143 }
144 
145 void ASTStmtReader::VisitNullStmt(NullStmt *S) {
146  VisitStmt(S);
147  S->setSemiLoc(readSourceLocation());
148  S->NullStmtBits.HasLeadingEmptyMacro = Record.readInt();
149 }
150 
151 void ASTStmtReader::VisitCompoundStmt(CompoundStmt *S) {
152  VisitStmt(S);
154  unsigned NumStmts = Record.readInt();
155  while (NumStmts--)
156  Stmts.push_back(Record.readSubStmt());
157  S->setStmts(Stmts);
158  S->CompoundStmtBits.LBraceLoc = readSourceLocation();
159  S->RBraceLoc = readSourceLocation();
160 }
161 
162 void ASTStmtReader::VisitSwitchCase(SwitchCase *S) {
163  VisitStmt(S);
164  Record.recordSwitchCaseID(S, Record.readInt());
165  S->setKeywordLoc(readSourceLocation());
166  S->setColonLoc(readSourceLocation());
167 }
168 
169 void ASTStmtReader::VisitCaseStmt(CaseStmt *S) {
170  VisitSwitchCase(S);
171  bool CaseStmtIsGNURange = Record.readInt();
172  S->setLHS(Record.readSubExpr());
173  S->setSubStmt(Record.readSubStmt());
174  if (CaseStmtIsGNURange) {
175  S->setRHS(Record.readSubExpr());
176  S->setEllipsisLoc(readSourceLocation());
177  }
178 }
179 
180 void ASTStmtReader::VisitDefaultStmt(DefaultStmt *S) {
181  VisitSwitchCase(S);
182  S->setSubStmt(Record.readSubStmt());
183 }
184 
185 void ASTStmtReader::VisitLabelStmt(LabelStmt *S) {
186  VisitStmt(S);
187  bool IsSideEntry = Record.readInt();
188  auto *LD = readDeclAs<LabelDecl>();
189  LD->setStmt(S);
190  S->setDecl(LD);
191  S->setSubStmt(Record.readSubStmt());
192  S->setIdentLoc(readSourceLocation());
193  S->setSideEntry(IsSideEntry);
194 }
195 
196 void ASTStmtReader::VisitAttributedStmt(AttributedStmt *S) {
197  VisitStmt(S);
198  // NumAttrs in AttributedStmt is set when creating an empty
199  // AttributedStmt in AttributedStmt::CreateEmpty, since it is needed
200  // to allocate the right amount of space for the trailing Attr *.
201  uint64_t NumAttrs = Record.readInt();
202  AttrVec Attrs;
203  Record.readAttributes(Attrs);
204  (void)NumAttrs;
205  assert(NumAttrs == S->AttributedStmtBits.NumAttrs);
206  assert(NumAttrs == Attrs.size());
207  std::copy(Attrs.begin(), Attrs.end(), S->getAttrArrayPtr());
208  S->SubStmt = Record.readSubStmt();
209  S->AttributedStmtBits.AttrLoc = readSourceLocation();
210 }
211 
212 void ASTStmtReader::VisitIfStmt(IfStmt *S) {
213  VisitStmt(S);
214 
215  bool HasElse = Record.readInt();
216  bool HasVar = Record.readInt();
217  bool HasInit = Record.readInt();
218 
219  S->setStatementKind(static_cast<IfStatementKind>(Record.readInt()));
220  S->setCond(Record.readSubExpr());
221  S->setThen(Record.readSubStmt());
222  if (HasElse)
223  S->setElse(Record.readSubStmt());
224  if (HasVar)
225  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
226  if (HasInit)
227  S->setInit(Record.readSubStmt());
228 
229  S->setIfLoc(readSourceLocation());
230  S->setLParenLoc(readSourceLocation());
231  S->setRParenLoc(readSourceLocation());
232  if (HasElse)
233  S->setElseLoc(readSourceLocation());
234 }
235 
236 void ASTStmtReader::VisitSwitchStmt(SwitchStmt *S) {
237  VisitStmt(S);
238 
239  bool HasInit = Record.readInt();
240  bool HasVar = Record.readInt();
241  bool AllEnumCasesCovered = Record.readInt();
242  if (AllEnumCasesCovered)
243  S->setAllEnumCasesCovered();
244 
245  S->setCond(Record.readSubExpr());
246  S->setBody(Record.readSubStmt());
247  if (HasInit)
248  S->setInit(Record.readSubStmt());
249  if (HasVar)
250  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
251 
252  S->setSwitchLoc(readSourceLocation());
253  S->setLParenLoc(readSourceLocation());
254  S->setRParenLoc(readSourceLocation());
255 
256  SwitchCase *PrevSC = nullptr;
257  for (auto E = Record.size(); Record.getIdx() != E; ) {
258  SwitchCase *SC = Record.getSwitchCaseWithID(Record.readInt());
259  if (PrevSC)
260  PrevSC->setNextSwitchCase(SC);
261  else
262  S->setSwitchCaseList(SC);
263 
264  PrevSC = SC;
265  }
266 }
267 
268 void ASTStmtReader::VisitWhileStmt(WhileStmt *S) {
269  VisitStmt(S);
270 
271  bool HasVar = Record.readInt();
272 
273  S->setCond(Record.readSubExpr());
274  S->setBody(Record.readSubStmt());
275  if (HasVar)
276  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
277 
278  S->setWhileLoc(readSourceLocation());
279  S->setLParenLoc(readSourceLocation());
280  S->setRParenLoc(readSourceLocation());
281 }
282 
283 void ASTStmtReader::VisitDoStmt(DoStmt *S) {
284  VisitStmt(S);
285  S->setCond(Record.readSubExpr());
286  S->setBody(Record.readSubStmt());
287  S->setDoLoc(readSourceLocation());
288  S->setWhileLoc(readSourceLocation());
289  S->setRParenLoc(readSourceLocation());
290 }
291 
292 void ASTStmtReader::VisitForStmt(ForStmt *S) {
293  VisitStmt(S);
294  S->setInit(Record.readSubStmt());
295  S->setCond(Record.readSubExpr());
296  S->setConditionVariable(Record.getContext(), readDeclAs<VarDecl>());
297  S->setInc(Record.readSubExpr());
298  S->setBody(Record.readSubStmt());
299  S->setForLoc(readSourceLocation());
300  S->setLParenLoc(readSourceLocation());
301  S->setRParenLoc(readSourceLocation());
302 }
303 
304 void ASTStmtReader::VisitGotoStmt(GotoStmt *S) {
305  VisitStmt(S);
306  S->setLabel(readDeclAs<LabelDecl>());
307  S->setGotoLoc(readSourceLocation());
308  S->setLabelLoc(readSourceLocation());
309 }
310 
311 void ASTStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
312  VisitStmt(S);
313  S->setGotoLoc(readSourceLocation());
314  S->setStarLoc(readSourceLocation());
315  S->setTarget(Record.readSubExpr());
316 }
317 
318 void ASTStmtReader::VisitContinueStmt(ContinueStmt *S) {
319  VisitStmt(S);
320  S->setContinueLoc(readSourceLocation());
321 }
322 
323 void ASTStmtReader::VisitBreakStmt(BreakStmt *S) {
324  VisitStmt(S);
325  S->setBreakLoc(readSourceLocation());
326 }
327 
328 void ASTStmtReader::VisitReturnStmt(ReturnStmt *S) {
329  VisitStmt(S);
330 
331  bool HasNRVOCandidate = Record.readInt();
332 
333  S->setRetValue(Record.readSubExpr());
334  if (HasNRVOCandidate)
335  S->setNRVOCandidate(readDeclAs<VarDecl>());
336 
337  S->setReturnLoc(readSourceLocation());
338 }
339 
340 void ASTStmtReader::VisitDeclStmt(DeclStmt *S) {
341  VisitStmt(S);
342  S->setStartLoc(readSourceLocation());
343  S->setEndLoc(readSourceLocation());
344 
345  if (Record.size() - Record.getIdx() == 1) {
346  // Single declaration
347  S->setDeclGroup(DeclGroupRef(readDecl()));
348  } else {
350  int N = Record.size() - Record.getIdx();
351  Decls.reserve(N);
352  for (int I = 0; I < N; ++I)
353  Decls.push_back(readDecl());
354  S->setDeclGroup(DeclGroupRef(DeclGroup::Create(Record.getContext(),
355  Decls.data(),
356  Decls.size())));
357  }
358 }
359 
360 void ASTStmtReader::VisitAsmStmt(AsmStmt *S) {
361  VisitStmt(S);
362  S->NumOutputs = Record.readInt();
363  S->NumInputs = Record.readInt();
364  S->NumClobbers = Record.readInt();
365  S->setAsmLoc(readSourceLocation());
366  S->setVolatile(Record.readInt());
367  S->setSimple(Record.readInt());
368 }
369 
370 void ASTStmtReader::VisitGCCAsmStmt(GCCAsmStmt *S) {
371  VisitAsmStmt(S);
372  S->NumLabels = Record.readInt();
373  S->setRParenLoc(readSourceLocation());
374  S->setAsmString(cast_or_null<StringLiteral>(Record.readSubStmt()));
375 
376  unsigned NumOutputs = S->getNumOutputs();
377  unsigned NumInputs = S->getNumInputs();
378  unsigned NumClobbers = S->getNumClobbers();
379  unsigned NumLabels = S->getNumLabels();
380 
381  // Outputs and inputs
385  for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
386  Names.push_back(Record.readIdentifier());
387  Constraints.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
388  Exprs.push_back(Record.readSubStmt());
389  }
390 
391  // Constraints
393  for (unsigned I = 0; I != NumClobbers; ++I)
394  Clobbers.push_back(cast_or_null<StringLiteral>(Record.readSubStmt()));
395 
396  // Labels
397  for (unsigned I = 0, N = NumLabels; I != N; ++I)
398  Exprs.push_back(Record.readSubStmt());
399 
400  S->setOutputsAndInputsAndClobbers(Record.getContext(),
401  Names.data(), Constraints.data(),
402  Exprs.data(), NumOutputs, NumInputs,
403  NumLabels,
404  Clobbers.data(), NumClobbers);
405 }
406 
407 void ASTStmtReader::VisitMSAsmStmt(MSAsmStmt *S) {
408  VisitAsmStmt(S);
409  S->LBraceLoc = readSourceLocation();
410  S->EndLoc = readSourceLocation();
411  S->NumAsmToks = Record.readInt();
412  std::string AsmStr = readString();
413 
414  // Read the tokens.
415  SmallVector<Token, 16> AsmToks;
416  AsmToks.reserve(S->NumAsmToks);
417  for (unsigned i = 0, e = S->NumAsmToks; i != e; ++i) {
418  AsmToks.push_back(Record.readToken());
419  }
420 
421  // The calls to reserve() for the FooData vectors are mandatory to
422  // prevent dead StringRefs in the Foo vectors.
423 
424  // Read the clobbers.
425  SmallVector<std::string, 16> ClobbersData;
427  ClobbersData.reserve(S->NumClobbers);
428  Clobbers.reserve(S->NumClobbers);
429  for (unsigned i = 0, e = S->NumClobbers; i != e; ++i) {
430  ClobbersData.push_back(readString());
431  Clobbers.push_back(ClobbersData.back());
432  }
433 
434  // Read the operands.
435  unsigned NumOperands = S->NumOutputs + S->NumInputs;
437  SmallVector<std::string, 16> ConstraintsData;
438  SmallVector<StringRef, 16> Constraints;
439  Exprs.reserve(NumOperands);
440  ConstraintsData.reserve(NumOperands);
441  Constraints.reserve(NumOperands);
442  for (unsigned i = 0; i != NumOperands; ++i) {
443  Exprs.push_back(cast<Expr>(Record.readSubStmt()));
444  ConstraintsData.push_back(readString());
445  Constraints.push_back(ConstraintsData.back());
446  }
447 
448  S->initialize(Record.getContext(), AsmStr, AsmToks,
449  Constraints, Exprs, Clobbers);
450 }
451 
452 void ASTStmtReader::VisitCoroutineBodyStmt(CoroutineBodyStmt *S) {
453  VisitStmt(S);
454  assert(Record.peekInt() == S->NumParams);
455  Record.skipInts(1);
456  auto *StoredStmts = S->getStoredStmts();
457  for (unsigned i = 0;
458  i < CoroutineBodyStmt::SubStmt::FirstParamMove + S->NumParams; ++i)
459  StoredStmts[i] = Record.readSubStmt();
460 }
461 
462 void ASTStmtReader::VisitCoreturnStmt(CoreturnStmt *S) {
463  VisitStmt(S);
464  S->CoreturnLoc = Record.readSourceLocation();
465  for (auto &SubStmt: S->SubStmts)
466  SubStmt = Record.readSubStmt();
467  S->IsImplicit = Record.readInt() != 0;
468 }
469 
470 void ASTStmtReader::VisitCoawaitExpr(CoawaitExpr *E) {
471  VisitExpr(E);
472  E->KeywordLoc = readSourceLocation();
473  for (auto &SubExpr: E->SubExprs)
474  SubExpr = Record.readSubStmt();
475  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
476  E->setIsImplicit(Record.readInt() != 0);
477 }
478 
479 void ASTStmtReader::VisitCoyieldExpr(CoyieldExpr *E) {
480  VisitExpr(E);
481  E->KeywordLoc = readSourceLocation();
482  for (auto &SubExpr: E->SubExprs)
483  SubExpr = Record.readSubStmt();
484  E->OpaqueValue = cast_or_null<OpaqueValueExpr>(Record.readSubStmt());
485 }
486 
487 void ASTStmtReader::VisitDependentCoawaitExpr(DependentCoawaitExpr *E) {
488  VisitExpr(E);
489  E->KeywordLoc = readSourceLocation();
490  for (auto &SubExpr: E->SubExprs)
491  SubExpr = Record.readSubStmt();
492 }
493 
494 void ASTStmtReader::VisitCapturedStmt(CapturedStmt *S) {
495  VisitStmt(S);
496  Record.skipInts(1);
497  S->setCapturedDecl(readDeclAs<CapturedDecl>());
498  S->setCapturedRegionKind(static_cast<CapturedRegionKind>(Record.readInt()));
499  S->setCapturedRecordDecl(readDeclAs<RecordDecl>());
500 
501  // Capture inits
502  for (CapturedStmt::capture_init_iterator I = S->capture_init_begin(),
503  E = S->capture_init_end();
504  I != E; ++I)
505  *I = Record.readSubExpr();
506 
507  // Body
508  S->setCapturedStmt(Record.readSubStmt());
509  S->getCapturedDecl()->setBody(S->getCapturedStmt());
510 
511  // Captures
512  for (auto &I : S->captures()) {
513  I.VarAndKind.setPointer(readDeclAs<VarDecl>());
514  I.VarAndKind.setInt(
515  static_cast<CapturedStmt::VariableCaptureKind>(Record.readInt()));
516  I.Loc = readSourceLocation();
517  }
518 }
519 
520 void ASTStmtReader::VisitExpr(Expr *E) {
521  VisitStmt(E);
522  E->setType(Record.readType());
523  E->setDependence(static_cast<ExprDependence>(Record.readInt()));
524  E->setValueKind(static_cast<ExprValueKind>(Record.readInt()));
525  E->setObjectKind(static_cast<ExprObjectKind>(Record.readInt()));
526  assert(Record.getIdx() == NumExprFields &&
527  "Incorrect expression field count");
528 }
529 
530 void ASTStmtReader::VisitConstantExpr(ConstantExpr *E) {
531  VisitExpr(E);
532 
533  auto StorageKind = Record.readInt();
534  assert(E->ConstantExprBits.ResultKind == StorageKind && "Wrong ResultKind!");
535 
536  E->ConstantExprBits.APValueKind = Record.readInt();
537  E->ConstantExprBits.IsUnsigned = Record.readInt();
538  E->ConstantExprBits.BitWidth = Record.readInt();
539  E->ConstantExprBits.HasCleanup = false; // Not serialized, see below.
540  E->ConstantExprBits.IsImmediateInvocation = Record.readInt();
541 
542  switch (StorageKind) {
544  break;
545 
547  E->Int64Result() = Record.readInt();
548  break;
549 
551  E->APValueResult() = Record.readAPValue();
552  if (E->APValueResult().needsCleanup()) {
553  E->ConstantExprBits.HasCleanup = true;
554  Record.getContext().addDestruction(&E->APValueResult());
555  }
556  break;
557  default:
558  llvm_unreachable("unexpected ResultKind!");
559  }
560 
561  E->setSubExpr(Record.readSubExpr());
562 }
563 
564 void ASTStmtReader::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
565  VisitExpr(E);
566 
567  E->setLocation(readSourceLocation());
568  E->setLParenLocation(readSourceLocation());
569  E->setRParenLocation(readSourceLocation());
570 
571  E->setTypeSourceInfo(Record.readTypeSourceInfo());
572 }
573 
574 void ASTStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
575  VisitExpr(E);
576  bool HasFunctionName = Record.readInt();
577  E->PredefinedExprBits.HasFunctionName = HasFunctionName;
578  E->PredefinedExprBits.Kind = Record.readInt();
579  E->setLocation(readSourceLocation());
580  if (HasFunctionName)
581  E->setFunctionName(cast<StringLiteral>(Record.readSubExpr()));
582 }
583 
584 void ASTStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
585  VisitExpr(E);
586 
587  E->DeclRefExprBits.HasQualifier = Record.readInt();
588  E->DeclRefExprBits.HasFoundDecl = Record.readInt();
589  E->DeclRefExprBits.HasTemplateKWAndArgsInfo = Record.readInt();
590  E->DeclRefExprBits.HadMultipleCandidates = Record.readInt();
591  E->DeclRefExprBits.RefersToEnclosingVariableOrCapture = Record.readInt();
592  E->DeclRefExprBits.NonOdrUseReason = Record.readInt();
593  unsigned NumTemplateArgs = 0;
594  if (E->hasTemplateKWAndArgsInfo())
595  NumTemplateArgs = Record.readInt();
596 
597  if (E->hasQualifier())
598  new (E->getTrailingObjects<NestedNameSpecifierLoc>())
599  NestedNameSpecifierLoc(Record.readNestedNameSpecifierLoc());
600 
601  if (E->hasFoundDecl())
602  *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
603 
604  if (E->hasTemplateKWAndArgsInfo())
605  ReadTemplateKWAndArgsInfo(
606  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
607  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
608 
609  E->D = readDeclAs<ValueDecl>();
610  E->setLocation(readSourceLocation());
611  E->DNLoc = Record.readDeclarationNameLoc(E->getDecl()->getDeclName());
612 }
613 
614 void ASTStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
615  VisitExpr(E);
616  E->setLocation(readSourceLocation());
617  E->setValue(Record.getContext(), Record.readAPInt());
618 }
619 
620 void ASTStmtReader::VisitFixedPointLiteral(FixedPointLiteral *E) {
621  VisitExpr(E);
622  E->setLocation(readSourceLocation());
623  E->setScale(Record.readInt());
624  E->setValue(Record.getContext(), Record.readAPInt());
625 }
626 
627 void ASTStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
628  VisitExpr(E);
629  E->setRawSemantics(
630  static_cast<llvm::APFloatBase::Semantics>(Record.readInt()));
631  E->setExact(Record.readInt());
632  E->setValue(Record.getContext(), Record.readAPFloat(E->getSemantics()));
633  E->setLocation(readSourceLocation());
634 }
635 
636 void ASTStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
637  VisitExpr(E);
638  E->setSubExpr(Record.readSubExpr());
639 }
640 
641 void ASTStmtReader::VisitStringLiteral(StringLiteral *E) {
642  VisitExpr(E);
643 
644  // NumConcatenated, Length and CharByteWidth are set by the empty
645  // ctor since they are needed to allocate storage for the trailing objects.
646  unsigned NumConcatenated = Record.readInt();
647  unsigned Length = Record.readInt();
648  unsigned CharByteWidth = Record.readInt();
649  assert((NumConcatenated == E->getNumConcatenated()) &&
650  "Wrong number of concatenated tokens!");
651  assert((Length == E->getLength()) && "Wrong Length!");
652  assert((CharByteWidth == E->getCharByteWidth()) && "Wrong character width!");
653  E->StringLiteralBits.Kind = Record.readInt();
654  E->StringLiteralBits.IsPascal = Record.readInt();
655 
656  // The character width is originally computed via mapCharByteWidth.
657  // Check that the deserialized character width is consistant with the result
658  // of calling mapCharByteWidth.
659  assert((CharByteWidth ==
660  StringLiteral::mapCharByteWidth(Record.getContext().getTargetInfo(),
661  E->getKind())) &&
662  "Wrong character width!");
663 
664  // Deserialize the trailing array of SourceLocation.
665  for (unsigned I = 0; I < NumConcatenated; ++I)
666  E->setStrTokenLoc(I, readSourceLocation());
667 
668  // Deserialize the trailing array of char holding the string data.
669  char *StrData = E->getStrDataAsChar();
670  for (unsigned I = 0; I < Length * CharByteWidth; ++I)
671  StrData[I] = Record.readInt();
672 }
673 
674 void ASTStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
675  VisitExpr(E);
676  E->setValue(Record.readInt());
677  E->setLocation(readSourceLocation());
678  E->setKind(static_cast<CharacterLiteral::CharacterKind>(Record.readInt()));
679 }
680 
681 void ASTStmtReader::VisitParenExpr(ParenExpr *E) {
682  VisitExpr(E);
683  E->setLParen(readSourceLocation());
684  E->setRParen(readSourceLocation());
685  E->setSubExpr(Record.readSubExpr());
686 }
687 
688 void ASTStmtReader::VisitParenListExpr(ParenListExpr *E) {
689  VisitExpr(E);
690  unsigned NumExprs = Record.readInt();
691  assert((NumExprs == E->getNumExprs()) && "Wrong NumExprs!");
692  for (unsigned I = 0; I != NumExprs; ++I)
693  E->getTrailingObjects<Stmt *>()[I] = Record.readSubStmt();
694  E->LParenLoc = readSourceLocation();
695  E->RParenLoc = readSourceLocation();
696 }
697 
698 void ASTStmtReader::VisitUnaryOperator(UnaryOperator *E) {
699  VisitExpr(E);
700  bool hasFP_Features = Record.readInt();
701  assert(hasFP_Features == E->hasStoredFPFeatures());
702  E->setSubExpr(Record.readSubExpr());
703  E->setOpcode((UnaryOperator::Opcode)Record.readInt());
704  E->setOperatorLoc(readSourceLocation());
705  E->setCanOverflow(Record.readInt());
706  if (hasFP_Features)
708  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
709 }
710 
711 void ASTStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
712  VisitExpr(E);
713  assert(E->getNumComponents() == Record.peekInt());
714  Record.skipInts(1);
715  assert(E->getNumExpressions() == Record.peekInt());
716  Record.skipInts(1);
717  E->setOperatorLoc(readSourceLocation());
718  E->setRParenLoc(readSourceLocation());
719  E->setTypeSourceInfo(readTypeSourceInfo());
720  for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
721  auto Kind = static_cast<OffsetOfNode::Kind>(Record.readInt());
722  SourceLocation Start = readSourceLocation();
723  SourceLocation End = readSourceLocation();
724  switch (Kind) {
725  case OffsetOfNode::Array:
726  E->setComponent(I, OffsetOfNode(Start, Record.readInt(), End));
727  break;
728 
729  case OffsetOfNode::Field:
730  E->setComponent(
731  I, OffsetOfNode(Start, readDeclAs<FieldDecl>(), End));
732  break;
733 
735  E->setComponent(
736  I,
737  OffsetOfNode(Start, Record.readIdentifier(), End));
738  break;
739 
740  case OffsetOfNode::Base: {
741  auto *Base = new (Record.getContext()) CXXBaseSpecifier();
742  *Base = Record.readCXXBaseSpecifier();
744  break;
745  }
746  }
747  }
748 
749  for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
750  E->setIndexExpr(I, Record.readSubExpr());
751 }
752 
753 void ASTStmtReader::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
754  VisitExpr(E);
755  E->setKind(static_cast<UnaryExprOrTypeTrait>(Record.readInt()));
756  if (Record.peekInt() == 0) {
757  E->setArgument(Record.readSubExpr());
758  Record.skipInts(1);
759  } else {
760  E->setArgument(readTypeSourceInfo());
761  }
762  E->setOperatorLoc(readSourceLocation());
763  E->setRParenLoc(readSourceLocation());
764 }
765 
768  ConstraintSatisfaction Satisfaction;
769  Satisfaction.IsSatisfied = Record.readInt();
770  if (!Satisfaction.IsSatisfied) {
771  unsigned NumDetailRecords = Record.readInt();
772  for (unsigned i = 0; i != NumDetailRecords; ++i) {
773  Expr *ConstraintExpr = Record.readExpr();
774  if (/* IsDiagnostic */Record.readInt()) {
775  SourceLocation DiagLocation = Record.readSourceLocation();
776  std::string DiagMessage = Record.readString();
777  Satisfaction.Details.emplace_back(
778  ConstraintExpr, new (Record.getContext())
780  DiagLocation, DiagMessage});
781  } else
782  Satisfaction.Details.emplace_back(ConstraintExpr, Record.readExpr());
783  }
784  }
785  return Satisfaction;
786 }
787 
788 void ASTStmtReader::VisitConceptSpecializationExpr(
790  VisitExpr(E);
791  unsigned NumTemplateArgs = Record.readInt();
792  E->NestedNameSpec = Record.readNestedNameSpecifierLoc();
793  E->TemplateKWLoc = Record.readSourceLocation();
794  E->ConceptName = Record.readDeclarationNameInfo();
795  E->NamedConcept = readDeclAs<ConceptDecl>();
796  E->FoundDecl = Record.readDeclAs<NamedDecl>();
797  E->ArgsAsWritten = Record.readASTTemplateArgumentListInfo();
799  for (unsigned I = 0; I < NumTemplateArgs; ++I)
800  Args.push_back(Record.readTemplateArgument());
801  E->setTemplateArguments(Args);
802  E->Satisfaction = E->isValueDependent() ? nullptr :
803  ASTConstraintSatisfaction::Create(Record.getContext(),
805 }
806 
809  std::string SubstitutedEntity = Record.readString();
810  SourceLocation DiagLoc = Record.readSourceLocation();
811  std::string DiagMessage = Record.readString();
812  return new (Record.getContext())
813  concepts::Requirement::SubstitutionDiagnostic{SubstitutedEntity, DiagLoc,
814  DiagMessage};
815 }
816 
817 void ASTStmtReader::VisitRequiresExpr(RequiresExpr *E) {
818  VisitExpr(E);
819  unsigned NumLocalParameters = Record.readInt();
820  unsigned NumRequirements = Record.readInt();
821  E->RequiresExprBits.RequiresKWLoc = Record.readSourceLocation();
822  E->RequiresExprBits.IsSatisfied = Record.readInt();
823  E->Body = Record.readDeclAs<RequiresExprBodyDecl>();
824  llvm::SmallVector<ParmVarDecl *, 4> LocalParameters;
825  for (unsigned i = 0; i < NumLocalParameters; ++i)
826  LocalParameters.push_back(cast<ParmVarDecl>(Record.readDecl()));
827  std::copy(LocalParameters.begin(), LocalParameters.end(),
828  E->getTrailingObjects<ParmVarDecl *>());
830  for (unsigned i = 0; i < NumRequirements; ++i) {
831  auto RK =
832  static_cast<concepts::Requirement::RequirementKind>(Record.readInt());
833  concepts::Requirement *R = nullptr;
834  switch (RK) {
836  auto Status =
838  Record.readInt());
840  R = new (Record.getContext())
842  else
843  R = new (Record.getContext())
844  concepts::TypeRequirement(Record.readTypeSourceInfo());
845  } break;
848  auto Status =
850  Record.readInt());
852  Expr *> E;
854  E = readSubstitutionDiagnostic(Record);
855  } else
856  E = Record.readExpr();
857 
859  ConceptSpecializationExpr *SubstitutedConstraintExpr = nullptr;
860  SourceLocation NoexceptLoc;
862  Req.emplace();
863  } else {
864  NoexceptLoc = Record.readSourceLocation();
865  switch (/* returnTypeRequirementKind */Record.readInt()) {
866  case 0:
867  // No return type requirement.
868  Req.emplace();
869  break;
870  case 1: {
871  // type-constraint
872  TemplateParameterList *TPL = Record.readTemplateParameterList();
873  if (Status >=
875  SubstitutedConstraintExpr =
876  cast<ConceptSpecializationExpr>(Record.readExpr());
877  Req.emplace(TPL);
878  } break;
879  case 2:
880  // Substitution failure
881  Req.emplace(readSubstitutionDiagnostic(Record));
882  break;
883  }
884  }
885  if (Expr *Ex = E.dyn_cast<Expr *>())
886  R = new (Record.getContext()) concepts::ExprRequirement(
887  Ex, RK == concepts::Requirement::RK_Simple, NoexceptLoc,
888  std::move(*Req), Status, SubstitutedConstraintExpr);
889  else
890  R = new (Record.getContext()) concepts::ExprRequirement(
892  RK == concepts::Requirement::RK_Simple, NoexceptLoc,
893  std::move(*Req));
894  } break;
896  if (/* IsSubstitutionDiagnostic */Record.readInt()) {
897  R = new (Record.getContext()) concepts::NestedRequirement(
899  break;
900  }
901  Expr *E = Record.readExpr();
902  if (E->isInstantiationDependent())
903  R = new (Record.getContext()) concepts::NestedRequirement(E);
904  else
905  R = new (Record.getContext())
906  concepts::NestedRequirement(Record.getContext(), E,
908  } break;
909  }
910  if (!R)
911  continue;
912  Requirements.push_back(R);
913  }
914  std::copy(Requirements.begin(), Requirements.end(),
915  E->getTrailingObjects<concepts::Requirement *>());
916  E->RBraceLoc = Record.readSourceLocation();
917 }
918 
919 void ASTStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
920  VisitExpr(E);
921  E->setLHS(Record.readSubExpr());
922  E->setRHS(Record.readSubExpr());
923  E->setRBracketLoc(readSourceLocation());
924 }
925 
926 void ASTStmtReader::VisitMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
927  VisitExpr(E);
928  E->setBase(Record.readSubExpr());
929  E->setRowIdx(Record.readSubExpr());
930  E->setColumnIdx(Record.readSubExpr());
931  E->setRBracketLoc(readSourceLocation());
932 }
933 
934 void ASTStmtReader::VisitOMPArraySectionExpr(OMPArraySectionExpr *E) {
935  VisitExpr(E);
936  E->setBase(Record.readSubExpr());
937  E->setLowerBound(Record.readSubExpr());
938  E->setLength(Record.readSubExpr());
939  E->setStride(Record.readSubExpr());
940  E->setColonLocFirst(readSourceLocation());
941  E->setColonLocSecond(readSourceLocation());
942  E->setRBracketLoc(readSourceLocation());
943 }
944 
945 void ASTStmtReader::VisitOMPArrayShapingExpr(OMPArrayShapingExpr *E) {
946  VisitExpr(E);
947  unsigned NumDims = Record.readInt();
948  E->setBase(Record.readSubExpr());
949  SmallVector<Expr *, 4> Dims(NumDims);
950  for (unsigned I = 0; I < NumDims; ++I)
951  Dims[I] = Record.readSubExpr();
952  E->setDimensions(Dims);
953  SmallVector<SourceRange, 4> SRs(NumDims);
954  for (unsigned I = 0; I < NumDims; ++I)
955  SRs[I] = readSourceRange();
956  E->setBracketsRanges(SRs);
957  E->setLParenLoc(readSourceLocation());
958  E->setRParenLoc(readSourceLocation());
959 }
960 
961 void ASTStmtReader::VisitOMPIteratorExpr(OMPIteratorExpr *E) {
962  VisitExpr(E);
963  unsigned NumIters = Record.readInt();
964  E->setIteratorKwLoc(readSourceLocation());
965  E->setLParenLoc(readSourceLocation());
966  E->setRParenLoc(readSourceLocation());
967  for (unsigned I = 0; I < NumIters; ++I) {
968  E->setIteratorDeclaration(I, Record.readDeclRef());
969  E->setAssignmentLoc(I, readSourceLocation());
970  Expr *Begin = Record.readSubExpr();
971  Expr *End = Record.readSubExpr();
972  Expr *Step = Record.readSubExpr();
973  SourceLocation ColonLoc = readSourceLocation();
974  SourceLocation SecColonLoc;
975  if (Step)
976  SecColonLoc = readSourceLocation();
977  E->setIteratorRange(I, Begin, ColonLoc, End, SecColonLoc, Step);
978  // Deserialize helpers
980  HD.CounterVD = cast_or_null<VarDecl>(Record.readDeclRef());
981  HD.Upper = Record.readSubExpr();
982  HD.Update = Record.readSubExpr();
983  HD.CounterUpdate = Record.readSubExpr();
984  E->setHelper(I, HD);
985  }
986 }
987 
988 void ASTStmtReader::VisitCallExpr(CallExpr *E) {
989  VisitExpr(E);
990  unsigned NumArgs = Record.readInt();
991  bool HasFPFeatures = Record.readInt();
992  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
993  E->setRParenLoc(readSourceLocation());
994  E->setCallee(Record.readSubExpr());
995  for (unsigned I = 0; I != NumArgs; ++I)
996  E->setArg(I, Record.readSubExpr());
997  E->setADLCallKind(static_cast<CallExpr::ADLCallKind>(Record.readInt()));
998  if (HasFPFeatures)
1000  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
1001 }
1002 
1003 void ASTStmtReader::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1004  VisitCallExpr(E);
1005 }
1006 
1007 void ASTStmtReader::VisitMemberExpr(MemberExpr *E) {
1008  VisitExpr(E);
1009 
1010  bool HasQualifier = Record.readInt();
1011  bool HasFoundDecl = Record.readInt();
1012  bool HasTemplateInfo = Record.readInt();
1013  unsigned NumTemplateArgs = Record.readInt();
1014 
1015  E->Base = Record.readSubExpr();
1016  E->MemberDecl = Record.readDeclAs<ValueDecl>();
1017  E->MemberDNLoc = Record.readDeclarationNameLoc(E->MemberDecl->getDeclName());
1018  E->MemberLoc = Record.readSourceLocation();
1019  E->MemberExprBits.IsArrow = Record.readInt();
1020  E->MemberExprBits.HasQualifierOrFoundDecl = HasQualifier || HasFoundDecl;
1021  E->MemberExprBits.HasTemplateKWAndArgsInfo = HasTemplateInfo;
1022  E->MemberExprBits.HadMultipleCandidates = Record.readInt();
1023  E->MemberExprBits.NonOdrUseReason = Record.readInt();
1024  E->MemberExprBits.OperatorLoc = Record.readSourceLocation();
1025 
1026  if (HasQualifier || HasFoundDecl) {
1027  DeclAccessPair FoundDecl;
1028  if (HasFoundDecl) {
1029  auto *FoundD = Record.readDeclAs<NamedDecl>();
1030  auto AS = (AccessSpecifier)Record.readInt();
1031  FoundDecl = DeclAccessPair::make(FoundD, AS);
1032  } else {
1033  FoundDecl = DeclAccessPair::make(E->MemberDecl,
1034  E->MemberDecl->getAccess());
1035  }
1036  E->getTrailingObjects<MemberExprNameQualifier>()->FoundDecl = FoundDecl;
1037 
1038  NestedNameSpecifierLoc QualifierLoc;
1039  if (HasQualifier)
1040  QualifierLoc = Record.readNestedNameSpecifierLoc();
1041  E->getTrailingObjects<MemberExprNameQualifier>()->QualifierLoc =
1042  QualifierLoc;
1043  }
1044 
1045  if (HasTemplateInfo)
1046  ReadTemplateKWAndArgsInfo(
1047  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1048  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1049 }
1050 
1051 void ASTStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
1052  VisitExpr(E);
1053  E->setBase(Record.readSubExpr());
1054  E->setIsaMemberLoc(readSourceLocation());
1055  E->setOpLoc(readSourceLocation());
1056  E->setArrow(Record.readInt());
1057 }
1058 
1059 void ASTStmtReader::
1060 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
1061  VisitExpr(E);
1062  E->Operand = Record.readSubExpr();
1063  E->setShouldCopy(Record.readInt());
1064 }
1065 
1066 void ASTStmtReader::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
1067  VisitExplicitCastExpr(E);
1068  E->LParenLoc = readSourceLocation();
1069  E->BridgeKeywordLoc = readSourceLocation();
1070  E->Kind = Record.readInt();
1071 }
1072 
1073 void ASTStmtReader::VisitCastExpr(CastExpr *E) {
1074  VisitExpr(E);
1075  unsigned NumBaseSpecs = Record.readInt();
1076  assert(NumBaseSpecs == E->path_size());
1077  unsigned HasFPFeatures = Record.readInt();
1078  assert(E->hasStoredFPFeatures() == HasFPFeatures);
1079  E->setSubExpr(Record.readSubExpr());
1080  E->setCastKind((CastKind)Record.readInt());
1081  CastExpr::path_iterator BaseI = E->path_begin();
1082  while (NumBaseSpecs--) {
1083  auto *BaseSpec = new (Record.getContext()) CXXBaseSpecifier;
1084  *BaseSpec = Record.readCXXBaseSpecifier();
1085  *BaseI++ = BaseSpec;
1086  }
1087  if (HasFPFeatures)
1088  *E->getTrailingFPFeatures() =
1089  FPOptionsOverride::getFromOpaqueInt(Record.readInt());
1090 }
1091 
1092 void ASTStmtReader::VisitBinaryOperator(BinaryOperator *E) {
1093  bool hasFP_Features;
1094  VisitExpr(E);
1095  E->setHasStoredFPFeatures(hasFP_Features = Record.readInt());
1096  E->setOpcode((BinaryOperator::Opcode)Record.readInt());
1097  E->setLHS(Record.readSubExpr());
1098  E->setRHS(Record.readSubExpr());
1099  E->setOperatorLoc(readSourceLocation());
1100  if (hasFP_Features)
1102  FPOptionsOverride::getFromOpaqueInt(Record.readInt()));
1103 }
1104 
1105 void ASTStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
1106  VisitBinaryOperator(E);
1107  E->setComputationLHSType(Record.readType());
1108  E->setComputationResultType(Record.readType());
1109 }
1110 
1111 void ASTStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
1112  VisitExpr(E);
1113  E->SubExprs[ConditionalOperator::COND] = Record.readSubExpr();
1114  E->SubExprs[ConditionalOperator::LHS] = Record.readSubExpr();
1115  E->SubExprs[ConditionalOperator::RHS] = Record.readSubExpr();
1116  E->QuestionLoc = readSourceLocation();
1117  E->ColonLoc = readSourceLocation();
1118 }
1119 
1120 void
1121 ASTStmtReader::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
1122  VisitExpr(E);
1123  E->OpaqueValue = cast<OpaqueValueExpr>(Record.readSubExpr());
1124  E->SubExprs[BinaryConditionalOperator::COMMON] = Record.readSubExpr();
1125  E->SubExprs[BinaryConditionalOperator::COND] = Record.readSubExpr();
1126  E->SubExprs[BinaryConditionalOperator::LHS] = Record.readSubExpr();
1127  E->SubExprs[BinaryConditionalOperator::RHS] = Record.readSubExpr();
1128  E->QuestionLoc = readSourceLocation();
1129  E->ColonLoc = readSourceLocation();
1130 }
1131 
1132 void ASTStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
1133  VisitCastExpr(E);
1134  E->setIsPartOfExplicitCast(Record.readInt());
1135 }
1136 
1137 void ASTStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
1138  VisitCastExpr(E);
1139  E->setTypeInfoAsWritten(readTypeSourceInfo());
1140 }
1141 
1142 void ASTStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
1143  VisitExplicitCastExpr(E);
1144  E->setLParenLoc(readSourceLocation());
1145  E->setRParenLoc(readSourceLocation());
1146 }
1147 
1148 void ASTStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
1149  VisitExpr(E);
1150  E->setLParenLoc(readSourceLocation());
1151  E->setTypeSourceInfo(readTypeSourceInfo());
1152  E->setInitializer(Record.readSubExpr());
1153  E->setFileScope(Record.readInt());
1154 }
1155 
1156 void ASTStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
1157  VisitExpr(E);
1158  E->setBase(Record.readSubExpr());
1159  E->setAccessor(Record.readIdentifier());
1160  E->setAccessorLoc(readSourceLocation());
1161 }
1162 
1163 void ASTStmtReader::VisitInitListExpr(InitListExpr *E) {
1164  VisitExpr(E);
1165  if (auto *SyntForm = cast_or_null<InitListExpr>(Record.readSubStmt()))
1166  E->setSyntacticForm(SyntForm);
1167  E->setLBraceLoc(readSourceLocation());
1168  E->setRBraceLoc(readSourceLocation());
1169  bool isArrayFiller = Record.readInt();
1170  Expr *filler = nullptr;
1171  if (isArrayFiller) {
1172  filler = Record.readSubExpr();
1173  E->ArrayFillerOrUnionFieldInit = filler;
1174  } else
1175  E->ArrayFillerOrUnionFieldInit = readDeclAs<FieldDecl>();
1176  E->sawArrayRangeDesignator(Record.readInt());
1177  unsigned NumInits = Record.readInt();
1178  E->reserveInits(Record.getContext(), NumInits);
1179  if (isArrayFiller) {
1180  for (unsigned I = 0; I != NumInits; ++I) {
1181  Expr *init = Record.readSubExpr();
1182  E->updateInit(Record.getContext(), I, init ? init : filler);
1183  }
1184  } else {
1185  for (unsigned I = 0; I != NumInits; ++I)
1186  E->updateInit(Record.getContext(), I, Record.readSubExpr());
1187  }
1188 }
1189 
1190 void ASTStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
1192 
1193  VisitExpr(E);
1194  unsigned NumSubExprs = Record.readInt();
1195  assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
1196  for (unsigned I = 0; I != NumSubExprs; ++I)
1197  E->setSubExpr(I, Record.readSubExpr());
1198  E->setEqualOrColonLoc(readSourceLocation());
1199  E->setGNUSyntax(Record.readInt());
1200 
1201  SmallVector<Designator, 4> Designators;
1202  while (Record.getIdx() < Record.size()) {
1203  switch ((DesignatorTypes)Record.readInt()) {
1204  case DESIG_FIELD_DECL: {
1205  auto *Field = readDeclAs<FieldDecl>();
1206  SourceLocation DotLoc = readSourceLocation();
1207  SourceLocation FieldLoc = readSourceLocation();
1208  Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
1209  FieldLoc));
1210  Designators.back().setField(Field);
1211  break;
1212  }
1213 
1214  case DESIG_FIELD_NAME: {
1215  const IdentifierInfo *Name = Record.readIdentifier();
1216  SourceLocation DotLoc = readSourceLocation();
1217  SourceLocation FieldLoc = readSourceLocation();
1218  Designators.push_back(Designator(Name, DotLoc, FieldLoc));
1219  break;
1220  }
1221 
1222  case DESIG_ARRAY: {
1223  unsigned Index = Record.readInt();
1224  SourceLocation LBracketLoc = readSourceLocation();
1225  SourceLocation RBracketLoc = readSourceLocation();
1226  Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
1227  break;
1228  }
1229 
1230  case DESIG_ARRAY_RANGE: {
1231  unsigned Index = Record.readInt();
1232  SourceLocation LBracketLoc = readSourceLocation();
1233  SourceLocation EllipsisLoc = readSourceLocation();
1234  SourceLocation RBracketLoc = readSourceLocation();
1235  Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
1236  RBracketLoc));
1237  break;
1238  }
1239  }
1240  }
1241  E->setDesignators(Record.getContext(),
1242  Designators.data(), Designators.size());
1243 }
1244 
1245 void ASTStmtReader::VisitDesignatedInitUpdateExpr(DesignatedInitUpdateExpr *E) {
1246  VisitExpr(E);
1247  E->setBase(Record.readSubExpr());
1248  E->setUpdater(Record.readSubExpr());
1249 }
1250 
1251 void ASTStmtReader::VisitNoInitExpr(NoInitExpr *E) {
1252  VisitExpr(E);
1253 }
1254 
1255 void ASTStmtReader::VisitArrayInitLoopExpr(ArrayInitLoopExpr *E) {
1256  VisitExpr(E);
1257  E->SubExprs[0] = Record.readSubExpr();
1258  E->SubExprs[1] = Record.readSubExpr();
1259 }
1260 
1261 void ASTStmtReader::VisitArrayInitIndexExpr(ArrayInitIndexExpr *E) {
1262  VisitExpr(E);
1263 }
1264 
1265 void ASTStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
1266  VisitExpr(E);
1267 }
1268 
1269 void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
1270  VisitExpr(E);
1271  E->setSubExpr(Record.readSubExpr());
1272  E->setWrittenTypeInfo(readTypeSourceInfo());
1273  E->setBuiltinLoc(readSourceLocation());
1274  E->setRParenLoc(readSourceLocation());
1275  E->setIsMicrosoftABI(Record.readInt());
1276 }
1277 
1278 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
1279  VisitExpr(E);
1280  E->ParentContext = readDeclAs<DeclContext>();
1281  E->BuiltinLoc = readSourceLocation();
1282  E->RParenLoc = readSourceLocation();
1283  E->SourceLocExprBits.Kind =
1284  static_cast<SourceLocExpr::IdentKind>(Record.readInt());
1285 }
1286 
1287 void ASTStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
1288  VisitExpr(E);
1289  E->setAmpAmpLoc(readSourceLocation());
1290  E->setLabelLoc(readSourceLocation());
1291  E->setLabel(readDeclAs<LabelDecl>());
1292 }
1293 
1294 void ASTStmtReader::VisitStmtExpr(StmtExpr *E) {
1295  VisitExpr(E);
1296  E->setLParenLoc(readSourceLocation());
1297  E->setRParenLoc(readSourceLocation());
1298  E->setSubStmt(cast_or_null<CompoundStmt>(Record.readSubStmt()));
1299  E->StmtExprBits.TemplateDepth = Record.readInt();
1300 }
1301 
1302 void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
1303  VisitExpr(E);
1304  E->setCond(Record.readSubExpr());
1305  E->setLHS(Record.readSubExpr());
1306  E->setRHS(Record.readSubExpr());
1307  E->setBuiltinLoc(readSourceLocation());
1308  E->setRParenLoc(readSourceLocation());
1309  E->setIsConditionTrue(Record.readInt());
1310 }
1311 
1312 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
1313  VisitExpr(E);
1314  E->setTokenLocation(readSourceLocation());
1315 }
1316 
1317 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
1318  VisitExpr(E);
1320  unsigned NumExprs = Record.readInt();
1321  while (NumExprs--)
1322  Exprs.push_back(Record.readSubExpr());
1323  E->setExprs(Record.getContext(), Exprs);
1324  E->setBuiltinLoc(readSourceLocation());
1325  E->setRParenLoc(readSourceLocation());
1326 }
1327 
1328 void ASTStmtReader::VisitConvertVectorExpr(ConvertVectorExpr *E) {
1329  VisitExpr(E);
1330  E->BuiltinLoc = readSourceLocation();
1331  E->RParenLoc = readSourceLocation();
1332  E->TInfo = readTypeSourceInfo();
1333  E->SrcExpr = Record.readSubExpr();
1334 }
1335 
1336 void ASTStmtReader::VisitBlockExpr(BlockExpr *E) {
1337  VisitExpr(E);
1338  E->setBlockDecl(readDeclAs<BlockDecl>());
1339 }
1340 
1341 void ASTStmtReader::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
1342  VisitExpr(E);
1343 
1344  unsigned NumAssocs = Record.readInt();
1345  assert(NumAssocs == E->getNumAssocs() && "Wrong NumAssocs!");
1346  E->ResultIndex = Record.readInt();
1347  E->GenericSelectionExprBits.GenericLoc = readSourceLocation();
1348  E->DefaultLoc = readSourceLocation();
1349  E->RParenLoc = readSourceLocation();
1350 
1351  Stmt **Stmts = E->getTrailingObjects<Stmt *>();
1352  // Add 1 to account for the controlling expression which is the first
1353  // expression in the trailing array of Stmt *. This is not needed for
1354  // the trailing array of TypeSourceInfo *.
1355  for (unsigned I = 0, N = NumAssocs + 1; I < N; ++I)
1356  Stmts[I] = Record.readSubExpr();
1357 
1358  TypeSourceInfo **TSIs = E->getTrailingObjects<TypeSourceInfo *>();
1359  for (unsigned I = 0, N = NumAssocs; I < N; ++I)
1360  TSIs[I] = readTypeSourceInfo();
1361 }
1362 
1363 void ASTStmtReader::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
1364  VisitExpr(E);
1365  unsigned numSemanticExprs = Record.readInt();
1366  assert(numSemanticExprs + 1 == E->PseudoObjectExprBits.NumSubExprs);
1367  E->PseudoObjectExprBits.ResultIndex = Record.readInt();
1368 
1369  // Read the syntactic expression.
1370  E->getSubExprsBuffer()[0] = Record.readSubExpr();
1371 
1372  // Read all the semantic expressions.
1373  for (unsigned i = 0; i != numSemanticExprs; ++i) {
1374  Expr *subExpr = Record.readSubExpr();
1375  E->getSubExprsBuffer()[i+1] = subExpr;
1376  }
1377 }
1378 
1379 void ASTStmtReader::VisitAtomicExpr(AtomicExpr *E) {
1380  VisitExpr(E);
1381  E->Op = AtomicExpr::AtomicOp(Record.readInt());
1382  E->NumSubExprs = AtomicExpr::getNumSubExprs(E->Op);
1383  for (unsigned I = 0; I != E->NumSubExprs; ++I)
1384  E->SubExprs[I] = Record.readSubExpr();
1385  E->BuiltinLoc = readSourceLocation();
1386  E->RParenLoc = readSourceLocation();
1387 }
1388 
1389 //===----------------------------------------------------------------------===//
1390 // Objective-C Expressions and Statements
1391 
1392 void ASTStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
1393  VisitExpr(E);
1394  E->setString(cast<StringLiteral>(Record.readSubStmt()));
1395  E->setAtLoc(readSourceLocation());
1396 }
1397 
1398 void ASTStmtReader::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
1399  VisitExpr(E);
1400  // could be one of several IntegerLiteral, FloatLiteral, etc.
1401  E->SubExpr = Record.readSubStmt();
1402  E->BoxingMethod = readDeclAs<ObjCMethodDecl>();
1403  E->Range = readSourceRange();
1404 }
1405 
1406 void ASTStmtReader::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
1407  VisitExpr(E);
1408  unsigned NumElements = Record.readInt();
1409  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1410  Expr **Elements = E->getElements();
1411  for (unsigned I = 0, N = NumElements; I != N; ++I)
1412  Elements[I] = Record.readSubExpr();
1413  E->ArrayWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1414  E->Range = readSourceRange();
1415 }
1416 
1417 void ASTStmtReader::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
1418  VisitExpr(E);
1419  unsigned NumElements = Record.readInt();
1420  assert(NumElements == E->getNumElements() && "Wrong number of elements");
1421  bool HasPackExpansions = Record.readInt();
1422  assert(HasPackExpansions == E->HasPackExpansions &&"Pack expansion mismatch");
1423  auto *KeyValues =
1424  E->getTrailingObjects<ObjCDictionaryLiteral::KeyValuePair>();
1425  auto *Expansions =
1426  E->getTrailingObjects<ObjCDictionaryLiteral::ExpansionData>();
1427  for (unsigned I = 0; I != NumElements; ++I) {
1428  KeyValues[I].Key = Record.readSubExpr();
1429  KeyValues[I].Value = Record.readSubExpr();
1430  if (HasPackExpansions) {
1431  Expansions[I].EllipsisLoc = readSourceLocation();
1432  Expansions[I].NumExpansionsPlusOne = Record.readInt();
1433  }
1434  }
1435  E->DictWithObjectsMethod = readDeclAs<ObjCMethodDecl>();
1436  E->Range = readSourceRange();
1437 }
1438 
1439 void ASTStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
1440  VisitExpr(E);
1441  E->setEncodedTypeSourceInfo(readTypeSourceInfo());
1442  E->setAtLoc(readSourceLocation());
1443  E->setRParenLoc(readSourceLocation());
1444 }
1445 
1446 void ASTStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
1447  VisitExpr(E);
1448  E->setSelector(Record.readSelector());
1449  E->setAtLoc(readSourceLocation());
1450  E->setRParenLoc(readSourceLocation());
1451 }
1452 
1453 void ASTStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
1454  VisitExpr(E);
1455  E->setProtocol(readDeclAs<ObjCProtocolDecl>());
1456  E->setAtLoc(readSourceLocation());
1457  E->ProtoLoc = readSourceLocation();
1458  E->setRParenLoc(readSourceLocation());
1459 }
1460 
1461 void ASTStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
1462  VisitExpr(E);
1463  E->setDecl(readDeclAs<ObjCIvarDecl>());
1464  E->setLocation(readSourceLocation());
1465  E->setOpLoc(readSourceLocation());
1466  E->setBase(Record.readSubExpr());
1467  E->setIsArrow(Record.readInt());
1468  E->setIsFreeIvar(Record.readInt());
1469 }
1470 
1471 void ASTStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
1472  VisitExpr(E);
1473  unsigned MethodRefFlags = Record.readInt();
1474  bool Implicit = Record.readInt() != 0;
1475  if (Implicit) {
1476  auto *Getter = readDeclAs<ObjCMethodDecl>();
1477  auto *Setter = readDeclAs<ObjCMethodDecl>();
1478  E->setImplicitProperty(Getter, Setter, MethodRefFlags);
1479  } else {
1480  E->setExplicitProperty(readDeclAs<ObjCPropertyDecl>(), MethodRefFlags);
1481  }
1482  E->setLocation(readSourceLocation());
1483  E->setReceiverLocation(readSourceLocation());
1484  switch (Record.readInt()) {
1485  case 0:
1486  E->setBase(Record.readSubExpr());
1487  break;
1488  case 1:
1489  E->setSuperReceiver(Record.readType());
1490  break;
1491  case 2:
1492  E->setClassReceiver(readDeclAs<ObjCInterfaceDecl>());
1493  break;
1494  }
1495 }
1496 
1497 void ASTStmtReader::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
1498  VisitExpr(E);
1499  E->setRBracket(readSourceLocation());
1500  E->setBaseExpr(Record.readSubExpr());
1501  E->setKeyExpr(Record.readSubExpr());
1502  E->GetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1503  E->SetAtIndexMethodDecl = readDeclAs<ObjCMethodDecl>();
1504 }
1505 
1506 void ASTStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
1507  VisitExpr(E);
1508  assert(Record.peekInt() == E->getNumArgs());
1509  Record.skipInts(1);
1510  unsigned NumStoredSelLocs = Record.readInt();
1511  E->SelLocsKind = Record.readInt();
1512  E->setDelegateInitCall(Record.readInt());
1513  E->IsImplicit = Record.readInt();
1514  auto Kind = static_cast<ObjCMessageExpr::ReceiverKind>(Record.readInt());
1515  switch (Kind) {
1517  E->setInstanceReceiver(Record.readSubExpr());
1518  break;
1519 
1521  E->setClassReceiver(readTypeSourceInfo());
1522  break;
1523 
1526  QualType T = Record.readType();
1527  SourceLocation SuperLoc = readSourceLocation();
1528  E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
1529  break;
1530  }
1531  }
1532 
1533  assert(Kind == E->getReceiverKind());
1534 
1535  if (Record.readInt())
1536  E->setMethodDecl(readDeclAs<ObjCMethodDecl>());
1537  else
1538  E->setSelector(Record.readSelector());
1539 
1540  E->LBracLoc = readSourceLocation();
1541  E->RBracLoc = readSourceLocation();
1542 
1543  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1544  E->setArg(I, Record.readSubExpr());
1545 
1546  SourceLocation *Locs = E->getStoredSelLocs();
1547  for (unsigned I = 0; I != NumStoredSelLocs; ++I)
1548  Locs[I] = readSourceLocation();
1549 }
1550 
1551 void ASTStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
1552  VisitStmt(S);
1553  S->setElement(Record.readSubStmt());
1554  S->setCollection(Record.readSubExpr());
1555  S->setBody(Record.readSubStmt());
1556  S->setForLoc(readSourceLocation());
1557  S->setRParenLoc(readSourceLocation());
1558 }
1559 
1560 void ASTStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
1561  VisitStmt(S);
1562  S->setCatchBody(Record.readSubStmt());
1563  S->setCatchParamDecl(readDeclAs<VarDecl>());
1564  S->setAtCatchLoc(readSourceLocation());
1565  S->setRParenLoc(readSourceLocation());
1566 }
1567 
1568 void ASTStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
1569  VisitStmt(S);
1570  S->setFinallyBody(Record.readSubStmt());
1571  S->setAtFinallyLoc(readSourceLocation());
1572 }
1573 
1574 void ASTStmtReader::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
1575  VisitStmt(S); // FIXME: no test coverage.
1576  S->setSubStmt(Record.readSubStmt());
1577  S->setAtLoc(readSourceLocation());
1578 }
1579 
1580 void ASTStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
1581  VisitStmt(S);
1582  assert(Record.peekInt() == S->getNumCatchStmts());
1583  Record.skipInts(1);
1584  bool HasFinally = Record.readInt();
1585  S->setTryBody(Record.readSubStmt());
1586  for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
1587  S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Record.readSubStmt()));
1588 
1589  if (HasFinally)
1590  S->setFinallyStmt(Record.readSubStmt());
1591  S->setAtTryLoc(readSourceLocation());
1592 }
1593 
1594 void ASTStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1595  VisitStmt(S); // FIXME: no test coverage.
1596  S->setSynchExpr(Record.readSubStmt());
1597  S->setSynchBody(Record.readSubStmt());
1598  S->setAtSynchronizedLoc(readSourceLocation());
1599 }
1600 
1601 void ASTStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
1602  VisitStmt(S); // FIXME: no test coverage.
1603  S->setThrowExpr(Record.readSubStmt());
1604  S->setThrowLoc(readSourceLocation());
1605 }
1606 
1607 void ASTStmtReader::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1608  VisitExpr(E);
1609  E->setValue(Record.readInt());
1610  E->setLocation(readSourceLocation());
1611 }
1612 
1613 void ASTStmtReader::VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {
1614  VisitExpr(E);
1615  SourceRange R = Record.readSourceRange();
1616  E->AtLoc = R.getBegin();
1617  E->RParen = R.getEnd();
1618  E->VersionToCheck = Record.readVersionTuple();
1619 }
1620 
1621 //===----------------------------------------------------------------------===//
1622 // C++ Expressions and Statements
1623 //===----------------------------------------------------------------------===//
1624 
1625 void ASTStmtReader::VisitCXXCatchStmt(CXXCatchStmt *S) {
1626  VisitStmt(S);
1627  S->CatchLoc = readSourceLocation();
1628  S->ExceptionDecl = readDeclAs<VarDecl>();
1629  S->HandlerBlock = Record.readSubStmt();
1630 }
1631 
1632 void ASTStmtReader::VisitCXXTryStmt(CXXTryStmt *S) {
1633  VisitStmt(S);
1634  assert(Record.peekInt() == S->getNumHandlers() && "NumStmtFields is wrong ?");
1635  Record.skipInts(1);
1636  S->TryLoc = readSourceLocation();
1637  S->getStmts()[0] = Record.readSubStmt();
1638  for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1639  S->getStmts()[i + 1] = Record.readSubStmt();
1640 }
1641 
1642 void ASTStmtReader::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1643  VisitStmt(S);
1644  S->ForLoc = readSourceLocation();
1645  S->CoawaitLoc = readSourceLocation();
1646  S->ColonLoc = readSourceLocation();
1647  S->RParenLoc = readSourceLocation();
1648  S->setInit(Record.readSubStmt());
1649  S->setRangeStmt(Record.readSubStmt());
1650  S->setBeginStmt(Record.readSubStmt());
1651  S->setEndStmt(Record.readSubStmt());
1652  S->setCond(Record.readSubExpr());
1653  S->setInc(Record.readSubExpr());
1654  S->setLoopVarStmt(Record.readSubStmt());
1655  S->setBody(Record.readSubStmt());
1656 }
1657 
1658 void ASTStmtReader::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1659  VisitStmt(S);
1660  S->KeywordLoc = readSourceLocation();
1661  S->IsIfExists = Record.readInt();
1662  S->QualifierLoc = Record.readNestedNameSpecifierLoc();
1663  S->NameInfo = Record.readDeclarationNameInfo();
1664  S->SubStmt = Record.readSubStmt();
1665 }
1666 
1667 void ASTStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1668  VisitCallExpr(E);
1669  E->CXXOperatorCallExprBits.OperatorKind = Record.readInt();
1670  E->Range = Record.readSourceRange();
1671 }
1672 
1673 void ASTStmtReader::VisitCXXRewrittenBinaryOperator(
1675  VisitExpr(E);
1676  E->CXXRewrittenBinaryOperatorBits.IsReversed = Record.readInt();
1677  E->SemanticForm = Record.readSubExpr();
1678 }
1679 
1680 void ASTStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
1681  VisitExpr(E);
1682 
1683  unsigned NumArgs = Record.readInt();
1684  assert((NumArgs == E->getNumArgs()) && "Wrong NumArgs!");
1685 
1686  E->CXXConstructExprBits.Elidable = Record.readInt();
1687  E->CXXConstructExprBits.HadMultipleCandidates = Record.readInt();
1688  E->CXXConstructExprBits.ListInitialization = Record.readInt();
1689  E->CXXConstructExprBits.StdInitListInitialization = Record.readInt();
1690  E->CXXConstructExprBits.ZeroInitialization = Record.readInt();
1691  E->CXXConstructExprBits.ConstructionKind = Record.readInt();
1692  E->CXXConstructExprBits.Loc = readSourceLocation();
1693  E->Constructor = readDeclAs<CXXConstructorDecl>();
1694  E->ParenOrBraceRange = readSourceRange();
1695 
1696  for (unsigned I = 0; I != NumArgs; ++I)
1697  E->setArg(I, Record.readSubExpr());
1698 }
1699 
1700 void ASTStmtReader::VisitCXXInheritedCtorInitExpr(CXXInheritedCtorInitExpr *E) {
1701  VisitExpr(E);
1702  E->Constructor = readDeclAs<CXXConstructorDecl>();
1703  E->Loc = readSourceLocation();
1704  E->ConstructsVirtualBase = Record.readInt();
1705  E->InheritedFromVirtualBase = Record.readInt();
1706 }
1707 
1708 void ASTStmtReader::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1709  VisitCXXConstructExpr(E);
1710  E->TSI = readTypeSourceInfo();
1711 }
1712 
1713 void ASTStmtReader::VisitLambdaExpr(LambdaExpr *E) {
1714  VisitExpr(E);
1715  unsigned NumCaptures = Record.readInt();
1716  (void)NumCaptures;
1717  assert(NumCaptures == E->LambdaExprBits.NumCaptures);
1718  E->IntroducerRange = readSourceRange();
1719  E->LambdaExprBits.CaptureDefault = Record.readInt();
1720  E->CaptureDefaultLoc = readSourceLocation();
1721  E->LambdaExprBits.ExplicitParams = Record.readInt();
1722  E->LambdaExprBits.ExplicitResultType = Record.readInt();
1723  E->ClosingBrace = readSourceLocation();
1724 
1725  // Read capture initializers.
1727  CEnd = E->capture_init_end();
1728  C != CEnd; ++C)
1729  *C = Record.readSubExpr();
1730 
1731  // The body will be lazily deserialized when needed from the call operator
1732  // declaration.
1733 }
1734 
1735 void
1736 ASTStmtReader::VisitCXXStdInitializerListExpr(CXXStdInitializerListExpr *E) {
1737  VisitExpr(E);
1738  E->SubExpr = Record.readSubExpr();
1739 }
1740 
1741 void ASTStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1742  VisitExplicitCastExpr(E);
1743  SourceRange R = readSourceRange();
1744  E->Loc = R.getBegin();
1745  E->RParenLoc = R.getEnd();
1746  R = readSourceRange();
1747  E->AngleBrackets = R;
1748 }
1749 
1750 void ASTStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1751  return VisitCXXNamedCastExpr(E);
1752 }
1753 
1754 void ASTStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1755  return VisitCXXNamedCastExpr(E);
1756 }
1757 
1758 void ASTStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1759  return VisitCXXNamedCastExpr(E);
1760 }
1761 
1762 void ASTStmtReader::VisitCXXAddrspaceCastExpr(CXXAddrspaceCastExpr *E) {
1763  return VisitCXXNamedCastExpr(E);
1764 }
1765 
1766 void ASTStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1767  return VisitCXXNamedCastExpr(E);
1768 }
1769 
1770 void ASTStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1771  VisitExplicitCastExpr(E);
1772  E->setLParenLoc(readSourceLocation());
1773  E->setRParenLoc(readSourceLocation());
1774 }
1775 
1776 void ASTStmtReader::VisitBuiltinBitCastExpr(BuiltinBitCastExpr *E) {
1777  VisitExplicitCastExpr(E);
1778  E->KWLoc = readSourceLocation();
1779  E->RParenLoc = readSourceLocation();
1780 }
1781 
1782 void ASTStmtReader::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1783  VisitCallExpr(E);
1784  E->UDSuffixLoc = readSourceLocation();
1785 }
1786 
1787 void ASTStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1788  VisitExpr(E);
1789  E->setValue(Record.readInt());
1790  E->setLocation(readSourceLocation());
1791 }
1792 
1793 void ASTStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1794  VisitExpr(E);
1795  E->setLocation(readSourceLocation());
1796 }
1797 
1798 void ASTStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1799  VisitExpr(E);
1800  E->setSourceRange(readSourceRange());
1801  if (E->isTypeOperand())
1802  E->Operand = readTypeSourceInfo();
1803  else
1804  E->Operand = Record.readSubExpr();
1805 }
1806 
1807 void ASTStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
1808  VisitExpr(E);
1809  E->setLocation(readSourceLocation());
1810  E->setImplicit(Record.readInt());
1811 }
1812 
1813 void ASTStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
1814  VisitExpr(E);
1815  E->CXXThrowExprBits.ThrowLoc = readSourceLocation();
1816  E->Operand = Record.readSubExpr();
1817  E->CXXThrowExprBits.IsThrownVariableInScope = Record.readInt();
1818 }
1819 
1820 void ASTStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1821  VisitExpr(E);
1822  E->Param = readDeclAs<ParmVarDecl>();
1823  E->UsedContext = readDeclAs<DeclContext>();
1824  E->CXXDefaultArgExprBits.Loc = readSourceLocation();
1825 }
1826 
1827 void ASTStmtReader::VisitCXXDefaultInitExpr(CXXDefaultInitExpr *E) {
1828  VisitExpr(E);
1829  E->Field = readDeclAs<FieldDecl>();
1830  E->UsedContext = readDeclAs<DeclContext>();
1831  E->CXXDefaultInitExprBits.Loc = readSourceLocation();
1832 }
1833 
1834 void ASTStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1835  VisitExpr(E);
1836  E->setTemporary(Record.readCXXTemporary());
1837  E->setSubExpr(Record.readSubExpr());
1838 }
1839 
1840 void ASTStmtReader::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1841  VisitExpr(E);
1842  E->TypeInfo = readTypeSourceInfo();
1843  E->CXXScalarValueInitExprBits.RParenLoc = readSourceLocation();
1844 }
1845 
1846 void ASTStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
1847  VisitExpr(E);
1848 
1849  bool IsArray = Record.readInt();
1850  bool HasInit = Record.readInt();
1851  unsigned NumPlacementArgs = Record.readInt();
1852  bool IsParenTypeId = Record.readInt();
1853 
1854  E->CXXNewExprBits.IsGlobalNew = Record.readInt();
1855  E->CXXNewExprBits.ShouldPassAlignment = Record.readInt();
1856  E->CXXNewExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1857  E->CXXNewExprBits.StoredInitializationStyle = Record.readInt();
1858 
1859  assert((IsArray == E->isArray()) && "Wrong IsArray!");
1860  assert((HasInit == E->hasInitializer()) && "Wrong HasInit!");
1861  assert((NumPlacementArgs == E->getNumPlacementArgs()) &&
1862  "Wrong NumPlacementArgs!");
1863  assert((IsParenTypeId == E->isParenTypeId()) && "Wrong IsParenTypeId!");
1864  (void)IsArray;
1865  (void)HasInit;
1866  (void)NumPlacementArgs;
1867 
1868  E->setOperatorNew(readDeclAs<FunctionDecl>());
1869  E->setOperatorDelete(readDeclAs<FunctionDecl>());
1870  E->AllocatedTypeInfo = readTypeSourceInfo();
1871  if (IsParenTypeId)
1872  E->getTrailingObjects<SourceRange>()[0] = readSourceRange();
1873  E->Range = readSourceRange();
1874  E->DirectInitRange = readSourceRange();
1875 
1876  // Install all the subexpressions.
1878  N = E->raw_arg_end();
1879  I != N; ++I)
1880  *I = Record.readSubStmt();
1881 }
1882 
1883 void ASTStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1884  VisitExpr(E);
1885  E->CXXDeleteExprBits.GlobalDelete = Record.readInt();
1886  E->CXXDeleteExprBits.ArrayForm = Record.readInt();
1887  E->CXXDeleteExprBits.ArrayFormAsWritten = Record.readInt();
1888  E->CXXDeleteExprBits.UsualArrayDeleteWantsSize = Record.readInt();
1889  E->OperatorDelete = readDeclAs<FunctionDecl>();
1890  E->Argument = Record.readSubExpr();
1891  E->CXXDeleteExprBits.Loc = readSourceLocation();
1892 }
1893 
1894 void ASTStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1895  VisitExpr(E);
1896 
1897  E->Base = Record.readSubExpr();
1898  E->IsArrow = Record.readInt();
1899  E->OperatorLoc = readSourceLocation();
1900  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1901  E->ScopeType = readTypeSourceInfo();
1902  E->ColonColonLoc = readSourceLocation();
1903  E->TildeLoc = readSourceLocation();
1904 
1905  IdentifierInfo *II = Record.readIdentifier();
1906  if (II)
1907  E->setDestroyedType(II, readSourceLocation());
1908  else
1909  E->setDestroyedType(readTypeSourceInfo());
1910 }
1911 
1912 void ASTStmtReader::VisitExprWithCleanups(ExprWithCleanups *E) {
1913  VisitExpr(E);
1914 
1915  unsigned NumObjects = Record.readInt();
1916  assert(NumObjects == E->getNumObjects());
1917  for (unsigned i = 0; i != NumObjects; ++i) {
1918  unsigned CleanupKind = Record.readInt();
1920  if (CleanupKind == COK_Block)
1921  Obj = readDeclAs<BlockDecl>();
1922  else if (CleanupKind == COK_CompoundLiteral)
1923  Obj = cast<CompoundLiteralExpr>(Record.readSubExpr());
1924  else
1925  llvm_unreachable("unexpected cleanup object type");
1926  E->getTrailingObjects<ExprWithCleanups::CleanupObject>()[i] = Obj;
1927  }
1928 
1929  E->ExprWithCleanupsBits.CleanupsHaveSideEffects = Record.readInt();
1930  E->SubExpr = Record.readSubExpr();
1931 }
1932 
1933 void ASTStmtReader::VisitCXXDependentScopeMemberExpr(
1935  VisitExpr(E);
1936 
1937  bool HasTemplateKWAndArgsInfo = Record.readInt();
1938  unsigned NumTemplateArgs = Record.readInt();
1939  bool HasFirstQualifierFoundInScope = Record.readInt();
1940 
1941  assert((HasTemplateKWAndArgsInfo == E->hasTemplateKWAndArgsInfo()) &&
1942  "Wrong HasTemplateKWAndArgsInfo!");
1943  assert(
1944  (HasFirstQualifierFoundInScope == E->hasFirstQualifierFoundInScope()) &&
1945  "Wrong HasFirstQualifierFoundInScope!");
1946 
1947  if (HasTemplateKWAndArgsInfo)
1948  ReadTemplateKWAndArgsInfo(
1949  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1950  E->getTrailingObjects<TemplateArgumentLoc>(), NumTemplateArgs);
1951 
1952  assert((NumTemplateArgs == E->getNumTemplateArgs()) &&
1953  "Wrong NumTemplateArgs!");
1954 
1955  E->CXXDependentScopeMemberExprBits.IsArrow = Record.readInt();
1956  E->CXXDependentScopeMemberExprBits.OperatorLoc = readSourceLocation();
1957  E->BaseType = Record.readType();
1958  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1959  E->Base = Record.readSubExpr();
1960 
1961  if (HasFirstQualifierFoundInScope)
1962  *E->getTrailingObjects<NamedDecl *>() = readDeclAs<NamedDecl>();
1963 
1964  E->MemberNameInfo = Record.readDeclarationNameInfo();
1965 }
1966 
1967 void
1968 ASTStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1969  VisitExpr(E);
1970 
1971  if (Record.readInt()) // HasTemplateKWAndArgsInfo
1972  ReadTemplateKWAndArgsInfo(
1973  *E->getTrailingObjects<ASTTemplateKWAndArgsInfo>(),
1974  E->getTrailingObjects<TemplateArgumentLoc>(),
1975  /*NumTemplateArgs=*/Record.readInt());
1976 
1977  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
1978  E->NameInfo = Record.readDeclarationNameInfo();
1979 }
1980 
1981 void
1982 ASTStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1983  VisitExpr(E);
1984  assert(Record.peekInt() == E->getNumArgs() &&
1985  "Read wrong record during creation ?");
1986  Record.skipInts(1);
1987  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1988  E->setArg(I, Record.readSubExpr());
1989  E->TSI = readTypeSourceInfo();
1990  E->setLParenLoc(readSourceLocation());
1991  E->setRParenLoc(readSourceLocation());
1992 }
1993 
1994 void ASTStmtReader::VisitOverloadExpr(OverloadExpr *E) {
1995  VisitExpr(E);
1996 
1997  unsigned NumResults = Record.readInt();
1998  bool HasTemplateKWAndArgsInfo = Record.readInt();
1999  assert((E->getNumDecls() == NumResults) && "Wrong NumResults!");
2000  assert((E->hasTemplateKWAndArgsInfo() == HasTemplateKWAndArgsInfo) &&
2001  "Wrong HasTemplateKWAndArgsInfo!");
2002 
2003  if (HasTemplateKWAndArgsInfo) {
2004  unsigned NumTemplateArgs = Record.readInt();
2005  ReadTemplateKWAndArgsInfo(*E->getTrailingASTTemplateKWAndArgsInfo(),
2007  NumTemplateArgs);
2008  assert((E->getNumTemplateArgs() == NumTemplateArgs) &&
2009  "Wrong NumTemplateArgs!");
2010  }
2011 
2012  UnresolvedSet<8> Decls;
2013  for (unsigned I = 0; I != NumResults; ++I) {
2014  auto *D = readDeclAs<NamedDecl>();
2015  auto AS = (AccessSpecifier)Record.readInt();
2016  Decls.addDecl(D, AS);
2017  }
2018 
2019  DeclAccessPair *Results = E->getTrailingResults();
2020  UnresolvedSetIterator Iter = Decls.begin();
2021  for (unsigned I = 0; I != NumResults; ++I) {
2022  Results[I] = (Iter + I).getPair();
2023  }
2024 
2025  E->NameInfo = Record.readDeclarationNameInfo();
2026  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2027 }
2028 
2029 void ASTStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
2030  VisitOverloadExpr(E);
2031  E->UnresolvedMemberExprBits.IsArrow = Record.readInt();
2032  E->UnresolvedMemberExprBits.HasUnresolvedUsing = Record.readInt();
2033  E->Base = Record.readSubExpr();
2034  E->BaseType = Record.readType();
2035  E->OperatorLoc = readSourceLocation();
2036 }
2037 
2038 void ASTStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
2039  VisitOverloadExpr(E);
2040  E->UnresolvedLookupExprBits.RequiresADL = Record.readInt();
2041  E->UnresolvedLookupExprBits.Overloaded = Record.readInt();
2042  E->NamingClass = readDeclAs<CXXRecordDecl>();
2043 }
2044 
2045 void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
2046  VisitExpr(E);
2047  E->TypeTraitExprBits.NumArgs = Record.readInt();
2048  E->TypeTraitExprBits.Kind = Record.readInt();
2049  E->TypeTraitExprBits.Value = Record.readInt();
2050  SourceRange Range = readSourceRange();
2051  E->Loc = Range.getBegin();
2052  E->RParenLoc = Range.getEnd();
2053 
2054  auto **Args = E->getTrailingObjects<TypeSourceInfo *>();
2055  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
2056  Args[I] = readTypeSourceInfo();
2057 }
2058 
2059 void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
2060  VisitExpr(E);
2061  E->ATT = (ArrayTypeTrait)Record.readInt();
2062  E->Value = (unsigned int)Record.readInt();
2063  SourceRange Range = readSourceRange();
2064  E->Loc = Range.getBegin();
2065  E->RParen = Range.getEnd();
2066  E->QueriedType = readTypeSourceInfo();
2067  E->Dimension = Record.readSubExpr();
2068 }
2069 
2070 void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
2071  VisitExpr(E);
2072  E->ET = (ExpressionTrait)Record.readInt();
2073  E->Value = (bool)Record.readInt();
2074  SourceRange Range = readSourceRange();
2075  E->QueriedExpression = Record.readSubExpr();
2076  E->Loc = Range.getBegin();
2077  E->RParen = Range.getEnd();
2078 }
2079 
2080 void ASTStmtReader::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
2081  VisitExpr(E);
2082  E->CXXNoexceptExprBits.Value = Record.readInt();
2083  E->Range = readSourceRange();
2084  E->Operand = Record.readSubExpr();
2085 }
2086 
2087 void ASTStmtReader::VisitPackExpansionExpr(PackExpansionExpr *E) {
2088  VisitExpr(E);
2089  E->EllipsisLoc = readSourceLocation();
2090  E->NumExpansions = Record.readInt();
2091  E->Pattern = Record.readSubExpr();
2092 }
2093 
2094 void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
2095  VisitExpr(E);
2096  unsigned NumPartialArgs = Record.readInt();
2097  E->OperatorLoc = readSourceLocation();
2098  E->PackLoc = readSourceLocation();
2099  E->RParenLoc = readSourceLocation();
2100  E->Pack = Record.readDeclAs<NamedDecl>();
2101  if (E->isPartiallySubstituted()) {
2102  assert(E->Length == NumPartialArgs);
2103  for (auto *I = E->getTrailingObjects<TemplateArgument>(),
2104  *E = I + NumPartialArgs;
2105  I != E; ++I)
2106  new (I) TemplateArgument(Record.readTemplateArgument());
2107  } else if (!E->isValueDependent()) {
2108  E->Length = Record.readInt();
2109  }
2110 }
2111 
2112 void ASTStmtReader::VisitSubstNonTypeTemplateParmExpr(
2114  VisitExpr(E);
2115  E->ParamAndRef.setPointer(readDeclAs<NonTypeTemplateParmDecl>());
2116  E->ParamAndRef.setInt(Record.readInt());
2117  E->SubstNonTypeTemplateParmExprBits.NameLoc = readSourceLocation();
2118  E->Replacement = Record.readSubExpr();
2119 }
2120 
2121 void ASTStmtReader::VisitSubstNonTypeTemplateParmPackExpr(
2123  VisitExpr(E);
2124  E->Param = readDeclAs<NonTypeTemplateParmDecl>();
2125  TemplateArgument ArgPack = Record.readTemplateArgument();
2126  if (ArgPack.getKind() != TemplateArgument::Pack)
2127  return;
2128 
2129  E->Arguments = ArgPack.pack_begin();
2130  E->NumArguments = ArgPack.pack_size();
2131  E->NameLoc = readSourceLocation();
2132 }
2133 
2134 void ASTStmtReader::VisitFunctionParmPackExpr(FunctionParmPackExpr *E) {
2135  VisitExpr(E);
2136  E->NumParameters = Record.readInt();
2137  E->ParamPack = readDeclAs<ParmVarDecl>();
2138  E->NameLoc = readSourceLocation();
2139  auto **Parms = E->getTrailingObjects<VarDecl *>();
2140  for (unsigned i = 0, n = E->NumParameters; i != n; ++i)
2141  Parms[i] = readDeclAs<VarDecl>();
2142 }
2143 
2144 void ASTStmtReader::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
2145  VisitExpr(E);
2146  bool HasMaterialzedDecl = Record.readInt();
2147  if (HasMaterialzedDecl)
2148  E->State = cast<LifetimeExtendedTemporaryDecl>(Record.readDecl());
2149  else
2150  E->State = Record.readSubExpr();
2151 }
2152 
2153 void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
2154  VisitExpr(E);
2155  E->LParenLoc = readSourceLocation();
2156  E->EllipsisLoc = readSourceLocation();
2157  E->RParenLoc = readSourceLocation();
2158  E->NumExpansions = Record.readInt();
2159  E->SubExprs[0] = Record.readSubExpr();
2160  E->SubExprs[1] = Record.readSubExpr();
2161  E->SubExprs[2] = Record.readSubExpr();
2162  E->Opcode = (BinaryOperatorKind)Record.readInt();
2163 }
2164 
2165 void ASTStmtReader::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
2166  VisitExpr(E);
2167  E->SourceExpr = Record.readSubExpr();
2168  E->OpaqueValueExprBits.Loc = readSourceLocation();
2169  E->setIsUnique(Record.readInt());
2170 }
2171 
2172 void ASTStmtReader::VisitTypoExpr(TypoExpr *E) {
2173  llvm_unreachable("Cannot read TypoExpr nodes");
2174 }
2175 
2176 void ASTStmtReader::VisitRecoveryExpr(RecoveryExpr *E) {
2177  VisitExpr(E);
2178  unsigned NumArgs = Record.readInt();
2179  E->BeginLoc = readSourceLocation();
2180  E->EndLoc = readSourceLocation();
2181  assert((NumArgs + 0LL ==
2182  std::distance(E->children().begin(), E->children().end())) &&
2183  "Wrong NumArgs!");
2184  (void)NumArgs;
2185  for (Stmt *&Child : E->children())
2186  Child = Record.readSubStmt();
2187 }
2188 
2189 //===----------------------------------------------------------------------===//
2190 // Microsoft Expressions and Statements
2191 //===----------------------------------------------------------------------===//
2192 void ASTStmtReader::VisitMSPropertyRefExpr(MSPropertyRefExpr *E) {
2193  VisitExpr(E);
2194  E->IsArrow = (Record.readInt() != 0);
2195  E->BaseExpr = Record.readSubExpr();
2196  E->QualifierLoc = Record.readNestedNameSpecifierLoc();
2197  E->MemberLoc = readSourceLocation();
2198  E->TheDecl = readDeclAs<MSPropertyDecl>();
2199 }
2200 
2201 void ASTStmtReader::VisitMSPropertySubscriptExpr(MSPropertySubscriptExpr *E) {
2202  VisitExpr(E);
2203  E->setBase(Record.readSubExpr());
2204  E->setIdx(Record.readSubExpr());
2205  E->setRBracketLoc(readSourceLocation());
2206 }
2207 
2208 void ASTStmtReader::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
2209  VisitExpr(E);
2210  E->setSourceRange(readSourceRange());
2211  E->Guid = readDeclAs<MSGuidDecl>();
2212  if (E->isTypeOperand())
2213  E->Operand = readTypeSourceInfo();
2214  else
2215  E->Operand = Record.readSubExpr();
2216 }
2217 
2218 void ASTStmtReader::VisitSEHLeaveStmt(SEHLeaveStmt *S) {
2219  VisitStmt(S);
2220  S->setLeaveLoc(readSourceLocation());
2221 }
2222 
2223 void ASTStmtReader::VisitSEHExceptStmt(SEHExceptStmt *S) {
2224  VisitStmt(S);
2225  S->Loc = readSourceLocation();
2226  S->Children[SEHExceptStmt::FILTER_EXPR] = Record.readSubStmt();
2227  S->Children[SEHExceptStmt::BLOCK] = Record.readSubStmt();
2228 }
2229 
2230 void ASTStmtReader::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
2231  VisitStmt(S);
2232  S->Loc = readSourceLocation();
2233  S->Block = Record.readSubStmt();
2234 }
2235 
2236 void ASTStmtReader::VisitSEHTryStmt(SEHTryStmt *S) {
2237  VisitStmt(S);
2238  S->IsCXXTry = Record.readInt();
2239  S->TryLoc = readSourceLocation();
2240  S->Children[SEHTryStmt::TRY] = Record.readSubStmt();
2241  S->Children[SEHTryStmt::HANDLER] = Record.readSubStmt();
2242 }
2243 
2244 //===----------------------------------------------------------------------===//
2245 // CUDA Expressions and Statements
2246 //===----------------------------------------------------------------------===//
2247 
2248 void ASTStmtReader::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
2249  VisitCallExpr(E);
2250  E->setPreArg(CUDAKernelCallExpr::CONFIG, Record.readSubExpr());
2251 }
2252 
2253 //===----------------------------------------------------------------------===//
2254 // OpenCL Expressions and Statements.
2255 //===----------------------------------------------------------------------===//
2256 void ASTStmtReader::VisitAsTypeExpr(AsTypeExpr *E) {
2257  VisitExpr(E);
2258  E->BuiltinLoc = readSourceLocation();
2259  E->RParenLoc = readSourceLocation();
2260  E->SrcExpr = Record.readSubExpr();
2261 }
2262 
2263 //===----------------------------------------------------------------------===//
2264 // OpenMP Directives.
2265 //===----------------------------------------------------------------------===//
2266 
2267 void ASTStmtReader::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {
2268  VisitStmt(S);
2269  for (Stmt *&SubStmt : S->SubStmts)
2270  SubStmt = Record.readSubStmt();
2271 }
2272 
2273 void ASTStmtReader::VisitOMPExecutableDirective(OMPExecutableDirective *E) {
2274  Record.readOMPChildren(E->Data);
2275  E->setLocStart(readSourceLocation());
2276  E->setLocEnd(readSourceLocation());
2277 }
2278 
2279 void ASTStmtReader::VisitOMPLoopBasedDirective(OMPLoopBasedDirective *D) {
2280  VisitStmt(D);
2281  // Field CollapsedNum was read in ReadStmtFromStream.
2282  Record.skipInts(1);
2283  VisitOMPExecutableDirective(D);
2284 }
2285 
2286 void ASTStmtReader::VisitOMPLoopDirective(OMPLoopDirective *D) {
2287  VisitOMPLoopBasedDirective(D);
2288 }
2289 
2290 void ASTStmtReader::VisitOMPMetaDirective(OMPMetaDirective *D) {
2291  VisitStmt(D);
2292  // The NumClauses field was read in ReadStmtFromStream.
2293  Record.skipInts(1);
2294  VisitOMPExecutableDirective(D);
2295 }
2296 
2297 void ASTStmtReader::VisitOMPParallelDirective(OMPParallelDirective *D) {
2298  VisitStmt(D);
2299  VisitOMPExecutableDirective(D);
2300  D->setHasCancel(Record.readBool());
2301 }
2302 
2303 void ASTStmtReader::VisitOMPSimdDirective(OMPSimdDirective *D) {
2304  VisitOMPLoopDirective(D);
2305 }
2306 
2307 void ASTStmtReader::VisitOMPLoopTransformationDirective(
2309  VisitOMPLoopBasedDirective(D);
2310  D->setNumGeneratedLoops(Record.readUInt32());
2311 }
2312 
2313 void ASTStmtReader::VisitOMPTileDirective(OMPTileDirective *D) {
2314  VisitOMPLoopTransformationDirective(D);
2315 }
2316 
2317 void ASTStmtReader::VisitOMPUnrollDirective(OMPUnrollDirective *D) {
2318  VisitOMPLoopTransformationDirective(D);
2319 }
2320 
2321 void ASTStmtReader::VisitOMPForDirective(OMPForDirective *D) {
2322  VisitOMPLoopDirective(D);
2323  D->setHasCancel(Record.readBool());
2324 }
2325 
2326 void ASTStmtReader::VisitOMPForSimdDirective(OMPForSimdDirective *D) {
2327  VisitOMPLoopDirective(D);
2328 }
2329 
2330 void ASTStmtReader::VisitOMPSectionsDirective(OMPSectionsDirective *D) {
2331  VisitStmt(D);
2332  VisitOMPExecutableDirective(D);
2333  D->setHasCancel(Record.readBool());
2334 }
2335 
2336 void ASTStmtReader::VisitOMPSectionDirective(OMPSectionDirective *D) {
2337  VisitStmt(D);
2338  VisitOMPExecutableDirective(D);
2339  D->setHasCancel(Record.readBool());
2340 }
2341 
2342 void ASTStmtReader::VisitOMPSingleDirective(OMPSingleDirective *D) {
2343  VisitStmt(D);
2344  VisitOMPExecutableDirective(D);
2345 }
2346 
2347 void ASTStmtReader::VisitOMPMasterDirective(OMPMasterDirective *D) {
2348  VisitStmt(D);
2349  VisitOMPExecutableDirective(D);
2350 }
2351 
2352 void ASTStmtReader::VisitOMPCriticalDirective(OMPCriticalDirective *D) {
2353  VisitStmt(D);
2354  VisitOMPExecutableDirective(D);
2355  D->DirName = Record.readDeclarationNameInfo();
2356 }
2357 
2358 void ASTStmtReader::VisitOMPParallelForDirective(OMPParallelForDirective *D) {
2359  VisitOMPLoopDirective(D);
2360  D->setHasCancel(Record.readBool());
2361 }
2362 
2363 void ASTStmtReader::VisitOMPParallelForSimdDirective(
2365  VisitOMPLoopDirective(D);
2366 }
2367 
2368 void ASTStmtReader::VisitOMPParallelMasterDirective(
2370  VisitStmt(D);
2371  VisitOMPExecutableDirective(D);
2372 }
2373 
2374 void ASTStmtReader::VisitOMPParallelSectionsDirective(
2376  VisitStmt(D);
2377  VisitOMPExecutableDirective(D);
2378  D->setHasCancel(Record.readBool());
2379 }
2380 
2381 void ASTStmtReader::VisitOMPTaskDirective(OMPTaskDirective *D) {
2382  VisitStmt(D);
2383  VisitOMPExecutableDirective(D);
2384  D->setHasCancel(Record.readBool());
2385 }
2386 
2387 void ASTStmtReader::VisitOMPTaskyieldDirective(OMPTaskyieldDirective *D) {
2388  VisitStmt(D);
2389  VisitOMPExecutableDirective(D);
2390 }
2391 
2392 void ASTStmtReader::VisitOMPBarrierDirective(OMPBarrierDirective *D) {
2393  VisitStmt(D);
2394  VisitOMPExecutableDirective(D);
2395 }
2396 
2397 void ASTStmtReader::VisitOMPTaskwaitDirective(OMPTaskwaitDirective *D) {
2398  VisitStmt(D);
2399  // The NumClauses field was read in ReadStmtFromStream.
2400  Record.skipInts(1);
2401  VisitOMPExecutableDirective(D);
2402 }
2403 
2404 void ASTStmtReader::VisitOMPTaskgroupDirective(OMPTaskgroupDirective *D) {
2405  VisitStmt(D);
2406  VisitOMPExecutableDirective(D);
2407 }
2408 
2409 void ASTStmtReader::VisitOMPFlushDirective(OMPFlushDirective *D) {
2410  VisitStmt(D);
2411  VisitOMPExecutableDirective(D);
2412 }
2413 
2414 void ASTStmtReader::VisitOMPDepobjDirective(OMPDepobjDirective *D) {
2415  VisitStmt(D);
2416  VisitOMPExecutableDirective(D);
2417 }
2418 
2419 void ASTStmtReader::VisitOMPScanDirective(OMPScanDirective *D) {
2420  VisitStmt(D);
2421  VisitOMPExecutableDirective(D);
2422 }
2423 
2424 void ASTStmtReader::VisitOMPOrderedDirective(OMPOrderedDirective *D) {
2425  VisitStmt(D);
2426  VisitOMPExecutableDirective(D);
2427 }
2428 
2429 void ASTStmtReader::VisitOMPAtomicDirective(OMPAtomicDirective *D) {
2430  VisitStmt(D);
2431  VisitOMPExecutableDirective(D);
2432  D->Flags.IsXLHSInRHSPart = Record.readBool() ? 1 : 0;
2433  D->Flags.IsPostfixUpdate = Record.readBool() ? 1 : 0;
2434 }
2435 
2436 void ASTStmtReader::VisitOMPTargetDirective(OMPTargetDirective *D) {
2437  VisitStmt(D);
2438  VisitOMPExecutableDirective(D);
2439 }
2440 
2441 void ASTStmtReader::VisitOMPTargetDataDirective(OMPTargetDataDirective *D) {
2442  VisitStmt(D);
2443  VisitOMPExecutableDirective(D);
2444 }
2445 
2446 void ASTStmtReader::VisitOMPTargetEnterDataDirective(
2448  VisitStmt(D);
2449  VisitOMPExecutableDirective(D);
2450 }
2451 
2452 void ASTStmtReader::VisitOMPTargetExitDataDirective(
2454  VisitStmt(D);
2455  VisitOMPExecutableDirective(D);
2456 }
2457 
2458 void ASTStmtReader::VisitOMPTargetParallelDirective(
2460  VisitStmt(D);
2461  VisitOMPExecutableDirective(D);
2462  D->setHasCancel(Record.readBool());
2463 }
2464 
2465 void ASTStmtReader::VisitOMPTargetParallelForDirective(
2467  VisitOMPLoopDirective(D);
2468  D->setHasCancel(Record.readBool());
2469 }
2470 
2471 void ASTStmtReader::VisitOMPTeamsDirective(OMPTeamsDirective *D) {
2472  VisitStmt(D);
2473  VisitOMPExecutableDirective(D);
2474 }
2475 
2476 void ASTStmtReader::VisitOMPCancellationPointDirective(
2478  VisitStmt(D);
2479  VisitOMPExecutableDirective(D);
2480  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2481 }
2482 
2483 void ASTStmtReader::VisitOMPCancelDirective(OMPCancelDirective *D) {
2484  VisitStmt(D);
2485  VisitOMPExecutableDirective(D);
2486  D->setCancelRegion(Record.readEnum<OpenMPDirectiveKind>());
2487 }
2488 
2489 void ASTStmtReader::VisitOMPTaskLoopDirective(OMPTaskLoopDirective *D) {
2490  VisitOMPLoopDirective(D);
2491  D->setHasCancel(Record.readBool());
2492 }
2493 
2494 void ASTStmtReader::VisitOMPTaskLoopSimdDirective(OMPTaskLoopSimdDirective *D) {
2495  VisitOMPLoopDirective(D);
2496 }
2497 
2498 void ASTStmtReader::VisitOMPMasterTaskLoopDirective(
2500  VisitOMPLoopDirective(D);
2501  D->setHasCancel(Record.readBool());
2502 }
2503 
2504 void ASTStmtReader::VisitOMPMasterTaskLoopSimdDirective(
2506  VisitOMPLoopDirective(D);
2507 }
2508 
2509 void ASTStmtReader::VisitOMPParallelMasterTaskLoopDirective(
2511  VisitOMPLoopDirective(D);
2512  D->setHasCancel(Record.readBool());
2513 }
2514 
2515 void ASTStmtReader::VisitOMPParallelMasterTaskLoopSimdDirective(
2517  VisitOMPLoopDirective(D);
2518 }
2519 
2520 void ASTStmtReader::VisitOMPDistributeDirective(OMPDistributeDirective *D) {
2521  VisitOMPLoopDirective(D);
2522 }
2523 
2524 void ASTStmtReader::VisitOMPTargetUpdateDirective(OMPTargetUpdateDirective *D) {
2525  VisitStmt(D);
2526  VisitOMPExecutableDirective(D);
2527 }
2528 
2529 void ASTStmtReader::VisitOMPDistributeParallelForDirective(
2531  VisitOMPLoopDirective(D);
2532  D->setHasCancel(Record.readBool());
2533 }
2534 
2535 void ASTStmtReader::VisitOMPDistributeParallelForSimdDirective(
2537  VisitOMPLoopDirective(D);
2538 }
2539 
2540 void ASTStmtReader::VisitOMPDistributeSimdDirective(
2542  VisitOMPLoopDirective(D);
2543 }
2544 
2545 void ASTStmtReader::VisitOMPTargetParallelForSimdDirective(
2547  VisitOMPLoopDirective(D);
2548 }
2549 
2550 void ASTStmtReader::VisitOMPTargetSimdDirective(OMPTargetSimdDirective *D) {
2551  VisitOMPLoopDirective(D);
2552 }
2553 
2554 void ASTStmtReader::VisitOMPTeamsDistributeDirective(
2556  VisitOMPLoopDirective(D);
2557 }
2558 
2559 void ASTStmtReader::VisitOMPTeamsDistributeSimdDirective(
2561  VisitOMPLoopDirective(D);
2562 }
2563 
2564 void ASTStmtReader::VisitOMPTeamsDistributeParallelForSimdDirective(
2566  VisitOMPLoopDirective(D);
2567 }
2568 
2569 void ASTStmtReader::VisitOMPTeamsDistributeParallelForDirective(
2571  VisitOMPLoopDirective(D);
2572  D->setHasCancel(Record.readBool());
2573 }
2574 
2575 void ASTStmtReader::VisitOMPTargetTeamsDirective(OMPTargetTeamsDirective *D) {
2576  VisitStmt(D);
2577  VisitOMPExecutableDirective(D);
2578 }
2579 
2580 void ASTStmtReader::VisitOMPTargetTeamsDistributeDirective(
2582  VisitOMPLoopDirective(D);
2583 }
2584 
2585 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForDirective(
2587  VisitOMPLoopDirective(D);
2588  D->setHasCancel(Record.readBool());
2589 }
2590 
2591 void ASTStmtReader::VisitOMPTargetTeamsDistributeParallelForSimdDirective(
2593  VisitOMPLoopDirective(D);
2594 }
2595 
2596 void ASTStmtReader::VisitOMPTargetTeamsDistributeSimdDirective(
2598  VisitOMPLoopDirective(D);
2599 }
2600 
2601 void ASTStmtReader::VisitOMPInteropDirective(OMPInteropDirective *D) {
2602  VisitStmt(D);
2603  VisitOMPExecutableDirective(D);
2604 }
2605 
2606 void ASTStmtReader::VisitOMPDispatchDirective(OMPDispatchDirective *D) {
2607  VisitStmt(D);
2608  VisitOMPExecutableDirective(D);
2609  D->setTargetCallLoc(Record.readSourceLocation());
2610 }
2611 
2612 void ASTStmtReader::VisitOMPMaskedDirective(OMPMaskedDirective *D) {
2613  VisitStmt(D);
2614  VisitOMPExecutableDirective(D);
2615 }
2616 
2617 void ASTStmtReader::VisitOMPGenericLoopDirective(OMPGenericLoopDirective *D) {
2618  VisitOMPLoopDirective(D);
2619 }
2620 
2621 void ASTStmtReader::VisitOMPTeamsGenericLoopDirective(
2623  VisitOMPLoopDirective(D);
2624 }
2625 
2626 void ASTStmtReader::VisitOMPTargetTeamsGenericLoopDirective(
2628  VisitOMPLoopDirective(D);
2629 }
2630 
2631 void ASTStmtReader::VisitOMPParallelGenericLoopDirective(
2633  VisitOMPLoopDirective(D);
2634 }
2635 
2636 void ASTStmtReader::VisitOMPTargetParallelGenericLoopDirective(
2638  VisitOMPLoopDirective(D);
2639 }
2640 
2641 //===----------------------------------------------------------------------===//
2642 // ASTReader Implementation
2643 //===----------------------------------------------------------------------===//
2644 
2646  switch (ReadingKind) {
2647  case Read_None:
2648  llvm_unreachable("should not call this when not reading anything");
2649  case Read_Decl:
2650  case Read_Type:
2651  return ReadStmtFromStream(F);
2652  case Read_Stmt:
2653  return ReadSubStmt();
2654  }
2655 
2656  llvm_unreachable("ReadingKind not set ?");
2657 }
2658 
2660  return cast_or_null<Expr>(ReadStmt(F));
2661 }
2662 
2664  return cast_or_null<Expr>(ReadSubStmt());
2665 }
2666 
2667 // Within the bitstream, expressions are stored in Reverse Polish
2668 // Notation, with each of the subexpressions preceding the
2669 // expression they are stored in. Subexpressions are stored from last to first.
2670 // To evaluate expressions, we continue reading expressions and placing them on
2671 // the stack, with expressions having operands removing those operands from the
2672 // stack. Evaluation terminates when we see a STMT_STOP record, and
2673 // the single remaining expression on the stack is our result.
2674 Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
2675  ReadingKindTracker ReadingKind(Read_Stmt, *this);
2676  llvm::BitstreamCursor &Cursor = F.DeclsCursor;
2677 
2678  // Map of offset to previously deserialized stmt. The offset points
2679  // just after the stmt record.
2680  llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
2681 
2682 #ifndef NDEBUG
2683  unsigned PrevNumStmts = StmtStack.size();
2684 #endif
2685 
2686  ASTRecordReader Record(*this, F);
2687  ASTStmtReader Reader(Record, Cursor);
2688  Stmt::EmptyShell Empty;
2689 
2690  while (true) {
2692  Cursor.advanceSkippingSubblocks();
2693  if (!MaybeEntry) {
2694  Error(toString(MaybeEntry.takeError()));
2695  return nullptr;
2696  }
2697  llvm::BitstreamEntry Entry = MaybeEntry.get();
2698 
2699  switch (Entry.Kind) {
2700  case llvm::BitstreamEntry::SubBlock: // Handled for us already.
2702  Error("malformed block record in AST file");
2703  return nullptr;
2704  case llvm::BitstreamEntry::EndBlock:
2705  goto Done;
2706  case llvm::BitstreamEntry::Record:
2707  // The interesting case.
2708  break;
2709  }
2710 
2711  ASTContext &Context = getContext();
2712  Stmt *S = nullptr;
2713  bool Finished = false;
2714  bool IsStmtReference = false;
2715  Expected<unsigned> MaybeStmtCode = Record.readRecord(Cursor, Entry.ID);
2716  if (!MaybeStmtCode) {
2717  Error(toString(MaybeStmtCode.takeError()));
2718  return nullptr;
2719  }
2720  switch ((StmtCode)MaybeStmtCode.get()) {
2721  case STMT_STOP:
2722  Finished = true;
2723  break;
2724 
2725  case STMT_REF_PTR:
2726  IsStmtReference = true;
2727  assert(StmtEntries.find(Record[0]) != StmtEntries.end() &&
2728  "No stmt was recorded for this offset reference!");
2729  S = StmtEntries[Record.readInt()];
2730  break;
2731 
2732  case STMT_NULL_PTR:
2733  S = nullptr;
2734  break;
2735 
2736  case STMT_NULL:
2737  S = new (Context) NullStmt(Empty);
2738  break;
2739 
2740  case STMT_COMPOUND:
2742  Context, /*NumStmts=*/Record[ASTStmtReader::NumStmtFields]);
2743  break;
2744 
2745  case STMT_CASE:
2747  Context,
2748  /*CaseStmtIsGNURange*/ Record[ASTStmtReader::NumStmtFields + 3]);
2749  break;
2750 
2751  case STMT_DEFAULT:
2752  S = new (Context) DefaultStmt(Empty);
2753  break;
2754 
2755  case STMT_LABEL:
2756  S = new (Context) LabelStmt(Empty);
2757  break;
2758 
2759  case STMT_ATTRIBUTED:
2761  Context,
2762  /*NumAttrs*/Record[ASTStmtReader::NumStmtFields]);
2763  break;
2764 
2765  case STMT_IF:
2766  S = IfStmt::CreateEmpty(
2767  Context,
2768  /* HasElse=*/Record[ASTStmtReader::NumStmtFields],
2769  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1],
2770  /* HasInit=*/Record[ASTStmtReader::NumStmtFields + 2]);
2771  break;
2772 
2773  case STMT_SWITCH:
2775  Context,
2776  /* HasInit=*/Record[ASTStmtReader::NumStmtFields],
2777  /* HasVar=*/Record[ASTStmtReader::NumStmtFields + 1]);
2778  break;
2779 
2780  case STMT_WHILE:
2782  Context,
2783  /* HasVar=*/Record[ASTStmtReader::NumStmtFields]);
2784  break;
2785 
2786  case STMT_DO:
2787  S = new (Context) DoStmt(Empty);
2788  break;
2789 
2790  case STMT_FOR:
2791  S = new (Context) ForStmt(Empty);
2792  break;
2793 
2794  case STMT_GOTO:
2795  S = new (Context) GotoStmt(Empty);
2796  break;
2797 
2798  case STMT_INDIRECT_GOTO:
2799  S = new (Context) IndirectGotoStmt(Empty);
2800  break;
2801 
2802  case STMT_CONTINUE:
2803  S = new (Context) ContinueStmt(Empty);
2804  break;
2805 
2806  case STMT_BREAK:
2807  S = new (Context) BreakStmt(Empty);
2808  break;
2809 
2810  case STMT_RETURN:
2812  Context, /* HasNRVOCandidate=*/Record[ASTStmtReader::NumStmtFields]);
2813  break;
2814 
2815  case STMT_DECL:
2816  S = new (Context) DeclStmt(Empty);
2817  break;
2818 
2819  case STMT_GCCASM:
2820  S = new (Context) GCCAsmStmt(Empty);
2821  break;
2822 
2823  case STMT_MSASM:
2824  S = new (Context) MSAsmStmt(Empty);
2825  break;
2826 
2827  case STMT_CAPTURED:
2829  Context, Record[ASTStmtReader::NumStmtFields]);
2830  break;
2831 
2832  case EXPR_CONSTANT:
2834  Context, static_cast<ConstantExpr::ResultStorageKind>(
2835  /*StorageKind=*/Record[ASTStmtReader::NumExprFields]));
2836  break;
2837 
2840  break;
2841 
2842  case EXPR_PREDEFINED:
2844  Context,
2845  /*HasFunctionName*/ Record[ASTStmtReader::NumExprFields]);
2846  break;
2847 
2848  case EXPR_DECL_REF:
2850  Context,
2851  /*HasQualifier=*/Record[ASTStmtReader::NumExprFields],
2852  /*HasFoundDecl=*/Record[ASTStmtReader::NumExprFields + 1],
2853  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 2],
2854  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 2] ?
2855  Record[ASTStmtReader::NumExprFields + 6] : 0);
2856  break;
2857 
2858  case EXPR_INTEGER_LITERAL:
2859  S = IntegerLiteral::Create(Context, Empty);
2860  break;
2861 
2863  S = FixedPointLiteral::Create(Context, Empty);
2864  break;
2865 
2866  case EXPR_FLOATING_LITERAL:
2867  S = FloatingLiteral::Create(Context, Empty);
2868  break;
2869 
2871  S = new (Context) ImaginaryLiteral(Empty);
2872  break;
2873 
2874  case EXPR_STRING_LITERAL:
2876  Context,
2877  /* NumConcatenated=*/Record[ASTStmtReader::NumExprFields],
2878  /* Length=*/Record[ASTStmtReader::NumExprFields + 1],
2879  /* CharByteWidth=*/Record[ASTStmtReader::NumExprFields + 2]);
2880  break;
2881 
2883  S = new (Context) CharacterLiteral(Empty);
2884  break;
2885 
2886  case EXPR_PAREN:
2887  S = new (Context) ParenExpr(Empty);
2888  break;
2889 
2890  case EXPR_PAREN_LIST:
2892  Context,
2893  /* NumExprs=*/Record[ASTStmtReader::NumExprFields]);
2894  break;
2895 
2896  case EXPR_UNARY_OPERATOR:
2897  S = UnaryOperator::CreateEmpty(Context,
2899  break;
2900 
2901  case EXPR_OFFSETOF:
2902  S = OffsetOfExpr::CreateEmpty(Context,
2904  Record[ASTStmtReader::NumExprFields + 1]);
2905  break;
2906 
2907  case EXPR_SIZEOF_ALIGN_OF:
2908  S = new (Context) UnaryExprOrTypeTraitExpr(Empty);
2909  break;
2910 
2911  case EXPR_ARRAY_SUBSCRIPT:
2912  S = new (Context) ArraySubscriptExpr(Empty);
2913  break;
2914 
2915  case EXPR_MATRIX_SUBSCRIPT:
2916  S = new (Context) MatrixSubscriptExpr(Empty);
2917  break;
2918 
2920  S = new (Context) OMPArraySectionExpr(Empty);
2921  break;
2922 
2925  Context, Record[ASTStmtReader::NumExprFields]);
2926  break;
2927 
2928  case EXPR_OMP_ITERATOR:
2929  S = OMPIteratorExpr::CreateEmpty(Context,
2931  break;
2932 
2933  case EXPR_CALL:
2935  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
2936  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
2937  break;
2938 
2939  case EXPR_RECOVERY:
2941  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
2942  break;
2943 
2944  case EXPR_MEMBER:
2946  Record[ASTStmtReader::NumExprFields + 1],
2947  Record[ASTStmtReader::NumExprFields + 2],
2948  Record[ASTStmtReader::NumExprFields + 3]);
2949  break;
2950 
2951  case EXPR_BINARY_OPERATOR:
2952  S = BinaryOperator::CreateEmpty(Context,
2954  break;
2955 
2958  Context, Record[ASTStmtReader::NumExprFields]);
2959  break;
2960 
2962  S = new (Context) ConditionalOperator(Empty);
2963  break;
2964 
2966  S = new (Context) BinaryConditionalOperator(Empty);
2967  break;
2968 
2969  case EXPR_IMPLICIT_CAST:
2971  Context,
2972  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
2973  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
2974  break;
2975 
2976  case EXPR_CSTYLE_CAST:
2978  Context,
2979  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
2980  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
2981  break;
2982 
2983  case EXPR_COMPOUND_LITERAL:
2984  S = new (Context) CompoundLiteralExpr(Empty);
2985  break;
2986 
2988  S = new (Context) ExtVectorElementExpr(Empty);
2989  break;
2990 
2991  case EXPR_INIT_LIST:
2992  S = new (Context) InitListExpr(Empty);
2993  break;
2994 
2995  case EXPR_DESIGNATED_INIT:
2996  S = DesignatedInitExpr::CreateEmpty(Context,
2997  Record[ASTStmtReader::NumExprFields] - 1);
2998 
2999  break;
3000 
3002  S = new (Context) DesignatedInitUpdateExpr(Empty);
3003  break;
3004 
3006  S = new (Context) ImplicitValueInitExpr(Empty);
3007  break;
3008 
3009  case EXPR_NO_INIT:
3010  S = new (Context) NoInitExpr(Empty);
3011  break;
3012 
3013  case EXPR_ARRAY_INIT_LOOP:
3014  S = new (Context) ArrayInitLoopExpr(Empty);
3015  break;
3016 
3017  case EXPR_ARRAY_INIT_INDEX:
3018  S = new (Context) ArrayInitIndexExpr(Empty);
3019  break;
3020 
3021  case EXPR_VA_ARG:
3022  S = new (Context) VAArgExpr(Empty);
3023  break;
3024 
3025  case EXPR_SOURCE_LOC:
3026  S = new (Context) SourceLocExpr(Empty);
3027  break;
3028 
3029  case EXPR_ADDR_LABEL:
3030  S = new (Context) AddrLabelExpr(Empty);
3031  break;
3032 
3033  case EXPR_STMT:
3034  S = new (Context) StmtExpr(Empty);
3035  break;
3036 
3037  case EXPR_CHOOSE:
3038  S = new (Context) ChooseExpr(Empty);
3039  break;
3040 
3041  case EXPR_GNU_NULL:
3042  S = new (Context) GNUNullExpr(Empty);
3043  break;
3044 
3045  case EXPR_SHUFFLE_VECTOR:
3046  S = new (Context) ShuffleVectorExpr(Empty);
3047  break;
3048 
3049  case EXPR_CONVERT_VECTOR:
3050  S = new (Context) ConvertVectorExpr(Empty);
3051  break;
3052 
3053  case EXPR_BLOCK:
3054  S = new (Context) BlockExpr(Empty);
3055  break;
3056 
3059  Context,
3060  /*NumAssocs=*/Record[ASTStmtReader::NumExprFields]);
3061  break;
3062 
3064  S = new (Context) ObjCStringLiteral(Empty);
3065  break;
3066 
3068  S = new (Context) ObjCBoxedExpr(Empty);
3069  break;
3070 
3072  S = ObjCArrayLiteral::CreateEmpty(Context,
3074  break;
3075 
3079  Record[ASTStmtReader::NumExprFields + 1]);
3080  break;
3081 
3082  case EXPR_OBJC_ENCODE:
3083  S = new (Context) ObjCEncodeExpr(Empty);
3084  break;
3085 
3087  S = new (Context) ObjCSelectorExpr(Empty);
3088  break;
3089 
3091  S = new (Context) ObjCProtocolExpr(Empty);
3092  break;
3093 
3095  S = new (Context) ObjCIvarRefExpr(Empty);
3096  break;
3097 
3099  S = new (Context) ObjCPropertyRefExpr(Empty);
3100  break;
3101 
3103  S = new (Context) ObjCSubscriptRefExpr(Empty);
3104  break;
3105 
3107  llvm_unreachable("mismatching AST file");
3108 
3110  S = ObjCMessageExpr::CreateEmpty(Context,
3112  Record[ASTStmtReader::NumExprFields + 1]);
3113  break;
3114 
3115  case EXPR_OBJC_ISA:
3116  S = new (Context) ObjCIsaExpr(Empty);
3117  break;
3118 
3120  S = new (Context) ObjCIndirectCopyRestoreExpr(Empty);
3121  break;
3122 
3124  S = new (Context) ObjCBridgedCastExpr(Empty);
3125  break;
3126 
3128  S = new (Context) ObjCForCollectionStmt(Empty);
3129  break;
3130 
3131  case STMT_OBJC_CATCH:
3132  S = new (Context) ObjCAtCatchStmt(Empty);
3133  break;
3134 
3135  case STMT_OBJC_FINALLY:
3136  S = new (Context) ObjCAtFinallyStmt(Empty);
3137  break;
3138 
3139  case STMT_OBJC_AT_TRY:
3140  S = ObjCAtTryStmt::CreateEmpty(Context,
3142  Record[ASTStmtReader::NumStmtFields + 1]);
3143  break;
3144 
3146  S = new (Context) ObjCAtSynchronizedStmt(Empty);
3147  break;
3148 
3149  case STMT_OBJC_AT_THROW:
3150  S = new (Context) ObjCAtThrowStmt(Empty);
3151  break;
3152 
3154  S = new (Context) ObjCAutoreleasePoolStmt(Empty);
3155  break;
3156 
3158  S = new (Context) ObjCBoolLiteralExpr(Empty);
3159  break;
3160 
3162  S = new (Context) ObjCAvailabilityCheckExpr(Empty);
3163  break;
3164 
3165  case STMT_SEH_LEAVE:
3166  S = new (Context) SEHLeaveStmt(Empty);
3167  break;
3168 
3169  case STMT_SEH_EXCEPT:
3170  S = new (Context) SEHExceptStmt(Empty);
3171  break;
3172 
3173  case STMT_SEH_FINALLY:
3174  S = new (Context) SEHFinallyStmt(Empty);
3175  break;
3176 
3177  case STMT_SEH_TRY:
3178  S = new (Context) SEHTryStmt(Empty);
3179  break;
3180 
3181  case STMT_CXX_CATCH:
3182  S = new (Context) CXXCatchStmt(Empty);
3183  break;
3184 
3185  case STMT_CXX_TRY:
3186  S = CXXTryStmt::Create(Context, Empty,
3187  /*numHandlers=*/Record[ASTStmtReader::NumStmtFields]);
3188  break;
3189 
3190  case STMT_CXX_FOR_RANGE:
3191  S = new (Context) CXXForRangeStmt(Empty);
3192  break;
3193 
3195  S = new (Context) MSDependentExistsStmt(SourceLocation(), true,
3198  nullptr);
3199  break;
3200 
3202  S = OMPCanonicalLoop::createEmpty(Context);
3203  break;
3204 
3207  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3208  break;
3209 
3211  S =
3214  Empty);
3215  break;
3216 
3217  case STMT_OMP_SIMD_DIRECTIVE: {
3218  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3219  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3220  S = OMPSimdDirective::CreateEmpty(Context, NumClauses,
3221  CollapsedNum, Empty);
3222  break;
3223  }
3224 
3225  case STMT_OMP_TILE_DIRECTIVE: {
3226  unsigned NumLoops = Record[ASTStmtReader::NumStmtFields];
3227  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3228  S = OMPTileDirective::CreateEmpty(Context, NumClauses, NumLoops);
3229  break;
3230  }
3231 
3233  assert(Record[ASTStmtReader::NumStmtFields] == 1 && "Unroll directive accepts only a single loop");
3234  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3235  S = OMPUnrollDirective::CreateEmpty(Context, NumClauses);
3236  break;
3237  }
3238 
3239  case STMT_OMP_FOR_DIRECTIVE: {
3240  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3241  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3242  S = OMPForDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3243  Empty);
3244  break;
3245  }
3246 
3248  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3249  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3250  S = OMPForSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3251  Empty);
3252  break;
3253  }
3254 
3257  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3258  break;
3259 
3261  S = OMPSectionDirective::CreateEmpty(Context, Empty);
3262  break;
3263 
3266  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3267  break;
3268 
3270  S = OMPMasterDirective::CreateEmpty(Context, Empty);
3271  break;
3272 
3275  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3276  break;
3277 
3279  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3280  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3281  S = OMPParallelForDirective::CreateEmpty(Context, NumClauses,
3282  CollapsedNum, Empty);
3283  break;
3284  }
3285 
3287  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3288  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3289  S = OMPParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3290  CollapsedNum, Empty);
3291  break;
3292  }
3293 
3296  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3297  break;
3298 
3301  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3302  break;
3303 
3306  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3307  break;
3308 
3310  S = OMPTaskyieldDirective::CreateEmpty(Context, Empty);
3311  break;
3312 
3314  S = OMPBarrierDirective::CreateEmpty(Context, Empty);
3315  break;
3316 
3319  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3320  break;
3321 
3324  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3325  break;
3326 
3329  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3330  break;
3331 
3334  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3335  break;
3336 
3339  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3340  break;
3341 
3343  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields];
3344  bool HasAssociatedStmt = Record[ASTStmtReader::NumStmtFields + 2];
3345  S = OMPOrderedDirective::CreateEmpty(Context, NumClauses,
3346  !HasAssociatedStmt, Empty);
3347  break;
3348  }
3349 
3352  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3353  break;
3354 
3357  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3358  break;
3359 
3362  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3363  break;
3364 
3367  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3368  break;
3369 
3372  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3373  break;
3374 
3377  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3378  break;
3379 
3381  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3382  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3383  S = OMPTargetParallelForDirective::CreateEmpty(Context, NumClauses,
3384  CollapsedNum, Empty);
3385  break;
3386  }
3387 
3390  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3391  break;
3392 
3395  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3396  break;
3397 
3399  S = OMPCancellationPointDirective::CreateEmpty(Context, Empty);
3400  break;
3401 
3404  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3405  break;
3406 
3408  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3409  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3410  S = OMPTaskLoopDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3411  Empty);
3412  break;
3413  }
3414 
3416  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3417  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3418  S = OMPTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3419  CollapsedNum, Empty);
3420  break;
3421  }
3422 
3424  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3425  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3426  S = OMPMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3427  CollapsedNum, Empty);
3428  break;
3429  }
3430 
3432  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3433  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3434  S = OMPMasterTaskLoopSimdDirective::CreateEmpty(Context, NumClauses,
3435  CollapsedNum, Empty);
3436  break;
3437  }
3438 
3440  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3441  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3442  S = OMPParallelMasterTaskLoopDirective::CreateEmpty(Context, NumClauses,
3443  CollapsedNum, Empty);
3444  break;
3445  }
3446 
3448  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3449  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3451  Context, NumClauses, CollapsedNum, Empty);
3452  break;
3453  }
3454 
3456  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3457  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3458  S = OMPDistributeDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3459  Empty);
3460  break;
3461  }
3462 
3464  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3465  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3466  S = OMPDistributeParallelForDirective::CreateEmpty(Context, NumClauses,
3467  CollapsedNum, Empty);
3468  break;
3469  }
3470 
3472  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3473  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3475  CollapsedNum,
3476  Empty);
3477  break;
3478  }
3479 
3481  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3482  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3483  S = OMPDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3484  CollapsedNum, Empty);
3485  break;
3486  }
3487 
3489  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3490  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3491  S = OMPTargetParallelForSimdDirective::CreateEmpty(Context, NumClauses,
3492  CollapsedNum, Empty);
3493  break;
3494  }
3495 
3497  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3498  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3499  S = OMPTargetSimdDirective::CreateEmpty(Context, NumClauses, CollapsedNum,
3500  Empty);
3501  break;
3502  }
3503 
3505  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3506  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3507  S = OMPTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3508  CollapsedNum, Empty);
3509  break;
3510  }
3511 
3513  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3514  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3515  S = OMPTeamsDistributeSimdDirective::CreateEmpty(Context, NumClauses,
3516  CollapsedNum, Empty);
3517  break;
3518  }
3519 
3521  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3522  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3524  Context, NumClauses, CollapsedNum, Empty);
3525  break;
3526  }
3527 
3529  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3530  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3532  Context, NumClauses, CollapsedNum, Empty);
3533  break;
3534  }
3535 
3538  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3539  break;
3540 
3542  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3543  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3544  S = OMPTargetTeamsDistributeDirective::CreateEmpty(Context, NumClauses,
3545  CollapsedNum, Empty);
3546  break;
3547  }
3548 
3550  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3551  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3553  Context, NumClauses, CollapsedNum, Empty);
3554  break;
3555  }
3556 
3558  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3559  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3561  Context, NumClauses, CollapsedNum, Empty);
3562  break;
3563  }
3564 
3566  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3567  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3569  Context, NumClauses, CollapsedNum, Empty);
3570  break;
3571  }
3572 
3575  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3576  break;
3577 
3580  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3581  break;
3582 
3585  Context, Record[ASTStmtReader::NumStmtFields], Empty);
3586  break;
3587 
3589  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3590  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3591  S = OMPGenericLoopDirective::CreateEmpty(Context, NumClauses,
3592  CollapsedNum, Empty);
3593  break;
3594  }
3595 
3597  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3598  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3599  S = OMPTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses,
3600  CollapsedNum, Empty);
3601  break;
3602  }
3603 
3605  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3606  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3607  S = OMPTargetTeamsGenericLoopDirective::CreateEmpty(Context, NumClauses,
3608  CollapsedNum, Empty);
3609  break;
3610  }
3611 
3613  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3614  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3615  S = OMPParallelGenericLoopDirective::CreateEmpty(Context, NumClauses,
3616  CollapsedNum, Empty);
3617  break;
3618  }
3619 
3621  unsigned CollapsedNum = Record[ASTStmtReader::NumStmtFields];
3622  unsigned NumClauses = Record[ASTStmtReader::NumStmtFields + 1];
3624  Context, NumClauses, CollapsedNum, Empty);
3625  break;
3626  }
3627 
3630  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3631  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3632  break;
3633 
3634  case EXPR_CXX_MEMBER_CALL:
3636  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3637  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3638  break;
3639 
3641  S = new (Context) CXXRewrittenBinaryOperator(Empty);
3642  break;
3643 
3644  case EXPR_CXX_CONSTRUCT:
3646  Context,
3647  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3648  break;
3649 
3651  S = new (Context) CXXInheritedCtorInitExpr(Empty);
3652  break;
3653 
3656  Context,
3657  /* NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3658  break;
3659 
3660  case EXPR_CXX_STATIC_CAST:
3662  Context,
3663  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3664  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3665  break;
3666 
3667  case EXPR_CXX_DYNAMIC_CAST:
3668  S = CXXDynamicCastExpr::CreateEmpty(Context,
3669  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3670  break;
3671 
3674  /*PathSize*/ Record[ASTStmtReader::NumExprFields]);
3675  break;
3676 
3677  case EXPR_CXX_CONST_CAST:
3678  S = CXXConstCastExpr::CreateEmpty(Context);
3679  break;
3680 
3682  S = CXXAddrspaceCastExpr::CreateEmpty(Context);
3683  break;
3684 
3687  Context,
3688  /*PathSize*/ Record[ASTStmtReader::NumExprFields],
3689  /*HasFPFeatures*/ Record[ASTStmtReader::NumExprFields + 1]);
3690  break;
3691 
3692  case EXPR_BUILTIN_BIT_CAST:
3693  assert(Record[ASTStmtReader::NumExprFields] == 0 && "Wrong PathSize!");
3694  S = new (Context) BuiltinBitCastExpr(Empty);
3695  break;
3696 
3699  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3700  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3701  break;
3702 
3704  S = new (Context) CXXStdInitializerListExpr(Empty);
3705  break;
3706 
3707  case EXPR_CXX_BOOL_LITERAL:
3708  S = new (Context) CXXBoolLiteralExpr(Empty);
3709  break;
3710 
3712  S = new (Context) CXXNullPtrLiteralExpr(Empty);
3713  break;
3714 
3715  case EXPR_CXX_TYPEID_EXPR:
3716  S = new (Context) CXXTypeidExpr(Empty, true);
3717  break;
3718 
3719  case EXPR_CXX_TYPEID_TYPE:
3720  S = new (Context) CXXTypeidExpr(Empty, false);
3721  break;
3722 
3723  case EXPR_CXX_UUIDOF_EXPR:
3724  S = new (Context) CXXUuidofExpr(Empty, true);
3725  break;
3726 
3728  S = new (Context) MSPropertyRefExpr(Empty);
3729  break;
3730 
3732  S = new (Context) MSPropertySubscriptExpr(Empty);
3733  break;
3734 
3735  case EXPR_CXX_UUIDOF_TYPE:
3736  S = new (Context) CXXUuidofExpr(Empty, false);
3737  break;
3738 
3739  case EXPR_CXX_THIS:
3740  S = new (Context) CXXThisExpr(Empty);
3741  break;
3742 
3743  case EXPR_CXX_THROW:
3744  S = new (Context) CXXThrowExpr(Empty);
3745  break;
3746 
3747  case EXPR_CXX_DEFAULT_ARG:
3748  S = new (Context) CXXDefaultArgExpr(Empty);
3749  break;
3750 
3751  case EXPR_CXX_DEFAULT_INIT:
3752  S = new (Context) CXXDefaultInitExpr(Empty);
3753  break;
3754 
3756  S = new (Context) CXXBindTemporaryExpr(Empty);
3757  break;
3758 
3760  S = new (Context) CXXScalarValueInitExpr(Empty);
3761  break;
3762 
3763  case EXPR_CXX_NEW:
3765  Context,
3766  /*IsArray=*/Record[ASTStmtReader::NumExprFields],
3767  /*HasInit=*/Record[ASTStmtReader::NumExprFields + 1],
3768  /*NumPlacementArgs=*/Record[ASTStmtReader::NumExprFields + 2],
3769  /*IsParenTypeId=*/Record[ASTStmtReader::NumExprFields + 3]);
3770  break;
3771 
3772  case EXPR_CXX_DELETE:
3773  S = new (Context) CXXDeleteExpr(Empty);
3774  break;
3775 
3777  S = new (Context) CXXPseudoDestructorExpr(Empty);
3778  break;
3779 
3781  S = ExprWithCleanups::Create(Context, Empty,
3783  break;
3784 
3787  Context,
3788  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3789  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields + 1],
3790  /*HasFirstQualifierFoundInScope=*/
3791  Record[ASTStmtReader::NumExprFields + 2]);
3792  break;
3793 
3796  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields],
3797  /*NumTemplateArgs=*/Record[ASTStmtReader::NumExprFields]
3798  ? Record[ASTStmtReader::NumExprFields + 1]
3799  : 0);
3800  break;
3801 
3804  /*NumArgs=*/Record[ASTStmtReader::NumExprFields]);
3805  break;
3806 
3809  Context,
3810  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3811  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3812  /*NumTemplateArgs=*/
3813  Record[ASTStmtReader::NumExprFields + 1]
3814  ? Record[ASTStmtReader::NumExprFields + 2]
3815  : 0);
3816  break;
3817 
3820  Context,
3821  /*NumResults=*/Record[ASTStmtReader::NumExprFields],
3822  /*HasTemplateKWAndArgsInfo=*/Record[ASTStmtReader::NumExprFields + 1],
3823  /*NumTemplateArgs=*/
3824  Record[ASTStmtReader::NumExprFields + 1]
3825  ? Record[ASTStmtReader::NumExprFields + 2]
3826  : 0);
3827  break;
3828 
3829  case EXPR_TYPE_TRAIT:
3832  break;
3833 
3834  case EXPR_ARRAY_TYPE_TRAIT:
3835  S = new (Context) ArrayTypeTraitExpr(Empty);
3836  break;
3837 
3839  S = new (Context) ExpressionTraitExpr(Empty);
3840  break;
3841 
3842  case EXPR_CXX_NOEXCEPT:
3843  S = new (Context) CXXNoexceptExpr(Empty);
3844  break;
3845 
3846  case EXPR_PACK_EXPANSION:
3847  S = new (Context) PackExpansionExpr(Empty);
3848  break;
3849 
3850  case EXPR_SIZEOF_PACK:
3852  Context,
3853  /*NumPartialArgs=*/Record[ASTStmtReader::NumExprFields]);
3854  break;
3855 
3857  S = new (Context) SubstNonTypeTemplateParmExpr(Empty);
3858  break;
3859 
3861  S = new (Context) SubstNonTypeTemplateParmPackExpr(Empty);
3862  break;
3863 
3867  break;
3868 
3870  S = new (Context) MaterializeTemporaryExpr(Empty);
3871  break;
3872 
3873  case EXPR_CXX_FOLD:
3874  S = new (Context) CXXFoldExpr(Empty);
3875  break;
3876 
3877  case EXPR_OPAQUE_VALUE:
3878  S = new (Context) OpaqueValueExpr(Empty);
3879  break;
3880 
3881  case EXPR_CUDA_KERNEL_CALL:
3883  Context, /*NumArgs=*/Record[ASTStmtReader::NumExprFields],
3884  /*HasFPFeatures=*/Record[ASTStmtReader::NumExprFields + 1], Empty);
3885  break;
3886 
3887  case EXPR_ASTYPE:
3888  S = new (Context) AsTypeExpr(Empty);
3889  break;
3890 
3891  case EXPR_PSEUDO_OBJECT: {
3892  unsigned numSemanticExprs = Record[ASTStmtReader::NumExprFields];
3893  S = PseudoObjectExpr::Create(Context, Empty, numSemanticExprs);
3894  break;
3895  }
3896 
3897  case EXPR_ATOMIC:
3898  S = new (Context) AtomicExpr(Empty);
3899  break;
3900 
3901  case EXPR_LAMBDA: {
3902  unsigned NumCaptures = Record[ASTStmtReader::NumExprFields];
3903  S = LambdaExpr::CreateDeserialized(Context, NumCaptures);
3904  break;
3905  }
3906 
3907  case STMT_COROUTINE_BODY: {
3908  unsigned NumParams = Record[ASTStmtReader::NumStmtFields];
3909  S = CoroutineBodyStmt::Create(Context, Empty, NumParams);
3910  break;
3911  }
3912 
3913  case STMT_CORETURN:
3914  S = new (Context) CoreturnStmt(Empty);
3915  break;
3916 
3917  case EXPR_COAWAIT:
3918  S = new (Context) CoawaitExpr(Empty);
3919  break;
3920 
3921  case EXPR_COYIELD:
3922  S = new (Context) CoyieldExpr(Empty);
3923  break;
3924 
3926  S = new (Context) DependentCoawaitExpr(Empty);
3927  break;
3928 
3930  unsigned numTemplateArgs = Record[ASTStmtReader::NumExprFields];
3931  S = ConceptSpecializationExpr::Create(Context, Empty, numTemplateArgs);
3932  break;
3933  }
3934 
3935  case EXPR_REQUIRES:
3936  unsigned numLocalParameters = Record[ASTStmtReader::NumExprFields];
3937  unsigned numRequirement = Record[ASTStmtReader::NumExprFields + 1];
3938  S = RequiresExpr::Create(Context, Empty, numLocalParameters,
3939  numRequirement);
3940  break;
3941  }
3942 
3943  // We hit a STMT_STOP, so we're done with this expression.
3944  if (Finished)
3945  break;
3946 
3947  ++NumStatementsRead;
3948 
3949  if (S && !IsStmtReference) {
3950  Reader.Visit(S);
3951  StmtEntries[Cursor.GetCurrentBitNo()] = S;
3952  }
3953 
3954  assert(Record.getIdx() == Record.size() &&
3955  "Invalid deserialization of statement");
3956  StmtStack.push_back(S);
3957  }
3958 Done:
3959  assert(StmtStack.size() > PrevNumStmts && "Read too many sub-stmts!");
3960  assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
3961  return StmtStack.pop_back_val();
3962 }
clang::OMPIteratorHelperData::Update
Expr * Update
Update expression for the originally specified iteration variable, calculated as VD = Begin + Counter...
Definition: ExprOpenMP.h:243
clang::StmtVisitor
StmtVisitor - This class implements a simple visitor for Stmt subclasses.
Definition: StmtVisitor.h:183
clang::ArrayInitIndexExpr
Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.
Definition: Expr.h:5474
clang::OMPIteratorExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:367
clang::CompoundLiteralExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3436
clang::OMPTeamsDirective::CreateEmpty
static OMPTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1022
clang::IndirectGotoStmt
IndirectGotoStmt - This represents an indirect goto.
Definition: Stmt.h:2649
clang::LabelStmt
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:1804
clang::serialization::EXPR_CHARACTER_LITERAL
@ EXPR_CHARACTER_LITERAL
A CharacterLiteral record.
Definition: ASTBitCodes.h:1617
clang::serialization::STMT_CXX_TRY
@ STMT_CXX_TRY
A CXXTryStmt record.
Definition: ASTBitCodes.h:1799
clang::ExpressionTraitExpr
An expression trait intrinsic.
Definition: ExprCXX.h:2840
clang::ObjCMessageExpr::SuperInstance
@ SuperInstance
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1097
clang::OMPForDirective
This represents '#pragma omp for' directive.
Definition: StmtOpenMP.h:1628
clang::CallExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3116
clang::concepts::Requirement::RequirementKind
RequirementKind
Definition: ExprConcepts.h:153
clang::serialization::STMT_MS_DEPENDENT_EXISTS
@ STMT_MS_DEPENDENT_EXISTS
Definition: ASTBitCodes.h:1982
clang::OMPIteratorExpr
OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...
Definition: ExprOpenMP.h:272
clang::MatrixSubscriptExpr
MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.
Definition: Expr.h:2723
clang::SubstNonTypeTemplateParmExpr
Represents a reference to a non-type template parameter that has been substituted with a template arg...
Definition: ExprCXX.h:4262
clang::RecoveryExpr::children
child_range children()
Definition: Expr.h:6438
clang::serialization::STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1940
clang::AtomicExpr
AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...
Definition: Expr.h:6234
clang::OMPMasterTaskLoopSimdDirective
This represents '#pragma omp master taskloop simd' directive.
Definition: StmtOpenMP.h:3786
clang::CaseStmt
CaseStmt - Represent a case statement.
Definition: Stmt.h:1572
clang::OMPParallelDirective::CreateEmpty
static OMPParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:292
clang::OMPTaskyieldDirective
This represents '#pragma omp taskyield' directive.
Definition: StmtOpenMP.h:2459
clang::ArrayTypeTrait
ArrayTypeTrait
Names for the array type traits.
Definition: TypeTraits.h:42
clang::OMPExecutableDirective::setLocEnd
void setLocEnd(SourceLocation Loc)
Set ending location of directive.
Definition: StmtOpenMP.h:501
clang::serialization::EXPR_OBJC_PROPERTY_REF_EXPR
@ EXPR_OBJC_PROPERTY_REF_EXPR
An ObjCPropertyRefExpr record.
Definition: ASTBitCodes.h:1749
clang::ImaginaryLiteral
ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....
Definition: Expr.h:1718
clang::serialization::EXPR_PSEUDO_OBJECT
@ EXPR_PSEUDO_OBJECT
A PseudoObjectExpr record.
Definition: ASTBitCodes.h:1719
clang::Expr::setValueKind
void setValueKind(ExprValueKind Cat)
setValueKind - Set the value kind produced by this expression.
Definition: Expr.h:447
clang::serialization::STMT_DECL
@ STMT_DECL
A DeclStmt record.
Definition: ASTBitCodes.h:1584
clang::ObjCArrayLiteral::CreateEmpty
static ObjCArrayLiteral * CreateEmpty(const ASTContext &C, unsigned NumElements)
Definition: ExprObjC.cpp:47
clang::OMPParallelMasterDirective::CreateEmpty
static OMPParallelMasterDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:679
clang::DesignatedInitUpdateExpr::setUpdater
void setUpdater(Expr *Updater)
Definition: Expr.h:5392
clang::ArrayTypeTraitExpr
An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.
Definition: ExprCXX.h:2770
clang::ASTRecordReader::getContext
ASTContext & getContext()
Retrieve the AST context that this AST reader supplements.
Definition: ASTRecordReader.h:56
clang::ObjCBoxedExpr
ObjCBoxedExpr - used for generalized expression boxing.
Definition: ExprObjC.h:128
clang::CallExpr::setPreArg
void setPreArg(unsigned I, Stmt *PreArg)
Definition: Expr.h:2889
clang::CaseStmt::CreateEmpty
static CaseStmt * CreateEmpty(const ASTContext &Ctx, bool CaseStmtIsGNURange)
Build an empty case statement.
Definition: Stmt.cpp:1221
clang::CXXBoolLiteralExpr
A boolean literal, per ([C++ lex.bool] Boolean literals).
Definition: ExprCXX.h:721
clang::CharacterLiteral::CharacterKind
CharacterKind
Definition: Expr.h:1586
clang::OMPTeamsGenericLoopDirective::CreateEmpty
static OMPTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2174
clang::OverloadExpr::getTrailingASTTemplateKWAndArgsInfo
ASTTemplateKWAndArgsInfo * getTrailingASTTemplateKWAndArgsInfo()
Return the optional template keyword and arguments info.
Definition: ExprCXX.h:3987
clang::OffsetOfExpr::setComponent
void setComponent(unsigned Idx, OffsetOfNode ON)
Definition: Expr.h:2498
clang::serialization::EXPR_GENERIC_SELECTION
@ EXPR_GENERIC_SELECTION
A GenericSelectionExpr record.
Definition: ASTBitCodes.h:1716
clang::PredefinedExpr::CreateEmpty
static PredefinedExpr * CreateEmpty(const ASTContext &Ctx, bool HasFunctionName)
Create an empty PredefinedExpr.
Definition: Expr.cpp:610
clang::AsTypeExpr
AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...
Definition: Expr.h:6031
clang::OffsetOfExpr
OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...
Definition: Expr.h:2444
Specifiers.h
clang::serialization::STMT_CAPTURED
@ STMT_CAPTURED
A CapturedStmt record.
Definition: ASTBitCodes.h:1587
clang::serialization::STMT_OMP_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1970
clang::serialization::STMT_OMP_TARGET_DATA_DIRECTIVE
@ STMT_OMP_TARGET_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1936
clang::serialization::STMT_CASE
@ STMT_CASE
A CaseStmt record.
Definition: ASTBitCodes.h:1542
clang::CXXPseudoDestructorExpr
Represents a C++ pseudo-destructor (C++ [expr.pseudo]).
Definition: ExprCXX.h:2534
clang::FloatingLiteral::setValue
void setValue(const ASTContext &C, const llvm::APFloat &Val)
Definition: Expr.h:1656
clang::ChooseExpr::setCond
void setCond(Expr *E)
Definition: Expr.h:4565
clang::OMPTargetExitDataDirective::CreateEmpty
static OMPTargetExitDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:1007
clang::CoawaitExpr::setIsImplicit
void setIsImplicit(bool value=true)
Definition: ExprCXX.h:4812
clang::SYCLUniqueStableNameExpr::CreateEmpty
static SYCLUniqueStableNameExpr * CreateEmpty(const ASTContext &Ctx)
Definition: Expr.cpp:552
clang::serialization::EXPR_INTEGER_LITERAL
@ EXPR_INTEGER_LITERAL
An IntegerLiteral record.
Definition: ASTBitCodes.h:1605
clang::serialization::EXPR_SHUFFLE_VECTOR
@ EXPR_SHUFFLE_VECTOR
A ShuffleVectorExpr record.
Definition: ASTBitCodes.h:1707
clang::OMPTileDirective
This represents the '#pragma omp tile' loop transformation directive.
Definition: StmtOpenMP.h:5118
clang::SwitchStmt
SwitchStmt - This represents a 'switch' stmt.
Definition: Stmt.h:2155
clang::serialization::STMT_OBJC_AT_THROW
@ STMT_OBJC_AT_THROW
An ObjCAtThrowStmt record.
Definition: ASTBitCodes.h:1782
clang::SourceLocExpr::IdentKind
IdentKind
Definition: Expr.h:4687
clang::ObjCDictionaryLiteral::getNumElements
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c dictionary literal.
Definition: ExprObjC.h:360
clang::OMPMaskedDirective
This represents '#pragma omp masked' directive.
Definition: StmtOpenMP.h:5445
Error
llvm::Error Error
Definition: ByteCodeEmitter.cpp:20
clang::serialization::EXPR_CXX_UNRESOLVED_LOOKUP
@ EXPR_CXX_UNRESOLVED_LOOKUP
Definition: ASTBitCodes.h:1872
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::serialization::EXPR_OMP_ARRAY_SECTION
@ EXPR_OMP_ARRAY_SECTION
Definition: ASTBitCodes.h:1975
DeclAccessPair.h
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
clang::Stmt::CXXNewExprBits
CXXNewExprBitfields CXXNewExprBits
Definition: Stmt.h:1055
clang::Stmt::PseudoObjectExprBits
PseudoObjectExprBitfields PseudoObjectExprBits
Definition: Stmt.h:1039
clang::WhileStmt
WhileStmt - This represents a 'while' stmt.
Definition: Stmt.h:2346
clang::ObjCIvarRefExpr::setOpLoc
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:598
clang::OMPArrayShapingExpr::CreateEmpty
static OMPArrayShapingExpr * CreateEmpty(const ASTContext &Context, unsigned NumDims)
Definition: Expr.cpp:4888
clang::NullStmt
NullStmt - This is the null statement ";": C99 6.8.3p3.
Definition: Stmt.h:1369
clang::serialization::STMT_NULL
@ STMT_NULL
A NullStmt record.
Definition: ASTBitCodes.h:1536
clang::serialization::STMT_OMP_CANONICAL_LOOP
@ STMT_OMP_CANONICAL_LOOP
Definition: ASTBitCodes.h:1910
clang::ObjCArrayLiteral::getNumElements
unsigned getNumElements() const
getNumElements - Return number of elements of objective-c array literal.
Definition: ExprObjC.h:229
clang::StringLiteral::CreateEmpty
static StringLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumConcatenated, unsigned Length, unsigned CharByteWidth)
Construct an empty string literal.
Definition: Expr.cpp:1113
clang::serialization::EXPR_CXX_UNRESOLVED_MEMBER
@ EXPR_CXX_UNRESOLVED_MEMBER
Definition: ASTBitCodes.h:1871
clang::serialization::STMT_MSASM
@ STMT_MSASM
A MS-style AsmStmt record.
Definition: ASTBitCodes.h:1593
clang::OMPCancelDirective::CreateEmpty
static OMPCancelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:797
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1965
clang::CXXReinterpretCastExpr
A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).
Definition: ExprCXX.h:521
clang::FunctionParmPackExpr::CreateEmpty
static FunctionParmPackExpr * CreateEmpty(const ASTContext &Context, unsigned NumParams)
Definition: ExprCXX.cpp:1622
clang::TypeTraitExpr::getNumArgs
unsigned getNumArgs() const
Determine the number of arguments to this type trait.
Definition: ExprCXX.h:2731
clang::CXXConstructExpr::getNumArgs
unsigned getNumArgs() const
Return the number of arguments to the constructor call.
Definition: ExprCXX.h:1608
clang::serialization::EXPR_CONVERT_VECTOR
@ EXPR_CONVERT_VECTOR
A ConvertVectorExpr record.
Definition: ASTBitCodes.h:1710
clang::CXXBoolLiteralExpr::setValue
void setValue(bool V)
Definition: ExprCXX.h:734
clang::TemplateArgument::pack_begin
pack_iterator pack_begin() const
Iterator referencing the first argument of a template argument pack.
Definition: TemplateBase.h:351
DependenceFlags.h
clang::OMPParallelMasterTaskLoopDirective
This represents '#pragma omp parallel master taskloop' directive.
Definition: StmtOpenMP.h:3852
clang::serialization::EXPR_PACK_EXPANSION
@ EXPR_PACK_EXPANSION
Definition: ASTBitCodes.h:1882
clang::OMPTargetParallelGenericLoopDirective
This represents '#pragma omp target parallel loop' directive.
Definition: StmtOpenMP.h:5793
clang::serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
Definition: ASTBitCodes.h:1869
clang::OMPDistributeParallelForSimdDirective::CreateEmpty
static OMPDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1468
clang::ObjCIvarRefExpr::setDecl
void setDecl(ObjCIvarDecl *d)
Definition: ExprObjC.h:578
clang::serialization::EXPR_CSTYLE_CAST
@ EXPR_CSTYLE_CAST
A CStyleCastExpr record.
Definition: ASTBitCodes.h:1659
clang::OMPIteratorHelperData
Helper expressions and declaration for OMPIteratorExpr class for each iteration space.
Definition: ExprOpenMP.h:235
clang::serialization::EXPR_CONDITIONAL_OPERATOR
@ EXPR_CONDITIONAL_OPERATOR
A ConditionOperator record.
Definition: ASTBitCodes.h:1653
clang::DesignatedInitExpr
Represents a C99 designated initializer expression.
Definition: Expr.h:5029
clang::OMPTargetTeamsDistributeDirective
This represents '#pragma omp target teams distribute' combined directive.
Definition: StmtOpenMP.h:4825
clang::concepts::TypeRequirement::SS_SubstitutionFailure
@ SS_SubstitutionFailure
Definition: ExprConcepts.h:207
clang::SubstNonTypeTemplateParmPackExpr
Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...
Definition: ExprCXX.h:4329
clang::UnresolvedMemberExpr::CreateEmpty
static UnresolvedMemberExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:1519
clang::CXXConstCastExpr::CreateEmpty
static CXXConstCastExpr * CreateEmpty(const ASTContext &Context)
Definition: ExprCXX.cpp:825
clang::OMPDepobjDirective::CreateEmpty
static OMPDepobjDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:827
clang::OMPTargetTeamsDistributeSimdDirective
This represents '#pragma omp target teams distribute simd' combined directive.
Definition: StmtOpenMP.h:5060
clang::CXXNewExpr::CreateEmpty
static CXXNewExpr * CreateEmpty(const ASTContext &Ctx, bool IsArray, bool HasInit, unsigned NumPlacementArgs, bool IsParenTypeId)
Create an empty c++ new expression.
Definition: ExprCXX.cpp:266
llvm::SmallVector
Definition: LLVM.h:38
clang::OMPCanonicalLoop
Representation of an OpenMP canonical loop.
Definition: StmtOpenMP.h:142
clang::serialization::STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1948
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::OMPTileDirective::CreateEmpty
static OMPTileDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned NumLoops)
Build an empty '#pragma omp tile' AST node for deserialization.
Definition: StmtOpenMP.cpp:420
clang::MSPropertyRefExpr
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:923
clang::DeclGroup::Create
static DeclGroup * Create(ASTContext &C, Decl **Decls, unsigned NumDecls)
Definition: DeclGroup.cpp:20
clang::Stmt::GenericSelectionExprBits
GenericSelectionExprBitfields GenericSelectionExprBits
Definition: Stmt.h:1038
clang::AttributedStmt::CreateEmpty
static AttributedStmt * CreateEmpty(const ASTContext &C, unsigned NumAttrs)
Definition: Stmt.cpp:425
clang::DesignatedInitExpr::setSubExpr
void setSubExpr(unsigned Idx, Expr *E)
Definition: Expr.h:5289
clang::OMPTargetParallelDirective::CreateEmpty
static OMPTargetParallelDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:918
clang::ASTRecordReader
An object for streaming information from a record.
Definition: ASTRecordReader.h:30
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1966
clang::Stmt::CXXOperatorCallExprBits
CXXOperatorCallExprBitfields CXXOperatorCallExprBits
Definition: Stmt.h:1046
clang::ObjCStringLiteral::setString
void setString(StringLiteral *S)
Definition: ExprObjC.h:67
clang::ParenListExpr
Definition: Expr.h:5537
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:219
clang::StmtExpr::setSubStmt
void setSubStmt(CompoundStmt *S)
Definition: Expr.h:4368
clang::serialization::EXPR_OBJC_BOOL_LITERAL
@ EXPR_OBJC_BOOL_LITERAL
An ObjCBoolLiteralExpr record.
Definition: ASTBitCodes.h:1788
clang::OMPMasterDirective
This represents '#pragma omp master' directive.
Definition: StmtOpenMP.h:1971
clang::ObjCMessageExpr::setClassReceiver
void setClassReceiver(TypeSourceInfo *TSInfo)
Definition: ExprObjC.h:1284
clang::serialization::EXPR_STRING_LITERAL
@ EXPR_STRING_LITERAL
A StringLiteral record.
Definition: ASTBitCodes.h:1614
clang::OMPMasterTaskLoopDirective::CreateEmpty
static OMPMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1153
clang::OffsetOfExpr::CreateEmpty
static OffsetOfExpr * CreateEmpty(const ASTContext &C, unsigned NumComps, unsigned NumExprs)
Definition: Expr.cpp:1563
clang::CXXNewExpr::getNumPlacementArgs
unsigned getNumPlacementArgs() const
Definition: ExprCXX.h:2292
clang::ExprWithCleanups::getNumObjects
unsigned getNumObjects() const
Definition: ExprCXX.h:3392
clang::ArraySubscriptExpr::setLHS
void setLHS(Expr *E)
Definition: Expr.h:2676
clang::CharacterLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1620
clang::NoInitExpr
Represents a place-holder for an object not to be initialized by anything.
Definition: Expr.h:5330
clang::InitListExpr::reserveInits
void reserveInits(const ASTContext &C, unsigned NumInits)
Reserve space for some number of initializers.
Definition: Expr.cpp:2275
clang::DependentScopeDeclRefExpr::CreateEmpty
static DependentScopeDeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:493
clang::OffsetOfNode::Array
@ Array
An index into an array.
Definition: Expr.h:2345
clang::OMPTaskwaitDirective
This represents '#pragma omp taskwait' directive.
Definition: StmtOpenMP.h:2551
ExpressionTraits.h
clang::UnresolvedMemberExpr
Represents a C++ member access expression for which lookup produced a set of overloaded functions.
Definition: ExprCXX.h:3827
clang::serialization::STMT_FOR
@ STMT_FOR
A ForStmt record.
Definition: ASTBitCodes.h:1566
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:675
clang::serialization::STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1971
clang::OMPArraySectionExpr::setColonLocFirst
void setColonLocFirst(SourceLocation L)
Definition: ExprOpenMP.h:119
clang::FloatingLiteral::setRawSemantics
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:1670
clang::ObjCBridgedCastExpr
An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...
Definition: ExprObjC.h:1625
clang::serialization::EXPR_OBJC_ARRAY_LITERAL
@ EXPR_OBJC_ARRAY_LITERAL
Definition: ASTBitCodes.h:1733
clang::Stmt::TypeTraitExprBits
TypeTraitExprBitfields TypeTraitExprBits
Definition: Stmt.h:1057
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:55
clang::CXXNewExpr::isArray
bool isArray() const
Definition: ExprCXX.h:2262
clang::serialization::STMT_OBJC_AT_SYNCHRONIZED
@ STMT_OBJC_AT_SYNCHRONIZED
An ObjCAtSynchronizedStmt record.
Definition: ASTBitCodes.h:1779
clang::OMPSectionDirective
This represents '#pragma omp section' directive.
Definition: StmtOpenMP.h:1858
Cursor
Cursor
Definition: SerializedDiagnosticReader.cpp:109
clang::serialization::EXPR_CXX_PROPERTY_REF_EXPR
@ EXPR_CXX_PROPERTY_REF_EXPR
Definition: ASTBitCodes.h:1899
clang::serialization::EXPR_IMPLICIT_VALUE_INIT
@ EXPR_IMPLICIT_VALUE_INIT
An ImplicitValueInitExpr record.
Definition: ASTBitCodes.h:1686
clang::serialization::EXPR_CXX_FUNCTIONAL_CAST
@ EXPR_CXX_FUNCTIONAL_CAST
A CXXFunctionalCastExpr record.
Definition: ASTBitCodes.h:1838
clang::TypeTraitExpr
A type trait used in the implementation of various C++11 and Library TR1 trait templates.
Definition: ExprCXX.h:2682
clang::serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
Definition: ASTBitCodes.h:1885
clang::CXXTypeidExpr
A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...
Definition: ExprCXX.h:839
clang::CXXUnresolvedConstructExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:3495
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::concepts::Requirement::SubstitutionDiagnostic
Definition: ExprConcepts.h:161
clang::serialization::EXPR_OBJC_MESSAGE_EXPR
@ EXPR_OBJC_MESSAGE_EXPR
An ObjCMessageExpr record.
Definition: ASTBitCodes.h:1758
clang::ObjCMessageExpr::setSuper
void setSuper(SourceLocation Loc, QualType T, bool IsInstanceSuper)
Definition: ExprObjC.h:1333
clang::RequiresExpr
C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...
Definition: ExprConcepts.h:475
clang::CXXFunctionalCastExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprCXX.h:1769
clang::serialization::STMT_COMPOUND
@ STMT_COMPOUND
A CompoundStmt record.
Definition: ASTBitCodes.h:1539
clang::OverloadExpr::hasTemplateKWAndArgsInfo
bool hasTemplateKWAndArgsInfo() const
Definition: ExprCXX.h:2941
clang::ASTStmtReader::NumExprFields
static const unsigned NumExprFields
The number of record fields required for the Expr class itself.
Definition: ASTReaderStmt.cpp:110
clang::OffsetOfExpr::setRParenLoc
void setRParenLoc(SourceLocation R)
Definition: Expr.h:2484
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1680
clang::Stmt::ConstantExprBits
ConstantExprBitfields ConstantExprBits
Definition: Stmt.h:1023
DeclCXX.h
clang::ASTStmtReader::NumStmtFields
static const unsigned NumStmtFields
The number of record fields required for the Stmt class itself.
Definition: ASTReaderStmt.cpp:106
int
__device__ int
Definition: __clang_hip_libdevice_declares.h:63
clang::OMPTeamsDistributeSimdDirective
This represents '#pragma omp teams distribute simd' combined directive.
Definition: StmtOpenMP.h:4542
AttrIterator.h
clang::Stmt::StringLiteralBits
StringLiteralBitfields StringLiteralBits
Definition: Stmt.h:1027
clang::ASTRecordReader::readSourceLocation
SourceLocation readSourceLocation()
Read a source location, advancing Idx.
Definition: ASTRecordReader.h:274
clang::serialization::STMT_CONTINUE
@ STMT_CONTINUE
A ContinueStmt record.
Definition: ASTBitCodes.h:1575
clang::VAArgExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4664
clang::ConceptSpecializationExpr::setTemplateArguments
void setTemplateArguments(ArrayRef< TemplateArgument > Converted)
Set new template arguments for this concept specialization.
Definition: ExprConcepts.cpp:64
clang::OMPCancellationPointDirective::CreateEmpty
static OMPCancellationPointDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:782
clang::CXXNewExpr
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Definition: ExprCXX.h:2139
clang::IfStmt
IfStmt - This represents an if/then/else.
Definition: Stmt.h:1909
clang::ExprObjectKind
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:134
clang::ObjCAtTryStmt
Represents Objective-C's @try ... @catch ... @finally statement.
Definition: StmtObjC.h:165
clang::RecoveryExpr
Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...
Definition: Expr.h:6421
clang::serialization::EXPR_STMT
@ EXPR_STMT
A StmtExpr record.
Definition: ASTBitCodes.h:1695
clang::OMPIteratorExpr::CreateEmpty
static OMPIteratorExpr * CreateEmpty(const ASTContext &Context, unsigned NumIterators)
Definition: Expr.cpp:5019
clang::serialization::EXPR_CXX_DELETE
@ EXPR_CXX_DELETE
Definition: ASTBitCodes.h:1863
clang::CapturedRegionKind
CapturedRegionKind
The different kinds of captured statement.
Definition: CapturedStmt.h:16
clang::GotoStmt
GotoStmt - This represents a direct goto.
Definition: Stmt.h:2610
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4791
clang::APValue::needsCleanup
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:429
clang::serialization::EXPR_CXX_TYPEID_TYPE
@ EXPR_CXX_TYPEID_TYPE
Definition: ASTBitCodes.h:1854
clang::serialization::EXPR_CXX_PSEUDO_DESTRUCTOR
@ EXPR_CXX_PSEUDO_DESTRUCTOR
Definition: ASTBitCodes.h:1864
clang::Stmt::CXXScalarValueInitExprBits
CXXScalarValueInitExprBitfields CXXScalarValueInitExprBits
Definition: Stmt.h:1054
llvm::Optional
Definition: LLVM.h:40
clang::OMPTaskgroupDirective::CreateEmpty
static OMPTaskgroupDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:766
clang::OMPLoopTransformationDirective
The base class for all loop transformation directives.
Definition: StmtOpenMP.h:959
clang::serialization::STMT_OMP_DISTRIBUTE_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_DIRECTIVE
Definition: ASTBitCodes.h:1951
clang::CompoundAssignOperator::setComputationLHSType
void setComputationLHSType(QualType T)
Definition: Expr.h:4089
clang::serialization::STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1923
ASTRecordReader.h
clang::ObjCBoolLiteralExpr::setValue
void setValue(bool V)
Definition: ExprObjC.h:102
clang::OMPDistributeDirective::CreateEmpty
static OMPDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1335
clang::serialization::STMT_OMP_ORDERED_DIRECTIVE
@ STMT_OMP_ORDERED_DIRECTIVE
Definition: ASTBitCodes.h:1933
clang::serialization::EXPR_CXX_SCALAR_VALUE_INIT
@ EXPR_CXX_SCALAR_VALUE_INIT
Definition: ASTBitCodes.h:1861
clang::UnaryOperator
UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...
Definition: Expr.h:2163
clang::serialization::EXPR_ARRAY_INIT_INDEX
@ EXPR_ARRAY_INIT_INDEX
An ArrayInitIndexExpr record.
Definition: ASTBitCodes.h:1683
clang::serialization::STMT_OMP_MASKED_DIRECTIVE
@ STMT_OMP_MASKED_DIRECTIVE
Definition: ASTBitCodes.h:1969
clang::OffsetOfExpr::getNumExpressions
unsigned getNumExpressions() const
Definition: Expr.h:2522
clang::UnaryOperator::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2215
clang::CXXMemberCallExpr::CreateEmpty
static CXXMemberCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Definition: ExprCXX.cpp:638
clang::serialization::STMT_OMP_META_DIRECTIVE
@ STMT_OMP_META_DIRECTIVE
Definition: ASTBitCodes.h:1909
clang::ImplicitCastExpr::CreateEmpty
static ImplicitCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: Expr.cpp:1996
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE
Definition: ASTBitCodes.h:1963
clang::serialization::EXPR_COAWAIT
@ EXPR_COAWAIT
Definition: ASTBitCodes.h:1986
clang::CoreturnStmt
Represents a 'co_return' statement in the C++ Coroutines TS.
Definition: StmtCXX.h:458
clang::Stmt::SourceLocExprBits
SourceLocExprBitfields SourceLocExprBits
Definition: Stmt.h:1040
llvm::Expected
Definition: LLVM.h:41
clang::OMPSingleDirective::CreateEmpty
static OMPSingleDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:542
clang::OMPIteratorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:370
ExprOpenMP.h
clang::CXXStaticCastExpr
A C++ static_cast expression (C++ [expr.static.cast]).
Definition: ExprCXX.h:431
clang::ObjCForCollectionStmt
Represents Objective-C's collection statement.
Definition: StmtObjC.h:23
clang::ObjCDictionaryLiteral_KeyValuePair
Internal struct for storing Key/value pair.
Definition: ExprObjC.h:286
clang::StmtExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4376
clang::ObjCProtocolExpr::setAtLoc
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:527
clang::ArrayInitLoopExpr
Represents a loop initializing the elements of an array.
Definition: Expr.h:5421
clang::OMPSectionDirective::CreateEmpty
static OMPSectionDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:526
clang::serialization::STMT_OMP_SIMD_DIRECTIVE
@ STMT_OMP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1912
clang::Stmt::SubstNonTypeTemplateParmExprBits
SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits
Definition: Stmt.h:1067
clang::serialization::EXPR_CXX_NOEXCEPT
@ EXPR_CXX_NOEXCEPT
Definition: ASTBitCodes.h:1875
clang::CompoundLiteralExpr::setInitializer
void setInitializer(Expr *E)
Definition: Expr.h:3430
clang::serialization::EXPR_CXX_DYNAMIC_CAST
@ EXPR_CXX_DYNAMIC_CAST
A CXXDynamicCastExpr record.
Definition: ASTBitCodes.h:1826
clang::ObjCMessageExpr::SuperClass
@ SuperClass
The receiver is a superclass.
Definition: ExprObjC.h:1094
clang::CastExpr::setCastKind
void setCastKind(CastKind K)
Definition: Expr.h:3520
clang::OMPTargetParallelGenericLoopDirective::CreateEmpty
static OMPTargetParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2307
clang::serialization::STMT_OMP_TARGET_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1957
clang::CastExpr::getTrailingFPFeatures
FPOptionsOverride * getTrailingFPFeatures()
Return a pointer to the trailing FPOptions.
Definition: Expr.cpp:1954
clang::CXXUnresolvedConstructExpr::getNumArgs
unsigned getNumArgs() const
Retrieve the number of arguments.
Definition: ExprCXX.h:3503
End
SourceLocation End
Definition: USRLocFinder.cpp:167
clang::serialization::EXPR_CXX_STD_INITIALIZER_LIST
@ EXPR_CXX_STD_INITIALIZER_LIST
A CXXStdInitializerListExpr record.
Definition: ASTBitCodes.h:1847
clang::serialization::EXPR_CXX_BOOL_LITERAL
@ EXPR_CXX_BOOL_LITERAL
A CXXBoolLiteralExpr record.
Definition: ASTBitCodes.h:1850
clang::ExprDependenceScope::ExprDependence
ExprDependence
Definition: DependenceFlags.h:17
clang::ConceptSpecializationExpr::Satisfaction
ASTConstraintSatisfaction * Satisfaction
Information about the satisfaction of the named concept with the given arguments.
Definition: ExprConcepts.h:56
clang::CallExpr::setADLCallKind
void setADLCallKind(ADLCallKind V=UsesADL)
Definition: Expr.h:2958
clang::DeclRefExpr::CreateEmpty
static DeclRefExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Construct an empty declaration reference expression.
Definition: Expr.cpp:494
clang::CoroutineBodyStmt::Create
static CoroutineBodyStmt * Create(const ASTContext &C, CtorArgs const &Args)
Definition: StmtCXX.cpp:86
clang::UnaryOperator::setCanOverflow
void setCanOverflow(bool C)
Definition: Expr.h:2224
clang::RequiresExpr::Create
static RequiresExpr * Create(ASTContext &C, SourceLocation RequiresKWLoc, RequiresExprBodyDecl *Body, ArrayRef< ParmVarDecl * > LocalParameters, ArrayRef< concepts::Requirement * > Requirements, SourceLocation RBraceLoc)
Definition: ExprConcepts.cpp:194
clang::ObjCBoolLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprObjC.h:108
clang::Stmt::ExprWithCleanupsBits
ExprWithCleanupsBitfields ExprWithCleanupsBits
Definition: Stmt.h:1060
clang::Stmt::EmptyShell
A placeholder type used to construct an empty shell of a type, that will be filled in later (e....
Definition: Stmt.h:1103
clang::OMPTargetTeamsDistributeParallelForDirective
This represents '#pragma omp target teams distribute parallel for' combined directive.
Definition: StmtOpenMP.h:4891
clang::FixedPointLiteral::Create
static FixedPointLiteral * Create(const ASTContext &C, EmptyShell Empty)
Returns an empty fixed-point literal.
Definition: Expr.cpp:930
clang::ParenExpr::setLParen
void setLParen(SourceLocation Loc)
Definition: Expr.h:2136
clang::OpaqueValueExpr
OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.
Definition: Expr.h:1135
clang::OMPArraySectionExpr::setLowerBound
void setLowerBound(Expr *E)
Set lower bound of the array section.
Definition: ExprOpenMP.h:99
clang::CXXUnresolvedConstructExpr::setArg
void setArg(unsigned I, Expr *E)
Definition: ExprCXX.h:3531
clang::SEHTryStmt
Definition: Stmt.h:3413
clang::CUDAKernelCallExpr::CreateEmpty
static CUDAKernelCallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Definition: ExprCXX.cpp:1738
clang::CXXFoldExpr
Represents a folding of a pack over an operator.
Definition: ExprCXX.h:4591
clang::serialization::STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
@ STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1938
clang::ObjCSubscriptRefExpr
ObjCSubscriptRefExpr - used for array and dictionary subscripting.
Definition: ExprObjC.h:841
clang::ObjCBoolLiteralExpr
ObjCBoolLiteralExpr - Objective-C Boolean Literal.
Definition: ExprObjC.h:88
clang::ConstantExpr::RSK_Int64
@ RSK_Int64
Definition: Expr.h:1044
clang::serialization::EXPR_CALL
@ EXPR_CALL
A CallExpr record.
Definition: ASTBitCodes.h:1641
clang::OMPTaskgroupDirective
This represents '#pragma omp taskgroup' directive.
Definition: StmtOpenMP.h:2602
clang::serialization::EXPR_OBJC_DICTIONARY_LITERAL
@ EXPR_OBJC_DICTIONARY_LITERAL
Definition: ASTBitCodes.h:1734
Decl.h
clang::ObjCIndirectCopyRestoreExpr
ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...
Definition: ExprObjC.h:1566
clang::OMPIteratorHelperData::CounterVD
VarDecl * CounterVD
Internal normalized counter.
Definition: ExprOpenMP.h:237
clang::serialization::STMT_OBJC_AUTORELEASE_POOL
@ STMT_OBJC_AUTORELEASE_POOL
An ObjCAutoreleasePoolStmt record.
Definition: ASTBitCodes.h:1785
clang::ConditionalOperator
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:4145
clang::CXXThrowExpr
A C++ throw-expression (C++ [except.throw]).
Definition: ExprCXX.h:1181
clang::ObjCArrayLiteral
ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...
Definition: ExprObjC.h:190
DeclObjC.h
clang::serialization::STMT_OMP_TASKLOOP_DIRECTIVE
@ STMT_OMP_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1945
clang::serialization::EXPR_DESIGNATED_INIT
@ EXPR_DESIGNATED_INIT
A DesignatedInitExpr record.
Definition: ASTBitCodes.h:1671
clang::serialization::EXPR_OBJC_PROTOCOL_EXPR
@ EXPR_OBJC_PROTOCOL_EXPR
An ObjCProtocolExpr record.
Definition: ASTBitCodes.h:1743
clang::serialization::EXPR_ADDR_LABEL
@ EXPR_ADDR_LABEL
An AddrLabelExpr record.
Definition: ASTBitCodes.h:1692
clang::ObjCPropertyRefExpr
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
clang::ConstraintSatisfaction::Details
llvm::SmallVector< std::pair< const Expr *, Detail >, 4 > Details
Pairs of unsatisfied atomic constraint expressions along with the substituted constraint expr,...
Definition: ASTConcept.h:52
clang::BinaryOperator::setStoredFPFeatures
void setStoredFPFeatures(FPOptionsOverride F)
Set FPFeatures in trailing storage, used only by Serialization.
Definition: Expr.h:3998
clang::ASTStmtReader::VisitStmt
void VisitStmt(Stmt *S)
Definition: ASTReaderStmt.cpp:141
clang::CXXTemporaryObjectExpr
Represents a C++ functional cast expression that builds a temporary object.
Definition: ExprCXX.h:1797
clang::FunctionParmPackExpr
Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...
Definition: ExprCXX.h:4397
clang::serialization::EXPR_OBJC_BOXED_EXPRESSION
@ EXPR_OBJC_BOXED_EXPRESSION
Definition: ASTBitCodes.h:1732
clang::OMPTaskLoopDirective::CreateEmpty
static OMPTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1064
clang::FixedPointLiteral
Definition: Expr.h:1537
clang::OMPTargetExitDataDirective
This represents '#pragma omp target exit data' directive.
Definition: StmtOpenMP.h:3171
clang::FloatingLiteral::getSemantics
const llvm::fltSemantics & getSemantics() const
Return the APFloat semantics this literal uses.
Definition: Expr.h:1675
clang::OMPExecutableDirective::Data
OMPChildren * Data
Data, associated with the directive.
Definition: StmtOpenMP.h:286
clang::ConstantExpr::RSK_APValue
@ RSK_APValue
Definition: Expr.h:1044
clang::OMPForSimdDirective
This represents '#pragma omp for simd' directive.
Definition: StmtOpenMP.h:1718
clang::ArraySubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2696
clang::ObjCMessageExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: ExprObjC.h:1395
clang::AttributedStmt
Represents an attribute applied to a statement.
Definition: Stmt.h:1851
clang::OMPParallelGenericLoopDirective
This represents '#pragma omp parallel loop' directive.
Definition: StmtOpenMP.h:5728
clang::CXXDependentScopeMemberExpr::CreateEmpty
static CXXDependentScopeMemberExpr * CreateEmpty(const ASTContext &Ctx, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs, bool HasFirstQualifierFoundInScope)
Definition: ExprCXX.cpp:1429
clang::UnaryOperator::hasStoredFPFeatures
bool hasStoredFPFeatures() const
Is FPFeatures in Trailing Storage?
Definition: Expr.h:2306
TemplateBase.h
clang::IntegerLiteral
Definition: Expr.h:1494
clang::PseudoObjectExpr::Create
static PseudoObjectExpr * Create(const ASTContext &Context, Expr *syntactic, ArrayRef< Expr * > semantic, unsigned resultIndex)
Definition: Expr.cpp:4632
clang::serialization::STMT_OMP_UNROLL_DIRECTIVE
@ STMT_OMP_UNROLL_DIRECTIVE
Definition: ASTBitCodes.h:1914
clang::ObjCAtCatchStmt
Represents Objective-C's @catch statement.
Definition: StmtObjC.h:77
clang::UnaryExprOrTypeTraitExpr
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.
Definition: Expr.h:2549
clang::FloatingLiteral
Definition: Expr.h:1639
clang::serialization::EXPR_CXX_CONSTRUCT
@ EXPR_CXX_CONSTRUCT
A CXXConstructExpr record.
Definition: ASTBitCodes.h:1814
clang::OMPTargetTeamsDistributeParallelForDirective::CreateEmpty
static OMPTargetTeamsDistributeParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1927
clang::TemplateArgument::getKind
ArgKind getKind() const
Return the kind of stored template argument.
Definition: TemplateBase.h:244
clang::AddrLabelExpr::setAmpAmpLoc
void setAmpAmpLoc(SourceLocation L)
Definition: Expr.h:4320
clang::ObjCIvarRefExpr::setIsArrow
void setIsArrow(bool A)
Definition: ExprObjC.h:586
clang::ASTRecordReader::readTypeSourceInfo
TypeSourceInfo * readTypeSourceInfo()
Reads a declarator info from the given record, advancing Idx.
Definition: ASTReader.cpp:6836
clang::MemberExprNameQualifier
Extra data stored in some MemberExpr objects.
Definition: Expr.h:3152
clang::CompoundStmt
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1404
clang::ConvertVectorExpr
ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...
Definition: Expr.h:4465
clang::ObjCSelectorExpr
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:454
DeclTemplate.h
clang::serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER
@ EXPR_CXX_DEPENDENT_SCOPE_MEMBER
Definition: ASTBitCodes.h:1868
clang::MSPropertySubscriptExpr
MS property subscript expression.
Definition: ExprCXX.h:994
clang::serialization::ModuleFile::DeclsCursor
llvm::BitstreamCursor DeclsCursor
DeclsCursor - This is a cursor to the start of the DECLTYPES_BLOCK block.
Definition: ModuleFile.h:431
clang::CXXAddrspaceCastExpr
A C++ addrspace_cast expression (currently only enabled for OpenCL).
Definition: ExprCXX.h:600
clang::serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE
@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1950
clang::OMPParallelMasterDirective
This represents '#pragma omp parallel master' directive.
Definition: StmtOpenMP.h:2252
clang::UnresolvedLookupExpr
A reference to a name which we were able to look up during parsing but could not resolve to a specifi...
Definition: ExprCXX.h:3090
clang::RequiresExprBodyDecl
Represents the body of a requires-expression.
Definition: DeclCXX.h:1946
clang::CXXRewrittenBinaryOperator
A rewritten comparison expression that was originally written using operator syntax.
Definition: ExprCXX.h:284
clang::StringLiteral::getNumConcatenated
unsigned getNumConcatenated() const
getNumConcatenated - Get the number of string literal tokens that were concatenated in translation ph...
Definition: Expr.h:1909
clang::OMPIteratorExpr::setIteratorKwLoc
void setIteratorKwLoc(SourceLocation L)
Definition: ExprOpenMP.h:373
clang::serialization::StmtCode
StmtCode
Record codes for each kind of statement or expression.
Definition: ASTBitCodes.h:1524
clang::TemplateArgumentListInfo
A convenient class for passing around template argument information.
Definition: TemplateBase.h:563
clang::CXXNewExpr::setOperatorNew
void setOperatorNew(FunctionDecl *D)
Definition: ExprCXX.h:2258
clang::serialization::EXPR_CXX_MEMBER_CALL
@ EXPR_CXX_MEMBER_CALL
A CXXMemberCallExpr record.
Definition: ASTBitCodes.h:1808
clang::serialization::STMT_OMP_TASKGROUP_DIRECTIVE
@ STMT_OMP_TASKGROUP_DIRECTIVE
Definition: ASTBitCodes.h:1942
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
StmtOpenMP.h
clang::DeclAccessPair::make
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
Definition: DeclAccessPair.h:35
clang::CXXBoolLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:740
clang::CXXConstructExpr::CreateEmpty
static CXXConstructExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Create an empty C++ construction expression.
Definition: ExprCXX.cpp:1049
clang::DependentCoawaitExpr
Represents a 'co_await' expression while the type of the promise is dependent.
Definition: ExprCXX.h:4821
clang::SizeOfPackExpr
Represents an expression that computes the length of a parameter pack.
Definition: ExprCXX.h:4144
clang::serialization::STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
@ STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE
Definition: ASTBitCodes.h:1925
clang::CXXBindTemporaryExpr
Represents binding an expression to a temporary.
Definition: ExprCXX.h:1412
clang::ShuffleVectorExpr::setExprs
void setExprs(const ASTContext &C, ArrayRef< Expr * > Exprs)
Definition: Expr.cpp:4202
clang::OverloadExpr::getNumDecls
unsigned getNumDecls() const
Gets the number of declarations in the unresolved set.
Definition: ExprCXX.h:3000
clang::serialization::EXPR_ARRAY_SUBSCRIPT
@ EXPR_ARRAY_SUBSCRIPT
An ArraySubscriptExpr record.
Definition: ASTBitCodes.h:1635
clang::CXXReinterpretCastExpr::CreateEmpty
static CXXReinterpretCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Definition: ExprCXX.cpp:811
clang::BinaryOperator
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3807
clang::ObjCSubscriptRefExpr::setKeyExpr
void setKeyExpr(Stmt *S)
Definition: ExprObjC.h:884
clang::InitListExpr::setRBraceLoc
void setRBraceLoc(SourceLocation Loc)
Definition: Expr.h:4943
clang::OMPTargetUpdateDirective::CreateEmpty
static OMPTargetUpdateDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1351
clang::OMPForDirective::CreateEmpty
static OMPForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:398
clang::OverloadExpr::getTrailingResults
DeclAccessPair * getTrailingResults()
Return the results. Defined after UnresolvedMemberExpr.
Definition: ExprCXX.h:3981
clang::OMPDistributeSimdDirective::CreateEmpty
static OMPDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1514
clang::TemplateArgumentListInfo::addArgument
void addArgument(const TemplateArgumentLoc &Loc)
Definition: TemplateBase.h:603
clang::OMPTeamsDirective
This represents '#pragma omp teams' directive.
Definition: StmtOpenMP.h:3400
clang::VAArgExpr::setIsMicrosoftABI
void setIsMicrosoftABI(bool IsMS)
Definition: Expr.h:4655
clang::serialization::STMT_SEH_LEAVE
@ STMT_SEH_LEAVE
Definition: ASTBitCodes.h:1903
clang::LambdaExpr
A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...
Definition: ExprCXX.h:1865
clang::OMPLoopDirective
This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....
Definition: StmtOpenMP.h:1002
clang::FloatingLiteral::setExact
void setExact(bool E)
Definition: Expr.h:1687
clang::ObjCAtThrowStmt
Represents Objective-C's @throw statement.
Definition: StmtObjC.h:357
clang::CXXThisExpr::setImplicit
void setImplicit(bool I)
Definition: ExprCXX.h:1160
OperatorKinds.h
clang::Stmt::PredefinedExprBits
PredefinedExprBitfields PredefinedExprBits
Definition: Stmt.h:1024
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:220
clang::ObjCProtocolExpr::setProtocol
void setProtocol(ObjCProtocolDecl *P)
Definition: ExprObjC.h:522
clang::OMPParallelForDirective::CreateEmpty
static OMPParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:618
clang::ObjCStringLiteral
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:52
clang::threadSafety::sx::toString
std::string toString(const til::SExpr *E)
Definition: ThreadSafetyCommon.h:90
clang::DeclAccessPair
A POD class for pairing a NamedDecl* with an access specifier.
Definition: DeclAccessPair.h:29
clang::ConceptReference::ConceptName
DeclarationNameInfo ConceptName
The concept name used.
Definition: ASTConcept.h:109
clang::Stmt::CXXDefaultInitExprBits
CXXDefaultInitExprBitfields CXXDefaultInitExprBits
Definition: Stmt.h:1053
clang::serialization::STMT_ATTRIBUTED
@ STMT_ATTRIBUTED
An AttributedStmt record.
Definition: ASTBitCodes.h:1551
clang::ConceptSpecializationExpr
Represents the specialization of a concept - evaluates to a prvalue of type bool.
Definition: ExprConcepts.h:40
clang::OMPScanDirective
This represents '#pragma omp scan' directive.
Definition: StmtOpenMP.h:5274
clang::MaterializeTemporaryExpr
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition: ExprCXX.h:4479
clang::serialization::EXPR_DESIGNATED_INIT_UPDATE
@ EXPR_DESIGNATED_INIT_UPDATE
A DesignatedInitUpdateExpr record.
Definition: ASTBitCodes.h:1674
clang::CXXTryStmt::Create
static CXXTryStmt * Create(const ASTContext &C, SourceLocation tryLoc, Stmt *tryBlock, ArrayRef< Stmt * > handlers)
Definition: StmtCXX.cpp:25
clang::OMPMaskedDirective::CreateEmpty
static OMPMaskedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:2089
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:208
clang::index::SymbolRole::Implicit
@ Implicit
clang::serialization::EXPR_CXX_TYPEID_EXPR
@ EXPR_CXX_TYPEID_EXPR
Definition: ASTBitCodes.h:1853
clang::ObjCDictionaryLiteral
ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...
Definition: ExprObjC.h:306
clang::serialization::EXPR_CXX_STATIC_CAST
@ EXPR_CXX_STATIC_CAST
A CXXStaticCastExpr record.
Definition: ASTBitCodes.h:1823
clang::OMPMetaDirective
This represents '#pragma omp metadirective' directive.
Definition: StmtOpenMP.h:5496
NestedNameSpecifier.h
LangOptions.h
clang::serialization::EXPR_OBJC_AVAILABILITY_CHECK
@ EXPR_OBJC_AVAILABILITY_CHECK
An ObjCAvailabilityCheckExpr record.
Definition: ASTBitCodes.h:1791
clang::Stmt::MemberExprBits
MemberExprBitfields MemberExprBits
Definition: Stmt.h:1033
clang::CXXConstructExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
Set the specified argument.
Definition: ExprCXX.h:1621
clang::ImplicitCastExpr::setIsPartOfExplicitCast
void setIsPartOfExplicitCast(bool PartOfExplicitCast)
Definition: Expr.h:3654
clang::Stmt::StmtExprBits
StmtExprBitfields StmtExprBits
Definition: Stmt.h:1043
clang::OMPCriticalDirective::CreateEmpty
static OMPCriticalDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:573
clang::serialization::STMT_OMP_TILE_DIRECTIVE
@ STMT_OMP_TILE_DIRECTIVE
Definition: ASTBitCodes.h:1913
clang::CallExpr::setArg
void setArg(unsigned Arg, Expr *ArgExpr)
setArg - Set the specified argument.
Definition: Expr.h:3005
clang::BinaryOperator::setRHS
void setRHS(Expr *E)
Definition: Expr.h:3859
clang::serialization::EXPR_CXX_BIND_TEMPORARY
@ EXPR_CXX_BIND_TEMPORARY
Definition: ASTBitCodes.h:1859
clang::concepts::NestedRequirement
A requires-expression requirement which is satisfied when a general constraint expression is satisfie...
Definition: ExprConcepts.h:407
TypeTraits.h
clang::Stmt::CXXConstructExprBits
CXXConstructExprBitfields CXXConstructExprBits
Definition: Stmt.h:1059
clang::OMPIteratorHelperData::CounterUpdate
Expr * CounterUpdate
Updater for the internal counter: ++CounterVD;.
Definition: ExprOpenMP.h:245
clang::ConceptReference::NamedConcept
ConceptDecl * NamedConcept
The concept named.
Definition: ASTConcept.h:118
clang::BuiltinBitCastExpr
Represents a C++2a __builtin_bit_cast(T, v) expression.
Definition: ExprCXX.h:4894
clang::ExprWithCleanups::CleanupObject
llvm::PointerUnion< BlockDecl *, CompoundLiteralExpr * > CleanupObject
The type of objects that are kept in the cleanup.
Definition: ExprCXX.h:3369
clang::serialization::STMT_OMP_FOR_SIMD_DIRECTIVE
@ STMT_OMP_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1916
clang::serialization::EXPR_SOURCE_LOC
@ EXPR_SOURCE_LOC
A SourceLocExpr record.
Definition: ASTBitCodes.h:1704
clang::serialization::STMT_DO
@ STMT_DO
A DoStmt record.
Definition: ASTBitCodes.h:1563
clang::TemplateArgument
Represents a template argument.
Definition: TemplateBase.h:61
clang::CharacterLiteral::setKind
void setKind(CharacterKind kind)
Definition: Expr.h:1621
OpenMPKinds.h
clang::serialization::EXPR_IMPLICIT_CAST
@ EXPR_IMPLICIT_CAST
An ImplicitCastExpr record.
Definition: ASTBitCodes.h:1656
clang::concepts::Requirement
A static requirement that can be used in a requires-expression to check properties of types and expre...
Definition: ExprConcepts.h:149
clang::OMPDistributeParallelForSimdDirective
This represents '#pragma omp distribute parallel for simd' composite directive.
Definition: StmtOpenMP.h:4213
clang::SwitchStmt::CreateEmpty
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:1082
clang::ASTStmtReader
Definition: ASTReaderStmt.cpp:71
clang::CastExpr::path_begin
path_iterator path_begin()
Definition: Expr.h:3545
clang::ObjCMessageExpr::setSelector
void setSelector(Selector S)
Definition: ExprObjC.h:1341
clang::serialization::STMT_OMP_PARALLEL_DIRECTIVE
@ STMT_OMP_PARALLEL_DIRECTIVE
Definition: ASTBitCodes.h:1911
clang::DesignatedInitUpdateExpr::setBase
void setBase(Expr *Base)
Definition: Expr.h:5387
clang::ForStmt
ForStmt - This represents a 'for (init;cond;inc)' stmt.
Definition: Stmt.h:2539
clang::ObjCAvailabilityCheckExpr
A runtime availability query.
Definition: ExprObjC.h:1686
clang::CXXFunctionalCastExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:1767
clang::serialization::STMT_OBJC_AT_TRY
@ STMT_OBJC_AT_TRY
An ObjCAtTryStmt record.
Definition: ASTBitCodes.h:1776
clang::OMPDepobjDirective
This represents '#pragma omp depobj' directive.
Definition: StmtOpenMP.h:2721
clang::CastExpr::hasStoredFPFeatures
bool hasStoredFPFeatures() const
Definition: Expr.h:3562
clang::ASTRecordReader::readString
std::string readString()
Read a string, advancing Idx.
Definition: ASTRecordReader.h:309
clang::serialization::STMT_OBJC_FOR_COLLECTION
@ STMT_OBJC_FOR_COLLECTION
An ObjCForCollectionStmt record.
Definition: ASTBitCodes.h:1767
clang::CXXNullPtrLiteralExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:774
clang::serialization::STMT_CXX_CATCH
@ STMT_CXX_CATCH
A CXXCatchStmt record.
Definition: ASTBitCodes.h:1796
clang::ASTTemplateKWAndArgsInfo::initializeFrom
void initializeFrom(SourceLocation TemplateKWLoc, const TemplateArgumentListInfo &List, TemplateArgumentLoc *OutArgArray)
Definition: TemplateBase.cpp:631
clang::Stmt::CXXRewrittenBinaryOperatorBits
CXXRewrittenBinaryOperatorBitfields CXXRewrittenBinaryOperatorBits
Definition: Stmt.h:1047
clang::PseudoObjectExpr
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:6100
clang::ObjCAtSynchronizedStmt
Represents Objective-C's @synchronized statement.
Definition: StmtObjC.h:302
clang::ObjCMessageExpr::getReceiverKind
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1224
clang::DesignatedInitExpr::getNumSubExprs
unsigned getNumSubExprs() const
Retrieve the total number of subexpressions in this designated initializer expression,...
Definition: Expr.h:5282
clang::serialization::EXPR_ASTYPE
@ EXPR_ASTYPE
Definition: ASTBitCodes.h:1896
clang::IntegerLiteral::Create
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value 'V' and type 'type'.
Definition: Expr.cpp:900
clang::InitListExpr::setLBraceLoc
void setLBraceLoc(SourceLocation Loc)
Definition: Expr.h:4941
clang::UnaryOperator::setOpcode
void setOpcode(Opcode Opc)
Definition: Expr.h:2208
clang::index::SymbolKind::Field
@ Field
clang::ChooseExpr::setRHS
void setRHS(Expr *E)
Definition: Expr.h:4569
clang::BinaryConditionalOperator
BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...
Definition: Expr.h:4207
clang::CXXNewExpr::raw_arg_end
raw_arg_iterator raw_arg_end()
Definition: ExprCXX.h:2385
clang::ParenListExpr::getNumExprs
unsigned getNumExprs() const
Return the number of expressions in this paren list.
Definition: Expr.h:5563
clang::serialization::EXPR_BUILTIN_BIT_CAST
@ EXPR_BUILTIN_BIT_CAST
A BuiltinBitCastExpr record.
Definition: ASTBitCodes.h:1841
clang::InitListExpr::updateInit
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:2284
clang::CapturedStmt::VariableCaptureKind
VariableCaptureKind
The different capture forms: by 'this', by reference, capture for variable-length array type etc.
Definition: Stmt.h:3509
clang::DeclRefExpr::getDecl
ValueDecl * getDecl()
Definition: Expr.h:1295
clang::TemplateArgumentLoc
Location wrapper for a TemplateArgument.
Definition: TemplateBase.h:457
clang::OMPTargetTeamsDirective::CreateEmpty
static OMPTargetTeamsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1822
Type.h
clang::ExtVectorElementExpr::setAccessor
void setAccessor(IdentifierInfo *II)
Definition: Expr.h:5932
clang::Stmt::RequiresExprBits
RequiresExprBitfields RequiresExprBits
Definition: Stmt.h:1069
clang::OMPAtomicDirective::CreateEmpty
static OMPAtomicDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:883
clang::Expr::isInstantiationDependent
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
Definition: Expr.h:214
clang::ObjCMessageExpr::Class
@ Class
The receiver is a class.
Definition: ExprObjC.h:1088
clang::ObjCMessageExpr::setDelegateInitCall
void setDelegateInitCall(bool isDelegate)
Definition: ExprObjC.h:1404
clang::OMPLoopBasedDirective
The base class for all loop-based directives, including loop transformation directives.
Definition: StmtOpenMP.h:682
Expr.h
clang::serialization::EXPR_CONCEPT_SPECIALIZATION
@ EXPR_CONCEPT_SPECIALIZATION
Definition: ASTBitCodes.h:1889
clang::ConceptSpecializationExpr::Create
static ConceptSpecializationExpr * Create(const ASTContext &C, NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo, NamedDecl *FoundDecl, ConceptDecl *NamedConcept, const ASTTemplateArgumentListInfo *ArgsAsWritten, ArrayRef< TemplateArgument > ConvertedArgs, const ConstraintSatisfaction *Satisfaction)
Definition: ExprConcepts.cpp:72
clang::ImplicitValueInitExpr
Represents an implicitly-generated value initialization of an object of a given type.
Definition: Expr.h:5510
bool
#define bool
Definition: stdbool.h:20
clang::CXXBindTemporaryExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: ExprCXX.h:1436
clang::serialization::STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1956
clang::TemplateArgumentListInfo::setLAngleLoc
void setLAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:582
clang::OMPParallelDirective
This represents '#pragma omp parallel' directive.
Definition: StmtOpenMP.h:611
ASTContext.h
clang::UnresolvedSet< 8 >
clang::CStyleCastExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:3771
clang::serialization::DesignatorTypes
DesignatorTypes
The kinds of designators that can occur in a DesignatedInitExpr.
Definition: ASTBitCodes.h:1999
clang::CXXDynamicCastExpr
A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).
Definition: ExprCXX.h:477
clang::OMPLoopTransformationDirective::setNumGeneratedLoops
void setNumGeneratedLoops(unsigned Num)
Set the number of loops generated by this loop transformation.
Definition: StmtOpenMP.h:974
clang::OMPParallelForSimdDirective
This represents '#pragma omp parallel for simd' directive.
Definition: StmtOpenMP.h:2187
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::ObjCAtTryStmt::CreateEmpty
static ObjCAtTryStmt * CreateEmpty(const ASTContext &Context, unsigned NumCatchStmts, bool HasFinally)
Definition: StmtObjC.cpp:56
clang::OMPTaskDirective
This represents '#pragma omp task' directive.
Definition: StmtOpenMP.h:2397
clang::OffsetOfExpr::getNumComponents
unsigned getNumComponents() const
Definition: Expr.h:2503
clang::FloatingLiteral::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:1695
clang::OffsetOfExpr::setTypeSourceInfo
void setTypeSourceInfo(TypeSourceInfo *tsi)
Definition: Expr.h:2489
clang::CapturedStmt::CreateDeserialized
static CapturedStmt * CreateDeserialized(const ASTContext &Context, unsigned NumCaptures)
Definition: Stmt.cpp:1370
clang::ObjCIsaExpr::setBase
void setBase(Expr *E)
Definition: ExprObjC.h:1506
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1767
clang::serialization::STMT_CORETURN
@ STMT_CORETURN
Definition: ASTBitCodes.h:1985
clang::OMPTargetParallelDirective
This represents '#pragma omp target parallel' directive.
Definition: StmtOpenMP.h:3225
clang::serialization::STMT_OMP_CANCEL_DIRECTIVE
@ STMT_OMP_CANCEL_DIRECTIVE
Definition: ASTBitCodes.h:1944
clang::ExprWithCleanups
Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...
Definition: ExprCXX.h:3359
clang::serialization::STMT_OMP_TARGET_PARALLEL_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_DIRECTIVE
Definition: ASTBitCodes.h:1939
clang::CapturedStmt
This captures a statement into a function.
Definition: Stmt.h:3505
clang::ObjCAtFinallyStmt
Represents Objective-C's @finally statement.
Definition: StmtObjC.h:127
OperationKinds.h
clang::OMPParallelForDirective
This represents '#pragma omp parallel for' directive.
Definition: StmtOpenMP.h:2090
clang::serialization::STMT_OMP_SCAN_DIRECTIVE
@ STMT_OMP_SCAN_DIRECTIVE
Definition: ASTBitCodes.h:1932
clang::serialization::STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1973
clang::DesignatedInitExpr::setEqualOrColonLoc
void setEqualOrColonLoc(SourceLocation L)
Definition: Expr.h:5258
clang::serialization::EXPR_UNARY_OPERATOR
@ EXPR_UNARY_OPERATOR
A UnaryOperator record.
Definition: ASTBitCodes.h:1626
clang::ObjCSelectorExpr::setSelector
void setSelector(Selector S)
Definition: ExprObjC.h:469
clang::OpaqueValueExpr::setIsUnique
void setIsUnique(bool V)
Definition: Expr.h:1187
clang::ImaginaryLiteral::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:1732
clang::serialization::STMT_OMP_DISPATCH_DIRECTIVE
@ STMT_OMP_DISPATCH_DIRECTIVE
Definition: ASTBitCodes.h:1968
clang::OMPParallelSectionsDirective::CreateEmpty
static OMPParallelSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:697
clang::serialization::EXPR_OMP_ARRAY_SHAPING
@ EXPR_OMP_ARRAY_SHAPING
Definition: ASTBitCodes.h:1976
clang::ObjCIvarRefExpr::setBase
void setBase(Expr *base)
Definition: ExprObjC.h:582
clang::CStyleCastExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:3774
clang::CXXTryStmt
CXXTryStmt - A C++ try block, including all handlers.
Definition: StmtCXX.h:68
clang::SwitchCase
Definition: Stmt.h:1527
ExprObjC.h
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::serialization::STMT_BREAK
@ STMT_BREAK
A BreakStmt record.
Definition: ASTBitCodes.h:1578
ExprCXX.h
clang::serialization::STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1955
clang::OMPMasterDirective::CreateEmpty
static OMPMasterDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:558
Base
clang::serialization::STMT_OMP_TEAMS_DIRECTIVE
@ STMT_OMP_TEAMS_DIRECTIVE
Definition: ASTBitCodes.h:1941
clang::FixedPointLiteral::setScale
void setScale(unsigned S)
Definition: Expr.h:1567
clang::ReturnStmt::CreateEmpty
static ReturnStmt * CreateEmpty(const ASTContext &Ctx, bool HasNRVOCandidate)
Create an empty return statement, optionally with storage for an NRVO candidate.
Definition: Stmt.cpp:1202
clang::ObjCEncodeExpr
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:409
clang::serialization::STMT_NULL_PTR
@ STMT_NULL_PTR
A NULL expression.
Definition: ASTBitCodes.h:1530
clang::CXXInheritedCtorInitExpr
Represents a call to an inherited base class constructor from an inheriting constructor.
Definition: ExprCXX.h:1651
clang::CXXDefaultArgExpr
A default argument (C++ [dcl.fct.default]).
Definition: ExprCXX.h:1241
clang::serialization::STMT_RETURN
@ STMT_RETURN
A ReturnStmt record.
Definition: ASTBitCodes.h:1581
clang::PackExpansionExpr
Represents a C++11 pack expansion that produces a sequence of expressions.
Definition: ExprCXX.h:4068
clang::CastExpr::path_size
unsigned path_size() const
Definition: Expr.h:3544
clang::concepts::TypeRequirement::SatisfactionStatus
SatisfactionStatus
Definition: ExprConcepts.h:205
clang::UnaryExprOrTypeTraitExpr::setArgument
void setArgument(Expr *E)
Definition: Expr.h:2607
clang::IfStmt::CreateEmpty
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:963
clang::OMPCriticalDirective
This represents '#pragma omp critical' directive.
Definition: StmtOpenMP.h:2019
clang::DeclRefExpr::hasQualifier
bool hasQualifier() const
Determine whether this declaration reference was preceded by a C++ nested-name-specifier,...
Definition: Expr.h:1310
clang::AtomicExpr::AtomicOp
AtomicOp
Definition: Expr.h:6236
clang::OMPTargetTeamsGenericLoopDirective
This represents '#pragma omp target teams loop' directive.
Definition: StmtOpenMP.h:5662
ASTConcept.h
This file provides AST data structures related to concepts.
clang::OMPTargetParallelForSimdDirective
This represents '#pragma omp target parallel for simd' directive.
Definition: StmtOpenMP.h:4344
DeclGroup.h
clang::CompoundLiteralExpr::setTypeSourceInfo
void setTypeSourceInfo(TypeSourceInfo *tinfo)
Definition: Expr.h:3441
clang::serialization::EXPR_OBJC_ISA
@ EXPR_OBJC_ISA
An ObjCIsa Expr record.
Definition: ASTBitCodes.h:1761
clang::ObjCIvarRefExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprObjC.h:590
clang::OMPMasterTaskLoopDirective
This represents '#pragma omp master taskloop' directive.
Definition: StmtOpenMP.h:3710
clang::serialization::EXPR_SYCL_UNIQUE_STABLE_NAME
@ EXPR_SYCL_UNIQUE_STABLE_NAME
Definition: ASTBitCodes.h:1994
clang::BlockExpr::setBlockDecl
void setBlockDecl(BlockDecl *BD)
Definition: Expr.h:5984
clang::concepts::Requirement::RK_Compound
@ RK_Compound
Definition: ExprConcepts.h:153
clang::ConstantExpr
ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...
Definition: Expr.h:1032
clang::serialization::EXPR_DECL_REF
@ EXPR_DECL_REF
A DeclRefExpr record.
Definition: ASTBitCodes.h:1602
clang::concepts::Requirement::RK_Simple
@ RK_Simple
Definition: ExprConcepts.h:153
clang::serialization::EXPR_MEMBER
@ EXPR_MEMBER
A MemberExpr record.
Definition: ASTBitCodes.h:1644
clang::serialization::EXPR_REQUIRES
@ EXPR_REQUIRES
Definition: ASTBitCodes.h:1890
clang::ObjCMessageExpr
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:940
clang::OMPTeamsDistributeDirective
This represents '#pragma omp teams distribute' directive.
Definition: StmtOpenMP.h:4476
clang::serialization::COK_Block
@ COK_Block
Definition: ASTBitCodes.h:2024
clang::OMPTargetParallelForDirective::CreateEmpty
static OMPTargetParallelForDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:962
clang::OffsetOfNode
Helper class for OffsetOfExpr.
Definition: Expr.h:2340
clang::serialization::STMT_COROUTINE_BODY
@ STMT_COROUTINE_BODY
Definition: ASTBitCodes.h:1984
clang::serialization::EXPR_CXX_REWRITTEN_BINARY_OPERATOR
@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR
A CXXRewrittenBinaryOperator record.
Definition: ASTBitCodes.h:1811
clang::ASTRecordReader::readDecl
Decl * readDecl()
Reads a declaration from the given position in a record in the given module, advancing Idx.
Definition: ASTRecordReader.h:192
clang::FullExpr::SubExpr
Stmt * SubExpr
Definition: Expr.h:1006
StmtObjC.h
clang::CompoundStmt::CreateEmpty
static CompoundStmt * CreateEmpty(const ASTContext &C, unsigned NumStmts)
Definition: Stmt.cpp:386
clang::serialization::STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1972
clang::ChooseExpr
ChooseExpr - GNU builtin-in function __builtin_choose_expr.
Definition: Expr.h:4524
clang::serialization::EXPR_CXX_REINTERPRET_CAST
@ EXPR_CXX_REINTERPRET_CAST
A CXXReinterpretCastExpr record.
Definition: ASTBitCodes.h:1829
clang::ObjCIsaExpr::setOpLoc
void setOpLoc(SourceLocation L)
Definition: ExprObjC.h:1518
clang::ConstraintSatisfaction::IsSatisfied
bool IsSatisfied
Definition: ASTConcept.h:46
clang::ObjCMessageExpr::ReceiverKind
ReceiverKind
The kind of receiver this message is sending to.
Definition: ExprObjC.h:1086
clang::ConceptReference::ArgsAsWritten
const ASTTemplateArgumentListInfo * ArgsAsWritten
The template argument list source info used to specialize the concept.
Definition: ASTConcept.h:122
clang::SEHExceptStmt
Definition: Stmt.h:3334
clang::InitListExpr::sawArrayRangeDesignator
void sawArrayRangeDesignator(bool ARD=true)
Definition: Expr.h:4966
clang::OMPTaskyieldDirective::CreateEmpty
static OMPTaskyieldDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:726
clang::OMPArrayShapingExpr
An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......
Definition: ExprOpenMP.h:146
clang::Stmt::CXXDefaultArgExprBits
CXXDefaultArgExprBitfields CXXDefaultArgExprBits
Definition: Stmt.h:1052
clang::serialization::EXPR_BLOCK
@ EXPR_BLOCK
BlockExpr.
Definition: ASTBitCodes.h:1713
clang::MatrixSubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: Expr.h:2778
clang::ASTReader::ReadSubExpr
Expr * ReadSubExpr()
Reads a sub-expression operand during statement reading.
Definition: ASTReaderStmt.cpp:2663
clang::serialization::EXPR_CXX_THROW
@ EXPR_CXX_THROW
Definition: ASTBitCodes.h:1856
clang::OMPMetaDirective::CreateEmpty
static OMPMetaDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Definition: StmtOpenMP.cpp:273
clang::serialization::STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE
Definition: ASTBitCodes.h:1964
clang::serialization::EXPR_CXX_FOLD
@ EXPR_CXX_FOLD
Definition: ASTBitCodes.h:1888
clang::serialization::STMT_INDIRECT_GOTO
@ STMT_INDIRECT_GOTO
An IndirectGotoStmt record.
Definition: ASTBitCodes.h:1572
clang::ObjCDictionaryLiteral_ExpansionData
Internal struct to describes an element that is a pack expansion, used if any of the elements in the ...
Definition: ExprObjC.h:294
clang::UnaryExprOrTypeTraitExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:2626
clang::GenericSelectionExpr::CreateEmpty
static GenericSelectionExpr * CreateEmpty(const ASTContext &Context, unsigned NumAssocs)
Create an empty generic selection expression for deserialization.
Definition: Expr.cpp:4290
clang::serialization::STMT_DEFAULT
@ STMT_DEFAULT
A DefaultStmt record.
Definition: ASTBitCodes.h:1545
clang::serialization::STMT_OMP_TARGET_DIRECTIVE
@ STMT_OMP_TARGET_DIRECTIVE
Definition: ASTBitCodes.h:1935
clang::OMPTargetTeamsDistributeDirective::CreateEmpty
static OMPTargetTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1864
clang::CharacterLiteral
Definition: Expr.h:1584
clang::OMPScanDirective::CreateEmpty
static OMPScanDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:842
clang::UserDefinedLiteral
A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....
Definition: ExprCXX.h:638
clang::CXXTypeidExpr::setSourceRange
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:894
clang::BinaryOperator::setLHS
void setLHS(Expr *E)
Definition: Expr.h:3857
clang::CompoundAssignOperator::CreateEmpty
static CompoundAssignOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
Definition: Expr.cpp:4552
clang::OMPTargetSimdDirective::CreateEmpty
static OMPTargetSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1597
clang::ChooseExpr::setIsConditionTrue
void setIsConditionTrue(bool isTrue)
Definition: Expr.h:4552
clang::serialization::EXPR_CXX_EXPRESSION_TRAIT
@ EXPR_CXX_EXPRESSION_TRAIT
Definition: ASTBitCodes.h:1874
clang::AddrLabelExpr::setLabelLoc
void setLabelLoc(SourceLocation L)
Definition: Expr.h:4322
clang::serialization::STMT_OMP_DEPOBJ_DIRECTIVE
@ STMT_OMP_DEPOBJ_DIRECTIVE
Definition: ASTBitCodes.h:1931
clang::transformer::EditKind::Range
@ Range
clang::MemberExpr::CreateEmpty
static MemberExpr * CreateEmpty(const ASTContext &Context, bool HasQualifier, bool HasFoundDecl, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: Expr.cpp:1681
clang::GNUNullExpr::setTokenLocation
void setTokenLocation(SourceLocation L)
Definition: Expr.h:4614
clang::serialization::EXPR_PAREN_LIST
@ EXPR_PAREN_LIST
A ParenListExpr record.
Definition: ASTBitCodes.h:1623
clang::OMPCancelDirective
This represents '#pragma omp cancel' directive.
Definition: StmtOpenMP.h:3511
clang::CompoundLiteralExpr
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3405
clang::OMPTeamsDistributeParallelForSimdDirective::CreateEmpty
static OMPTeamsDistributeParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1741
clang::serialization::EXPR_SIZEOF_ALIGN_OF
@ EXPR_SIZEOF_ALIGN_OF
A SizefAlignOfExpr record.
Definition: ASTBitCodes.h:1632
clang::MatrixSubscriptExpr::setRowIdx
void setRowIdx(Expr *E)
Definition: Expr.h:2755
ASTBitCodes.h
clang::serialization::EXPR_SIZEOF_PACK
@ EXPR_SIZEOF_PACK
Definition: ASTBitCodes.h:1883
clang::OMPSectionsDirective
This represents '#pragma omp sections' directive.
Definition: StmtOpenMP.h:1781
clang::OffsetOfNode::Kind
Kind
The kind of offsetof node we have.
Definition: Expr.h:2343
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:108
clang::serialization::EXPR_FUNCTION_PARM_PACK
@ EXPR_FUNCTION_PARM_PACK
Definition: ASTBitCodes.h:1886
clang::OMPTargetTeamsDistributeParallelForSimdDirective
This represents '#pragma omp target teams distribute parallel for simd' combined directive.
Definition: StmtOpenMP.h:4989
clang::CStyleCastExpr
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....
Definition: Expr.h:3735
clang::APIntStorage::setValue
void setValue(const ASTContext &C, const llvm::APInt &Val)
Definition: Expr.h:1479
clang::CallExpr::ADLCallKind
ADLCallKind
Definition: Expr.h:2857
clang::CallExpr::setCallee
void setCallee(Expr *F)
Definition: Expr.h:2953
clang::serialization::EXPR_MATRIX_SUBSCRIPT
@ EXPR_MATRIX_SUBSCRIPT
An MatrixSubscriptExpr record.
Definition: ASTBitCodes.h:1638
clang::Stmt::CXXDependentScopeMemberExprBits
CXXDependentScopeMemberExprBitfields CXXDependentScopeMemberExprBits
Definition: Stmt.h:1062
clang::GCCAsmStmt
This represents a GCC inline-assembly statement extension.
Definition: Stmt.h:3007
clang::OverloadExpr::getNumTemplateArgs
unsigned getNumTemplateArgs() const
Definition: ExprCXX.h:3056
clang::serialization::EXPR_CXX_OPERATOR_CALL
@ EXPR_CXX_OPERATOR_CALL
A CXXOperatorCallExpr record.
Definition: ASTBitCodes.h:1805
clang::CStyleCastExpr::CreateEmpty
static CStyleCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: Expr.cpp:2023
SourceLocation.h
clang::StringLiteral::getKind
StringKind getKind() const
Definition: Expr.h:1882
clang::serialization::STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
@ STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE
Definition: ASTBitCodes.h:1937
clang::OMPFlushDirective
This represents '#pragma omp flush' directive.
Definition: StmtOpenMP.h:2669
clang::ObjCMessageExpr::setInstanceReceiver
void setInstanceReceiver(Expr *rec)
Turn this message send into an instance message that computes the receiver object with the given expr...
Definition: ExprObjC.h:1262
clang::AsmStmt
AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.
Definition: Stmt.h:2848
clang::serialization::EXPR_BINARY_OPERATOR
@ EXPR_BINARY_OPERATOR
A BinaryOperator record.
Definition: ASTBitCodes.h:1647
clang::OMPTargetEnterDataDirective
This represents '#pragma omp target enter data' directive.
Definition: StmtOpenMP.h:3116
clang::ConceptReference::NestedNameSpec
NestedNameSpecifierLoc NestedNameSpec
Definition: ASTConcept.h:102
clang::DesignatedInitUpdateExpr
Definition: Expr.h:5367
clang::serialization::STMT_OMP_FLUSH_DIRECTIVE
@ STMT_OMP_FLUSH_DIRECTIVE
Definition: ASTBitCodes.h:1930
readConstraintSatisfaction
static ConstraintSatisfaction readConstraintSatisfaction(ASTRecordReader &Record)
Definition: ASTReaderStmt.cpp:767
clang::serialization::STMT_SEH_TRY
@ STMT_SEH_TRY
Definition: ASTBitCodes.h:1906
clang::serialization::EXPR_CXX_NULL_PTR_LITERAL
@ EXPR_CXX_NULL_PTR_LITERAL
Definition: ASTBitCodes.h:1852
clang::OffsetOfExpr::setIndexExpr
void setIndexExpr(unsigned Idx, Expr *E)
Definition: Expr.h:2517
clang::CXXUuidofExpr::setSourceRange
void setSourceRange(SourceRange R)
Definition: ExprCXX.h:1107
clang::ParenExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:2129
clang::OMPArraySectionExpr::setStride
void setStride(Expr *E)
Set length of the array section.
Definition: ExprOpenMP.h:111
clang::OMPInteropDirective
This represents '#pragma omp interop' directive.
Definition: StmtOpenMP.h:5327
clang::serialization::DESIG_ARRAY
@ DESIG_ARRAY
Array designator.
Definition: ASTBitCodes.h:2008
clang::OMPArraySectionExpr::setLength
void setLength(Expr *E)
Set length of the array section.
Definition: ExprOpenMP.h:105
clang::OMPTargetDataDirective::CreateEmpty
static OMPTargetDataDirective * CreateEmpty(const ASTContext &C, unsigned N, EmptyShell)
Creates an empty directive with the place for N clauses.
Definition: StmtOpenMP.cpp:978
clang::OMPIteratorHelperData::Upper
Expr * Upper
Normalized upper bound.
Definition: ExprOpenMP.h:240
clang::DesignatedInitExpr::setGNUSyntax
void setGNUSyntax(bool GNU)
Definition: Expr.h:5267
clang::serialization::STMT_IF
@ STMT_IF
An IfStmt record.
Definition: ASTBitCodes.h:1554
clang::LambdaExpr::capture_init_end
capture_init_iterator capture_init_end()
Retrieve the iterator pointing one past the last initialization argument for this lambda expression.
Definition: ExprCXX.h:2004
clang::ASTRecordReader::readSourceRange
SourceRange readSourceRange()
Read a source range, advancing Idx.
Definition: ASTRecordReader.h:279
clang::OMPDistributeDirective
This represents '#pragma omp distribute' directive.
Definition: StmtOpenMP.h:3995
clang::serialization::DESIG_FIELD_NAME
@ DESIG_FIELD_NAME
Field designator where only the field name is known.
Definition: ASTBitCodes.h:2001
clang::OMPTeamsGenericLoopDirective
This represents '#pragma omp teams loop' directive.
Definition: StmtOpenMP.h:5597
clang::concepts::TypeRequirement
A requires-expression requirement which queries the existence of a type name or type template special...
Definition: ExprConcepts.h:203
clang::OMPDispatchDirective::CreateEmpty
static OMPDispatchDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2071
clang::serialization::STMT_OMP_TASKYIELD_DIRECTIVE
@ STMT_OMP_TASKYIELD_DIRECTIVE
Definition: ASTBitCodes.h:1927
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::serialization::STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE
@ STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE
Definition: ASTBitCodes.h:1974
clang::OMPSingleDirective
This represents '#pragma omp single' directive.
Definition: StmtOpenMP.h:1920
clang::serialization::STMT_OBJC_CATCH
@ STMT_OBJC_CATCH
An ObjCAtCatchStmt record.
Definition: ASTBitCodes.h:1770
clang::OMPTaskwaitDirective::CreateEmpty
static OMPTaskwaitDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:751
clang::ParenExpr
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:2112
clang::UnaryOperator::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:2211
clang::CoyieldExpr
Represents a 'co_yield' expression.
Definition: ExprCXX.h:4870
clang::serialization::EXPR_CXX_ADDRSPACE_CAST
@ EXPR_CXX_ADDRSPACE_CAST
A CXXAddrspaceCastExpr record.
Definition: ASTBitCodes.h:1835
clang::serialization::STMT_CXX_FOR_RANGE
@ STMT_CXX_FOR_RANGE
A CXXForRangeStmt record.
Definition: ASTBitCodes.h:1802
clang::ObjCProtocolExpr
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:504
clang::OMPCanonicalLoop::createEmpty
static OMPCanonicalLoop * createEmpty(const ASTContext &Ctx)
Create an empty OMPCanonicalLoop for deserialization.
Definition: StmtOpenMP.h:176
clang::OMPParallelForSimdDirective::CreateEmpty
static OMPParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:661
clang::CallExpr::getNumArgs
unsigned getNumArgs() const
getNumArgs - Return the number of actual arguments to this call.
Definition: Expr.h:2979
clang::UserDefinedLiteral::CreateEmpty
static UserDefinedLiteral * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPOptions, EmptyShell Empty)
Definition: ExprCXX.cpp:906
clang::OMPForSimdDirective::CreateEmpty
static OMPForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:485
clang::serialization::EXPR_EXPR_WITH_CLEANUPS
@ EXPR_EXPR_WITH_CLEANUPS
Definition: ASTBitCodes.h:1866
clang::OMPArraySectionExpr::setBase
void setBase(Expr *E)
Set base of the array section.
Definition: ExprOpenMP.h:88
clang::serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE
@ EXPR_OBJC_INDIRECT_COPY_RESTORE
An ObjCIndirectCopyRestoreExpr record.
Definition: ASTBitCodes.h:1764
clang::DesignatedInitExpr::setDesignators
void setDesignators(const ASTContext &C, const Designator *Desigs, unsigned NumDesigs)
Definition: Expr.cpp:4363
clang::OMPBarrierDirective::CreateEmpty
static OMPBarrierDirective * CreateEmpty(const ASTContext &C, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:737
clang::CXXDeleteExpr
Represents a delete expression for memory deallocation and destructor calls, e.g.
Definition: ExprCXX.h:2415
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:165
clang::CXXTemporaryObjectExpr::CreateEmpty
static CXXTemporaryObjectExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs)
Definition: ExprCXX.cpp:1015
clang::CXXAddrspaceCastExpr::CreateEmpty
static CXXAddrspaceCastExpr * CreateEmpty(const ASTContext &Context)
Definition: ExprCXX.cpp:838
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5970
clang::OMPParallelMasterTaskLoopSimdDirective::CreateEmpty
static OMPParallelMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1289
clang::StmtExpr
StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).
Definition: Expr.h:4349
clang::UnresolvedLookupExpr::CreateEmpty
static UnresolvedLookupExpr * CreateEmpty(const ASTContext &Context, unsigned NumResults, bool HasTemplateKWAndArgsInfo, unsigned NumTemplateArgs)
Definition: ExprCXX.cpp:401
clang::OMPTaskLoopDirective
This represents '#pragma omp taskloop' directive.
Definition: StmtOpenMP.h:3571
clang::MSPropertySubscriptExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: ExprCXX.h:1032
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::serialization::EXPR_INIT_LIST
@ EXPR_INIT_LIST
An InitListExpr record.
Definition: ASTBitCodes.h:1668
clang::CXXTypeidExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:875
clang::serialization::STMT_OMP_INTEROP_DIRECTIVE
@ STMT_OMP_INTEROP_DIRECTIVE
Definition: ASTBitCodes.h:1967
clang::OffsetOfNode::Base
@ Base
An implicit indirection through a C++ base class, when the field found is in a base class.
Definition: Expr.h:2352
OpenMPClause.h
clang::serialization::EXPR_CXX_CONST_CAST
@ EXPR_CXX_CONST_CAST
A CXXConstCastExpr record.
Definition: ASTBitCodes.h:1832
clang::AddrLabelExpr
AddrLabelExpr - The GNU address of label extension, representing &&label.
Definition: Expr.h:4304
clang::OMPArrayShapingExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:196
clang::ParenExpr::setRParen
void setRParen(SourceLocation Loc)
Definition: Expr.h:2140
clang::CXXFunctionalCastExpr
Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....
Definition: ExprCXX.h:1726
clang::DeclGroupRef
Definition: DeclGroup.h:51
clang::DesignatedInitExpr::Designator
Represents a single C99 designator.
Definition: Expr.h:5104
clang::FloatingLiteral::Create
static FloatingLiteral * Create(const ASTContext &C, const llvm::APFloat &V, bool isexact, QualType Type, SourceLocation L)
Definition: Expr.cpp:1001
clang::CharacterLiteral::setValue
void setValue(unsigned Val)
Definition: Expr.h:1622
clang::serialization::EXPR_NO_INIT
@ EXPR_NO_INIT
An NoInitExpr record.
Definition: ASTBitCodes.h:1677
clang::StmtExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: Expr.h:4374
clang::ArraySubscriptExpr
ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.
Definition: Expr.h:2645
clang::CXXUuidofExpr
A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...
Definition: ExprCXX.h:1056
clang::DependentScopeDeclRefExpr
A qualified reference to a name whose declaration cannot yet be resolved.
Definition: ExprCXX.h:3208
clang::DoStmt
DoStmt - This represents a 'do/while' stmt.
Definition: Stmt.h:2483
clang::CXXNewExpr::setOperatorDelete
void setOperatorDelete(FunctionDecl *D)
Definition: ExprCXX.h:2260
CapturedStmt.h
clang::WhileStmt::CreateEmpty
static WhileStmt * CreateEmpty(const ASTContext &Ctx, bool HasVar)
Create an empty while statement optionally with storage for a condition variable.
Definition: Stmt.cpp:1144
clang::serialization::EXPR_VA_ARG
@ EXPR_VA_ARG
A VAArgExpr record.
Definition: ASTBitCodes.h:1689
clang::AddrLabelExpr::setLabel
void setLabel(LabelDecl *L)
Definition: Expr.h:4328
clang::VAArgExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:4651
clang::ObjCMessageExpr::CreateEmpty
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:232
clang::ObjCEncodeExpr::setAtLoc
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:424
StmtVisitor.h
clang::CXXUnresolvedConstructExpr::CreateEmpty
static CXXUnresolvedConstructExpr * CreateEmpty(const ASTContext &Context, unsigned NumArgs)
Definition: ExprCXX.cpp:1356
LLVM.h
clang::CXXNullPtrLiteralExpr
The null pointer literal (C++11 [lex.nullptr])
Definition: ExprCXX.h:759
clang::PredefinedExpr::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:2012
clang::ExtVectorElementExpr::setAccessorLoc
void setAccessorLoc(SourceLocation L)
Definition: Expr.h:5935
clang::CoroutineBodyStmt
Represents the body of a coroutine.
Definition: StmtCXX.h:317
clang::OffsetOfNode::Field
@ Field
A field.
Definition: Expr.h:2347
clang::concepts::ExprRequirement::SatisfactionStatus
SatisfactionStatus
Definition: ExprConcepts.h:260
clang::serialization::STMT_OMP_TASKWAIT_DIRECTIVE
@ STMT_OMP_TASKWAIT_DIRECTIVE
Definition: ASTBitCodes.h:1929
clang::serialization::STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE
Definition: ASTBitCodes.h:1954
clang::Stmt::UnresolvedMemberExprBits
UnresolvedMemberExprBitfields UnresolvedMemberExprBits
Definition: Stmt.h:1065
clang::CoawaitExpr
Represents a 'co_await' expression.
Definition: ExprCXX.h:4789
clang::UnaryOperatorKind
UnaryOperatorKind
Definition: OperationKinds.h:30
clang::BreakStmt
BreakStmt - This represents a break.
Definition: Stmt.h:2728
clang::serialization::EXPR_OBJC_ENCODE
@ EXPR_OBJC_ENCODE
An ObjCEncodeExpr record.
Definition: ASTBitCodes.h:1737
clang::ShuffleVectorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4419
clang::serialization::EXPR_OBJC_BRIDGED_CAST
@ EXPR_OBJC_BRIDGED_CAST
Definition: ASTBitCodes.h:1980
clang::concepts::ExprRequirement::SS_ExprSubstitutionFailure
@ SS_ExprSubstitutionFailure
Definition: ExprConcepts.h:262
clang::OverloadExpr
A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.
Definition: ExprCXX.h:2897
clang::OMPTargetTeamsDistributeSimdDirective::CreateEmpty
static OMPTargetTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2036
clang::serialization::EXPR_OBJC_IVAR_REF_EXPR
@ EXPR_OBJC_IVAR_REF_EXPR
An ObjCIvarRefExpr record.
Definition: ASTBitCodes.h:1746
clang::serialization::STMT_STOP
@ STMT_STOP
A marker record that indicates that we are at the end of an expression.
Definition: ASTBitCodes.h:1527
clang::OMPCancellationPointDirective
This represents '#pragma omp cancellation point' directive.
Definition: StmtOpenMP.h:3453
clang::OMPDispatchDirective
This represents '#pragma omp dispatch' directive.
Definition: StmtOpenMP.h:5380
clang::CXXDependentScopeMemberExpr
Represents a C++ member access expression where the actual member referenced could not be resolved be...
Definition: ExprCXX.h:3567
clang::OMPSectionsDirective::CreateEmpty
static OMPSectionsDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:506
clang::serialization::STMT_OMP_SINGLE_DIRECTIVE
@ STMT_OMP_SINGLE_DIRECTIVE
Definition: ASTBitCodes.h:1919
clang::serialization::EXPR_OBJC_KVC_REF_EXPR
@ EXPR_OBJC_KVC_REF_EXPR
UNUSED.
Definition: ASTBitCodes.h:1755
clang::ObjCIvarRefExpr::setIsFreeIvar
void setIsFreeIvar(bool A)
Definition: ExprObjC.h:587
clang::RecoveryExpr::CreateEmpty
static RecoveryExpr * CreateEmpty(ASTContext &Ctx, unsigned NumSubExprs)
Definition: Expr.cpp:4843
clang::OMPTeamsDistributeDirective::CreateEmpty
static OMPTeamsDistributeDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1640
clang::OMPTaskLoopSimdDirective::CreateEmpty
static OMPTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1109
clang::ASTStmtReader::ASTStmtReader
ASTStmtReader(ASTRecordReader &Record, llvm::BitstreamCursor &Cursor)
Definition: ASTReaderStmt.cpp:101
clang::CompoundAssignOperator
CompoundAssignOperator - For compound assignments (e.g.
Definition: Expr.h:4054
clang::BinaryOperatorKind
BinaryOperatorKind
Definition: OperationKinds.h:25
clang::serialization::EXPR_PAREN
@ EXPR_PAREN
A ParenExpr record.
Definition: ASTBitCodes.h:1620
clang::serialization::EXPR_CXX_DEFAULT_INIT
@ EXPR_CXX_DEFAULT_INIT
Definition: ASTBitCodes.h:1858
clang::OMPParallelGenericLoopDirective::CreateEmpty
static OMPParallelGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2262
clang::ExprValueKind
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:117
clang::CXXNoexceptExpr
Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
Definition: ExprCXX.h:4014
clang::serialization::STMT_SEH_EXCEPT
@ STMT_SEH_EXCEPT
Definition: ASTBitCodes.h:1904
clang::Expr::isValueDependent
bool isValueDependent() const
Determines whether the value of this expression depends on.
Definition: Expr.h:168
clang::CXXUnresolvedConstructExpr
Describes an explicit type conversion that uses functional notion but could not be resolved because o...
Definition: ExprCXX.h:3445
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::DeclRefExpr::setLocation
void setLocation(SourceLocation L)
Definition: Expr.h:1304
clang::serialization::STMT_GCCASM
@ STMT_GCCASM
A GCC-style AsmStmt record.
Definition: ASTBitCodes.h:1590
clang::OMPSectionDirective::setHasCancel
void setHasCancel(bool Has)
Set cancel state.
Definition: StmtOpenMP.h:1902
clang::ASTRecordReader::readExpr
Expr * readExpr()
Reads an expression.
Definition: ASTRecordReader.h:132
clang::OMPInteropDirective::CreateEmpty
static OMPInteropDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:2055
clang::OMPExecutableDirective
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:266
clang::serialization::STMT_OMP_TARGET_UPDATE_DIRECTIVE
@ STMT_OMP_TARGET_UPDATE_DIRECTIVE
Definition: ASTBitCodes.h:1952
clang::serialization::EXPR_CUDA_KERNEL_CALL
@ EXPR_CUDA_KERNEL_CALL
Definition: ASTBitCodes.h:1893
clang::StringLiteral::getCharByteWidth
unsigned getCharByteWidth() const
Definition: Expr.h:1880
clang::OMPTargetDirective::CreateEmpty
static OMPTargetDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:899
clang::OMPArraySectionExpr::setColonLocSecond
void setColonLocSecond(SourceLocation L)
Definition: ExprOpenMP.h:122
clang::serialization::STMT_OMP_PARALLEL_MASTER_DIRECTIVE
@ STMT_OMP_PARALLEL_MASTER_DIRECTIVE
Definition: ASTBitCodes.h:1924
clang::Stmt::CXXDeleteExprBits
CXXDeleteExprBitfields CXXDeleteExprBits
Definition: Stmt.h:1056
clang::CXXForRangeStmt
CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...
Definition: StmtCXX.h:134
Lambda.h
clang::Stmt::DeclRefExprBits
DeclRefExprBitfields DeclRefExprBits
Definition: Stmt.h:1025
clang::ObjCIsaExpr::setIsaMemberLoc
void setIsaMemberLoc(SourceLocation L)
Definition: ExprObjC.h:1515
clang::DesignatedInitExpr::CreateEmpty
static DesignatedInitExpr * CreateEmpty(const ASTContext &C, unsigned NumIndexExprs)
Definition: Expr.cpp:4356
clang::serialization::COK_CompoundLiteral
@ COK_CompoundLiteral
Definition: ASTBitCodes.h:2024
clang::OMPParallelMasterTaskLoopDirective::CreateEmpty
static OMPParallelMasterTaskLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1242
clang::ObjCPropertyAttribute::Kind
Kind
Definition: DeclObjCCommon.h:22
clang::DeclStmt
DeclStmt - Adaptor class for mixing declarations with statements and expressions.
Definition: Stmt.h:1297
clang::ContinueStmt
ContinueStmt - This represents a continue.
Definition: Stmt.h:2698
clang::ChooseExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: Expr.h:4575
clang::OffsetOfNode::Identifier
@ Identifier
A field in a dependent type, known only by its name.
Definition: Expr.h:2349
clang::Expr::setDependence
void setDependence(ExprDependence Deps)
Each concrete expr subclass is expected to compute its dependence and call this in the constructor.
Definition: Expr.h:134
clang::CallExpr::setStoredFPFeatures
void setStoredFPFeatures(FPOptionsOverride F)
Set FPOptionsOverride in trailing storage. Used only by Serialization.
Definition: Expr.h:3074
clang::ConstantExpr::CreateEmpty
static ConstantExpr * CreateEmpty(const ASTContext &Context, ResultStorageKind StorageKind)
Definition: Expr.cpp:336
clang::OMPTeamsDistributeSimdDirective::CreateEmpty
static OMPTeamsDistributeSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1683
clang::serialization::STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_MASTER_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1947
clang::ObjCSelectorExpr::setAtLoc
void setAtLoc(SourceLocation L)
Definition: ExprObjC.h:473
clang::OMPUnrollDirective::CreateEmpty
static OMPUnrollDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses)
Build an empty '#pragma omp unroll' AST node for deserialization.
Definition: StmtOpenMP.cpp:443
clang::CXXConstCastExpr
A C++ const_cast expression (C++ [expr.const.cast]).
Definition: ExprCXX.h:562
clang::OMPSimdDirective::CreateEmpty
static OMPSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:327
clang::CXXThisExpr
Represents the this expression in C++.
Definition: ExprCXX.h:1142
clang::serialization::EXPR_COYIELD
@ EXPR_COYIELD
Definition: ASTBitCodes.h:1987
clang::ExtVectorElementExpr
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5910
clang::OMPTeamsDistributeParallelForDirective
This represents '#pragma omp teams distribute parallel for' composite directive.
Definition: StmtOpenMP.h:4676
DeclarationName.h
clang::IfStatementKind
IfStatementKind
In an if statement, this denotes whether the the statement is a constexpr or consteval if statement.
Definition: Specifiers.h:36
clang::ObjCSubscriptRefExpr::setBaseExpr
void setBaseExpr(Stmt *S)
Definition: ExprObjC.h:881
clang::TypoExpr
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:6367
clang::PredefinedExpr
[C99 6.4.2.2] - A predefined identifier such as func.
Definition: Expr.h:1959
clang::serialization::EXPR_PREDEFINED
@ EXPR_PREDEFINED
A PredefinedExpr record.
Definition: ASTBitCodes.h:1599
clang::serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT
@ EXPR_CXX_UNRESOLVED_CONSTRUCT
Definition: ASTBitCodes.h:1870
clang::MSDependentExistsStmt
Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.
Definition: StmtCXX.h:252
clang::serialization::STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE
@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE
Definition: ASTBitCodes.h:1949
clang::FPOptionsOverride::getFromOpaqueInt
static FPOptionsOverride getFromOpaqueInt(storage_type I)
Definition: LangOptions.h:771
clang::serialization::EXPR_ARRAY_TYPE_TRAIT
@ EXPR_ARRAY_TYPE_TRAIT
Definition: ASTBitCodes.h:1880
clang::OMPOrderedDirective::CreateEmpty
static OMPOrderedDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, bool IsStandalone, EmptyShell)
Creates an empty directive.
Definition: StmtOpenMP.cpp:858
clang::SizeOfPackExpr::isPartiallySubstituted
bool isPartiallySubstituted() const
Determine whether this represents a partially-substituted sizeof...
Definition: ExprCXX.h:4232
clang::SEHFinallyStmt
Definition: Stmt.h:3378
clang::CUDAKernelCallExpr
Represents a call to a CUDA kernel function.
Definition: ExprCXX.h:232
clang::serialization::EXPR_CXX_INHERITED_CTOR_INIT
@ EXPR_CXX_INHERITED_CTOR_INIT
A CXXInheritedCtorInitExpr record.
Definition: ASTBitCodes.h:1817
clang::ExtVectorElementExpr::setBase
void setBase(Expr *E)
Definition: Expr.h:5929
clang::ObjCMessageExpr::Instance
@ Instance
The receiver is an object instance.
Definition: ExprObjC.h:1091
clang::ObjCSelectorExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:474
clang::serialization::EXPR_MATERIALIZE_TEMPORARY
@ EXPR_MATERIALIZE_TEMPORARY
Definition: ASTBitCodes.h:1887
clang::ConstantExpr::ResultStorageKind
ResultStorageKind
Describes the kind of result that can be tail-allocated.
Definition: Expr.h:1044
clang::serialization::EXPR_RECOVERY
@ EXPR_RECOVERY
A RecoveryExpr record.
Definition: ASTBitCodes.h:1725
clang::OMPArrayShapingExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprOpenMP.h:193
clang::OMPSimdDirective
This represents '#pragma omp simd' directive.
Definition: StmtOpenMP.h:1565
clang::UnaryExprOrTypeTraitExpr::setOperatorLoc
void setOperatorLoc(SourceLocation L)
Definition: Expr.h:2623
clang::CodeGen::CleanupKind
CleanupKind
Definition: EHScopeStack.h:77
clang::Expr::setType
void setType(QualType t)
Definition: Expr.h:142
clang::OMPArraySectionExpr
OpenMP 5.0 [2.1.5, Array Sections].
Definition: ExprOpenMP.h:56
clang
Definition: CalledOnceCheck.h:17
clang::TemplateArgumentListInfo::setRAngleLoc
void setRAngleLoc(SourceLocation Loc)
Definition: TemplateBase.h:583
clang::CompoundAssignOperator::setComputationResultType
void setComputationResultType(QualType T)
Definition: Expr.h:4092
clang::serialization::STMT_OMP_SECTIONS_DIRECTIVE
@ STMT_OMP_SECTIONS_DIRECTIVE
Definition: ASTBitCodes.h:1917
clang::serialization::EXPR_CXX_UUIDOF_EXPR
@ EXPR_CXX_UUIDOF_EXPR
Definition: ASTBitCodes.h:1901
clang::IntegerLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1522
clang::InitListExpr::setSyntacticForm
void setSyntacticForm(InitListExpr *Init)
Definition: Expr.h:4956
clang::CXXFunctionalCastExpr::CreateEmpty
static CXXFunctionalCastExpr * CreateEmpty(const ASTContext &Context, unsigned PathSize, bool HasFPFeatures)
Definition: ExprCXX.cpp:858
clang::serialization::EXPR_COMPOUND_ASSIGN_OPERATOR
@ EXPR_COMPOUND_ASSIGN_OPERATOR
A CompoundAssignOperator record.
Definition: ASTBitCodes.h:1650
clang::OMPTargetTeamsDirective
This represents '#pragma omp target teams' directive.
Definition: StmtOpenMP.h:4769
clang::serialization::EXPR_EXT_VECTOR_ELEMENT
@ EXPR_EXT_VECTOR_ELEMENT
An ExtVectorElementExpr record.
Definition: ASTBitCodes.h:1665
distance
float __ovld __cnfn distance(float, float)
Returns the distance between p0 and p1.
clang::ObjCDictionaryLiteral::CreateEmpty
static ObjCDictionaryLiteral * CreateEmpty(const ASTContext &C, unsigned NumElements, bool HasPackExpansions)
Definition: ExprObjC.cpp:88
clang::CXXDynamicCastExpr::CreateEmpty
static CXXDynamicCastExpr * CreateEmpty(const ASTContext &Context, unsigned pathSize)
Definition: ExprCXX.cpp:753
UnresolvedSet.h
clang::UnresolvedSetImpl::addDecl
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:91
clang::OMPTargetTeamsGenericLoopDirective::CreateEmpty
static OMPTargetTeamsGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2218
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:69
clang::ObjCEncodeExpr::setEncodedTypeSourceInfo
void setEncodedTypeSourceInfo(TypeSourceInfo *EncType)
Definition: ExprObjC.h:432
clang::OMPDistributeParallelForDirective
This represents '#pragma omp distribute parallel for' composite directive.
Definition: StmtOpenMP.h:4117
clang::OMPGenericLoopDirective::CreateEmpty
static OMPGenericLoopDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with a place for NumClauses clauses.
Definition: StmtOpenMP.cpp:2131
clang::DefaultStmt
Definition: Stmt.h:1728
clang::ObjCAutoreleasePoolStmt
Represents Objective-C's @autoreleasepool Statement.
Definition: StmtObjC.h:393
clang::BinaryOperator::CreateEmpty
static BinaryOperator * CreateEmpty(const ASTContext &C, bool hasFPFeatures)
Definition: Expr.cpp:4530
clang::CXXNewExpr::isParenTypeId
bool isParenTypeId() const
Definition: ExprCXX.h:2309
clang::CXXCatchStmt
CXXCatchStmt - This represents a C++ catch block.
Definition: StmtCXX.h:28
clang::serialization::STMT_OMP_BARRIER_DIRECTIVE
@ STMT_OMP_BARRIER_DIRECTIVE
Definition: ASTBitCodes.h:1928
clang::ASTStmtReader::ReadTemplateKWAndArgsInfo
void ReadTemplateKWAndArgsInfo(ASTTemplateKWAndArgsInfo &Args, TemplateArgumentLoc *ArgsLocArray, unsigned NumTemplateArgs)
Read and initialize a ExplicitTemplateArgumentList structure.
Definition: ASTReaderStmt.cpp:129
clang::GenericSelectionExpr
Represents a C11 generic selection.
Definition: Expr.h:5628
clang::CXXScalarValueInitExpr
An expression "T()" which creates a value-initialized rvalue of type T, which is a non-class type.
Definition: ExprCXX.h:2093
clang::serialization::EXPR_ATOMIC
@ EXPR_ATOMIC
An AtomicExpr record.
Definition: ASTBitCodes.h:1722
clang::ObjCIsaExpr
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
Definition: ExprObjC.h:1482
clang::serialization::STMT_OMP_ATOMIC_DIRECTIVE
@ STMT_OMP_ATOMIC_DIRECTIVE
Definition: ASTBitCodes.h:1934
clang::OMPMasterTaskLoopSimdDirective::CreateEmpty
static OMPMasterTaskLoopSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1197
clang::serialization::EXPR_OBJC_STRING_LITERAL
@ EXPR_OBJC_STRING_LITERAL
An ObjCStringLiteral record.
Definition: ASTBitCodes.h:1730
clang::serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM
Definition: ASTBitCodes.h:1884
clang::serialization::EXPR_FIXEDPOINT_LITERAL
@ EXPR_FIXEDPOINT_LITERAL
Definition: ASTBitCodes.h:1991
clang::CastExpr::setSubExpr
void setSubExpr(Expr *E)
Definition: Expr.h:3527
clang::Stmt::CXXThrowExprBits
CXXThrowExprBitfields CXXThrowExprBits
Definition: Stmt.h:1051
clang::serialization::EXPR_GNU_NULL
@ EXPR_GNU_NULL
A GNUNullExpr record.
Definition: ASTBitCodes.h:1701
clang::FixedPointLiteral::setLocation
void setLocation(SourceLocation Location)
Definition: Expr.h:1564
clang::ASTReader::ReadStmt
Stmt * ReadStmt(ModuleFile &F)
Reads a statement.
Definition: ASTReaderStmt.cpp:2645
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6471
clang::CXXUuidofExpr::isTypeOperand
bool isTypeOperand() const
Definition: ExprCXX.h:1086
clang::CXXDependentScopeMemberExpr::getNumTemplateArgs
unsigned getNumTemplateArgs() const
Retrieve the number of template arguments provided as part of this template-id.
Definition: ExprCXX.h:3769
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:311
clang::OMPUnrollDirective
This represents the '#pragma omp unroll' loop transformation directive.
Definition: StmtOpenMP.h:5200
clang::SizeOfPackExpr::CreateDeserialized
static SizeOfPackExpr * CreateDeserialized(ASTContext &Context, unsigned NumPartialArgs)
Definition: ExprCXX.cpp:1570
clang::serialization::STMT_OMP_TASK_DIRECTIVE
@ STMT_OMP_TASK_DIRECTIVE
Definition: ASTBitCodes.h:1926
clang::serialization::EXPR_CXX_DEFAULT_ARG
@ EXPR_CXX_DEFAULT_ARG
Definition: ASTBitCodes.h:1857
clang::ParenListExpr::CreateEmpty
static ParenListExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumExprs)
Create an empty paren list.
Definition: Expr.cpp:4489
clang::serialization::STMT_LABEL
@ STMT_LABEL
A LabelStmt record.
Definition: ASTBitCodes.h:1548
clang::CXXThisExpr::setLocation
void setLocation(SourceLocation L)
Definition: ExprCXX.h:1154
clang::CXXNewExpr::hasInitializer
bool hasInitializer() const
Whether this new-expression has any initializer at all.
Definition: ExprCXX.h:2318
clang::CXXNamedCastExpr
Abstract class common to all of the C++ "named"/"keyword" casts.
Definition: ExprCXX.h:373
clang::OMPArraySectionExpr::setRBracketLoc
void setRBracketLoc(SourceLocation L)
Definition: ExprOpenMP.h:125
clang::ASTRecordReader::readDeclAs
T * readDeclAs()
Reads a declaration from the given position in the record, advancing Idx.
Definition: ASTRecordReader.h:205
clang::VAArgExpr::setWrittenTypeInfo
void setWrittenTypeInfo(TypeSourceInfo *TI)
Definition: Expr.h:4658
clang::serialization::STMT_OMP_SECTION_DIRECTIVE
@ STMT_OMP_SECTION_DIRECTIVE
Definition: ASTBitCodes.h:1918
clang::CallExpr::CreateEmpty
static CallExpr * CreateEmpty(const ASTContext &Ctx, unsigned NumArgs, bool HasFPFeatures, EmptyShell Empty)
Create an empty call expression, for deserialization.
Definition: Expr.cpp:1418
clang::OMPTargetDirective
This represents '#pragma omp target' directive.
Definition: StmtOpenMP.h:3008
clang::OMPTargetParallelForSimdDirective::CreateEmpty
static OMPTargetParallelForSimdDirective * CreateEmpty(const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, EmptyShell)
Creates an empty directive with the place for NumClauses clauses.
Definition: StmtOpenMP.cpp:1558
clang::ObjCProtocolExpr::setRParenLoc
void setRParenLoc(SourceLocation L)
Definition: ExprObjC.h:528
clang::ASTReader::ReadExpr
Expr * ReadExpr(ModuleFile &F)
Reads an expression.
Definition: ASTReaderStmt.cpp:2659
clang::ConstraintSatisfaction::SubstitutionDiagnostic
std::pair< SourceLocation, StringRef > SubstitutionDiagnostic
Definition: ASTConcept.h:43
clang::OMPGenericLoopDirective
This represents '#pragma omp loop' directive.
Definition: StmtOpenMP.h:5535
clang::OMPTargetUpdateDirective
This represents '#pragma omp target update' directive.
Definition: StmtOpenMP.h:4061
clang::serialization::STMT_SEH_FINALLY
@ STMT_SEH_FINALLY
Definition: ASTBitCodes.h:1905
clang::StringLiteral::getLength
unsigned getLength() const
Definition: Expr.h:1879
clang::ObjCArrayLiteral::getElements
Expr ** getElements()
Retrieve elements of array of literals.
Definition: ExprObjC.h:221
clang::CXXUnresolvedConstructExpr::setLParenLoc
void setLParenLoc(SourceLocation L)
Definition: ExprCXX.h:3490
clang::ImplicitCastExpr
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3619
clang::VAArgExpr
Represents a call to the builtin function __builtin_va_arg.
Definition: Expr.h:4633
clang::OMPOrderedDirective
This represents '#pragma omp ordered' directive.
Definition: StmtOpenMP.