clang: lib/Serialization/ASTWriterStmt.cpp Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

24#include "llvm/Bitstream/BitstreamWriter.h"

25using namespace clang;

26

27

28

29

30

32

36

38 unsigned AbbrevToUse;

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55 class PakedBitsWriter {

56 public:

58 ~PakedBitsWriter() { assert(!CurrentIndex); }

59

60 void addBit(bool Value) {

61 assert(CurrentIndex && "Writing Bits without recording first!");

62 PackingBits.addBit(Value);

63 }

64 void addBits(uint32_t Value, uint32_t BitsWidth) {

65 assert(CurrentIndex && "Writing Bits without recording first!");

66 PackingBits.addBits(Value, BitsWidth);

67 }

68

69 void writeBits() {

70 if (!CurrentIndex)

71 return;

72

73 RecordRef[*CurrentIndex] = (uint32_t)PackingBits;

74 CurrentIndex = std::nullopt;

75 PackingBits.reset(0);

76 }

77

78 void updateBits() {

79 writeBits();

80

81 CurrentIndex = RecordRef.size();

82 RecordRef.push_back(0);

83 }

84

85 private:

88 std::optional CurrentIndex;

89 };

90

91 PakedBitsWriter CurrentPackingBits;

92

93 public:

96 : Writer(Writer), Record(Context, Writer, Record),

97 Code(serialization::STMT_NULL_PTR), AbbrevToUse(0),

98 CurrentPackingBits(this->Record) {}

99

102

104 CurrentPackingBits.writeBits();

106 "unhandled sub-statement writing AST file");

107 return Record.EmitStmt(Code, AbbrevToUse);

108 }

109

112

114#define STMT(Type, Base) \

115 void Visit##Type(Type *);

116#include "clang/AST/StmtNodes.inc"

117 };

118}

119

126 Record.AddTemplateArgumentLoc(Args[i]);

127}

128

130}

131

132void ASTStmtWriter::VisitNullStmt(NullStmt *S) {

134 Record.AddSourceLocation(S->getSemiLoc());

135 Record.push_back(S->NullStmtBits.HasLeadingEmptyMacro);

137}

138

139void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {

141

142 Record.push_back(S->size());

143 Record.push_back(S->hasStoredFPFeatures());

144

145 for (auto *CS : S->body())

147 if (S->hasStoredFPFeatures())

148 Record.push_back(S->getStoredFPFeatures().getAsOpaqueInt());

149 Record.AddSourceLocation(S->getLBracLoc());

150 Record.AddSourceLocation(S->getRBracLoc());

151

152 if (!S->hasStoredFPFeatures())

154

156}

157

158void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {

161 Record.AddSourceLocation(S->getKeywordLoc());

162 Record.AddSourceLocation(S->getColonLoc());

163}

164

165void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {

166 VisitSwitchCase(S);

167 Record.push_back(S->caseStmtIsGNURange());

168 Record.AddStmt(S->getLHS());

169 Record.AddStmt(S->getSubStmt());

170 if (S->caseStmtIsGNURange()) {

171 Record.AddStmt(S->getRHS());

172 Record.AddSourceLocation(S->getEllipsisLoc());

173 }

175}

176

177void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {

178 VisitSwitchCase(S);

179 Record.AddStmt(S->getSubStmt());

181}

182

183void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {

185 Record.push_back(S->isSideEntry());

186 Record.AddDeclRef(S->getDecl());

187 Record.AddStmt(S->getSubStmt());

188 Record.AddSourceLocation(S->getIdentLoc());

190}

191

192void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {

194 Record.push_back(S->getAttrs().size());

195 Record.AddAttributes(S->getAttrs());

196 Record.AddStmt(S->getSubStmt());

199}

200

201void ASTStmtWriter::VisitIfStmt(IfStmt *S) {

203

204 bool HasElse = S->getElse() != nullptr;

205 bool HasVar = S->getConditionVariableDeclStmt() != nullptr;

206 bool HasInit = S->getInit() != nullptr;

207

208 CurrentPackingBits.updateBits();

209

210 CurrentPackingBits.addBit(HasElse);

211 CurrentPackingBits.addBit(HasVar);

212 CurrentPackingBits.addBit(HasInit);

213 Record.push_back(static_cast<uint64_t>(S->getStatementKind()));

214 Record.AddStmt(S->getCond());

215 Record.AddStmt(S->getThen());

216 if (HasElse)

217 Record.AddStmt(S->getElse());

218 if (HasVar)

219 Record.AddStmt(S->getConditionVariableDeclStmt());

220 if (HasInit)

221 Record.AddStmt(S->getInit());

222

223 Record.AddSourceLocation(S->getIfLoc());

224 Record.AddSourceLocation(S->getLParenLoc());

225 Record.AddSourceLocation(S->getRParenLoc());

226 if (HasElse)

227 Record.AddSourceLocation(S->getElseLoc());

228

230}

231

232void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {

234

235 bool HasInit = S->getInit() != nullptr;

236 bool HasVar = S->getConditionVariableDeclStmt() != nullptr;

237 Record.push_back(HasInit);

238 Record.push_back(HasVar);

239 Record.push_back(S->isAllEnumCasesCovered());

240

241 Record.AddStmt(S->getCond());

242 Record.AddStmt(S->getBody());

243 if (HasInit)

244 Record.AddStmt(S->getInit());

245 if (HasVar)

246 Record.AddStmt(S->getConditionVariableDeclStmt());

247

248 Record.AddSourceLocation(S->getSwitchLoc());

249 Record.AddSourceLocation(S->getLParenLoc());

250 Record.AddSourceLocation(S->getRParenLoc());

251

252 for (SwitchCase *SC = S->getSwitchCaseList(); SC;

253 SC = SC->getNextSwitchCase())

256}

257

258void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {

260

261 bool HasVar = S->getConditionVariableDeclStmt() != nullptr;

262 Record.push_back(HasVar);

263

264 Record.AddStmt(S->getCond());

265 Record.AddStmt(S->getBody());

266 if (HasVar)

267 Record.AddStmt(S->getConditionVariableDeclStmt());

268

269 Record.AddSourceLocation(S->getWhileLoc());

270 Record.AddSourceLocation(S->getLParenLoc());

271 Record.AddSourceLocation(S->getRParenLoc());

273}

274

275void ASTStmtWriter::VisitDoStmt(DoStmt *S) {

277 Record.AddStmt(S->getCond());

278 Record.AddStmt(S->getBody());

279 Record.AddSourceLocation(S->getDoLoc());

280 Record.AddSourceLocation(S->getWhileLoc());

281 Record.AddSourceLocation(S->getRParenLoc());

283}

284

285void ASTStmtWriter::VisitForStmt(ForStmt *S) {

287 Record.AddStmt(S->getInit());

288 Record.AddStmt(S->getCond());

289 Record.AddStmt(S->getConditionVariableDeclStmt());

290 Record.AddStmt(S->getInc());

291 Record.AddStmt(S->getBody());

292 Record.AddSourceLocation(S->getForLoc());

293 Record.AddSourceLocation(S->getLParenLoc());

294 Record.AddSourceLocation(S->getRParenLoc());

296}

297

298void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {

300 Record.AddDeclRef(S->getLabel());

301 Record.AddSourceLocation(S->getGotoLoc());

302 Record.AddSourceLocation(S->getLabelLoc());

304}

305

306void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {

308 Record.AddSourceLocation(S->getGotoLoc());

309 Record.AddSourceLocation(S->getStarLoc());

310 Record.AddStmt(S->getTarget());

312}

313

314void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {

316 Record.AddSourceLocation(S->getContinueLoc());

318}

319

320void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {

322 Record.AddSourceLocation(S->getBreakLoc());

324}

325

326void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {

328

329 bool HasNRVOCandidate = S->getNRVOCandidate() != nullptr;

330 Record.push_back(HasNRVOCandidate);

331

332 Record.AddStmt(S->getRetValue());

333 if (HasNRVOCandidate)

334 Record.AddDeclRef(S->getNRVOCandidate());

335

336 Record.AddSourceLocation(S->getReturnLoc());

338}

339

340void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {

342 Record.AddSourceLocation(S->getBeginLoc());

343 Record.AddSourceLocation(S->getEndLoc());

348}

349

350void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {

352 Record.push_back(S->getNumOutputs());

353 Record.push_back(S->getNumInputs());

354 Record.push_back(S->getNumClobbers());

355 Record.AddSourceLocation(S->getAsmLoc());

356 Record.push_back(S->isVolatile());

357 Record.push_back(S->isSimple());

358}

359

360void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {

361 VisitAsmStmt(S);

362 Record.push_back(S->getNumLabels());

363 Record.AddSourceLocation(S->getRParenLoc());

364 Record.AddStmt(S->getAsmString());

365

366

367 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {

368 Record.AddIdentifierRef(S->getOutputIdentifier(I));

369 Record.AddStmt(S->getOutputConstraintLiteral(I));

370 Record.AddStmt(S->getOutputExpr(I));

371 }

372

373

374 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {

375 Record.AddIdentifierRef(S->getInputIdentifier(I));

376 Record.AddStmt(S->getInputConstraintLiteral(I));

377 Record.AddStmt(S->getInputExpr(I));

378 }

379

380

381 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)

382 Record.AddStmt(S->getClobberStringLiteral(I));

383

384

385 for (unsigned I = 0, N = S->getNumLabels(); I != N; ++I) {

386 Record.AddIdentifierRef(S->getLabelIdentifier(I));

387 Record.AddStmt(S->getLabelExpr(I));

388 }

389

391}

392

393void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {

394 VisitAsmStmt(S);

395 Record.AddSourceLocation(S->getLBraceLoc());

396 Record.AddSourceLocation(S->getEndLoc());

397 Record.push_back(S->getNumAsmToks());

398 Record.AddString(S->getAsmString());

399

400

401 for (unsigned I = 0, N = S->getNumAsmToks(); I != N; ++I) {

402

403 Writer.AddToken(S->getAsmToks()[I], Record.getRecordData());

404 }

405

406

407 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I) {

408 Record.AddString(S->getClobber(I));

409 }

410

411

412 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {

413 Record.AddStmt(S->getOutputExpr(I));

414 Record.AddString(S->getOutputConstraint(I));

415 }

416

417

418 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {

419 Record.AddStmt(S->getInputExpr(I));

420 Record.AddString(S->getInputConstraint(I));

421 }

422

424}

425

426void ASTStmtWriter::VisitCoroutineBodyStmt(CoroutineBodyStmt *CoroStmt) {

432}

433

434void ASTStmtWriter::VisitCoreturnStmt(CoreturnStmt *S) {

436 Record.AddSourceLocation(S->getKeywordLoc());

437 Record.AddStmt(S->getOperand());

438 Record.AddStmt(S->getPromiseCall());

439 Record.push_back(S->isImplicit());

441}

442

444 VisitExpr(E);

445 Record.AddSourceLocation(E->getKeywordLoc());

448 Record.AddStmt(E->getOpaqueValue());

449}

450

451void ASTStmtWriter::VisitCoawaitExpr(CoawaitExpr *E) {

452 VisitCoroutineSuspendExpr(E);

453 Record.push_back(E->isImplicit());

455}

456

457void ASTStmtWriter::VisitCoyieldExpr(CoyieldExpr *E) {

458 VisitCoroutineSuspendExpr(E);

460}

461

463 VisitExpr(E);

464 Record.AddSourceLocation(E->getKeywordLoc());

468}

469

470static void

477 for (const auto &DetailRecord : Satisfaction) {

478 auto *E = DetailRecord.dyn_cast<Expr *>();

479 Record.push_back( E == nullptr);

480 if (E)

482 else {

483 auto *Diag = cast<std::pair<SourceLocation, StringRef> *>(DetailRecord);

484 Record.AddSourceLocation(Diag->first);

486 }

487 }

488 }

489}

490

491static void

495 Record.AddString(D->SubstitutedEntity);

496 Record.AddSourceLocation(D->DiagLoc);

497 Record.AddString(D->DiagMessage);

498}

499

500void ASTStmtWriter::VisitConceptSpecializationExpr(

502 VisitExpr(E);

503 Record.AddDeclRef(E->getSpecializationDecl());

505 Record.push_back(CR != nullptr);

506 if (CR)

507 Record.AddConceptReference(CR);

510

512}

513

514void ASTStmtWriter::VisitRequiresExpr(RequiresExpr *E) {

515 VisitExpr(E);

516 Record.push_back(E->getLocalParameters().size());

517 Record.push_back(E->getRequirements().size());

520 Record.AddDeclRef(E->getBody());

524 if (auto *TypeReq = dyn_castconcepts::TypeRequirement(R)) {

526 Record.push_back(TypeReq->Status);

529 else

530 Record.AddTypeSourceInfo(TypeReq->getType());

531 } else if (auto *ExprReq = dyn_castconcepts::ExprRequirement(R)) {

532 Record.push_back(ExprReq->getKind());

533 Record.push_back(ExprReq->Status);

534 if (ExprReq->isExprSubstitutionFailure()) {

536 Record, cast<concepts::Requirement::SubstitutionDiagnostic *>(

537 ExprReq->Value));

538 } else

539 Record.AddStmt(cast<Expr *>(ExprReq->Value));

541 Record.AddSourceLocation(ExprReq->NoexceptLoc);

542 const auto &RetReq = ExprReq->getReturnTypeRequirement();

543 if (RetReq.isSubstitutionFailure()) {

546 } else if (RetReq.isTypeConstraint()) {

548 Record.AddTemplateParameterList(

549 RetReq.getTypeConstraintTemplateParameterList());

550 if (ExprReq->Status >=

553 ExprReq->getReturnTypeRequirementSubstitutedConstraintExpr());

554 } else {

555 assert(RetReq.isEmpty());

557 }

558 }

559 } else {

560 auto *NestedReq = castconcepts::NestedRequirement(R);

562 Record.push_back(NestedReq->hasInvalidConstraint());

563 if (NestedReq->hasInvalidConstraint()) {

564 Record.AddString(NestedReq->getInvalidConstraintEntity());

566 } else {

567 Record.AddStmt(NestedReq->getConstraintExpr());

568 if (!NestedReq->isDependent())

570 }

571 }

572 }

573 Record.AddSourceLocation(E->getLParenLoc());

574 Record.AddSourceLocation(E->getRParenLoc());

576

578}

579

580

581void ASTStmtWriter::VisitCapturedStmt(CapturedStmt *S) {

583

584 Record.push_back(std::distance(S->capture_begin(), S->capture_end()));

585

586

587 Record.AddDeclRef(S->getCapturedDecl());

588 Record.push_back(S->getCapturedRegionKind());

589

590 Record.AddDeclRef(S->getCapturedRecordDecl());

591

592

593 for (auto *I : S->capture_inits())

595

596

597 Record.AddStmt(S->getCapturedStmt());

598

599

600 for (const auto &I : S->captures()) {

601 if (I.capturesThis() || I.capturesVariableArrayType())

602 Record.AddDeclRef(nullptr);

603 else

604 Record.AddDeclRef(I.getCapturedVar());

605 Record.push_back(I.getCaptureKind());

606 Record.AddSourceLocation(I.getLocation());

607 }

608

610}

611

614 Record.AddStmt(S->getOriginalStmt());

615 Record.AddDeclRef(S->getOutlinedFunctionDecl());

616

618}

619

620void ASTStmtWriter::VisitExpr(Expr *E) {

622

623 CurrentPackingBits.updateBits();

624 CurrentPackingBits.addBits(E->getDependence(), 5);

625 CurrentPackingBits.addBits(E->getValueKind(), 2);

626 CurrentPackingBits.addBits(E->getObjectKind(), 3);

627

629}

630

631void ASTStmtWriter::VisitConstantExpr(ConstantExpr *E) {

632 VisitExpr(E);

634

638

640

641 switch (E->getResultStorageKind()) {

643 break;

645 Record.push_back(E->Int64Result());

646 break;

648 Record.AddAPValue(E->APValueResult());

649 break;

650 }

651

652 Record.AddStmt(E->getSubExpr());

654}

655

657 VisitExpr(E);

658 Record.AddSourceLocation(E->getLocation());

660}

661

663 VisitExpr(E);

664

665 Record.AddSourceLocation(E->getLocation());

666 Record.AddSourceLocation(E->getLParenLocation());

667 Record.AddSourceLocation(E->getRParenLocation());

668 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

669

671}

672

673void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {

674 VisitExpr(E);

675

676 bool HasFunctionName = E->getFunctionName() != nullptr;

677 Record.push_back(HasFunctionName);

679 llvm::to_underlying(E->getIdentKind()));

680 Record.push_back(E->isTransparent());

681 Record.AddSourceLocation(E->getLocation());

682 if (HasFunctionName)

683 Record.AddStmt(E->getFunctionName());

685}

686

687void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {

688 VisitExpr(E);

689

690 CurrentPackingBits.updateBits();

691

692 CurrentPackingBits.addBit(E->hadMultipleCandidates());

693 CurrentPackingBits.addBit(E->refersToEnclosingVariableOrCapture());

694 CurrentPackingBits.addBits(E->isNonOdrUse(), 2);

695 CurrentPackingBits.addBit(E->isImmediateEscalating());

696 CurrentPackingBits.addBit(E->getDecl() != E->getFoundDecl());

697 CurrentPackingBits.addBit(E->hasQualifier());

698 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());

699

700 if (E->hasTemplateKWAndArgsInfo()) {

701 unsigned NumTemplateArgs = E->getNumTemplateArgs();

702 Record.push_back(NumTemplateArgs);

703 }

704

706

707 if ((->hasTemplateKWAndArgsInfo()) && (->hasQualifier()) &&

708 (E->getDecl() == E->getFoundDecl()) &&

711 }

712

713 if (E->hasQualifier())

714 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

715

716 if (E->getDecl() != E->getFoundDecl())

717 Record.AddDeclRef(E->getFoundDecl());

718

719 if (E->hasTemplateKWAndArgsInfo())

722

723 Record.AddDeclRef(E->getDecl());

724 Record.AddSourceLocation(E->getLocation());

725 Record.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName());

727}

728

729void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {

730 VisitExpr(E);

731 Record.AddSourceLocation(E->getLocation());

732 Record.AddAPInt(E->getValue());

733

734 if (E->getValue().getBitWidth() == 32) {

736 }

737

739}

740

742 VisitExpr(E);

743 Record.AddSourceLocation(E->getLocation());

744 Record.push_back(E->getScale());

745 Record.AddAPInt(E->getValue());

747}

748

749void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {

750 VisitExpr(E);

751 Record.push_back(E->getRawSemantics());

752 Record.push_back(E->isExact());

753 Record.AddAPFloat(E->getValue());

754 Record.AddSourceLocation(E->getLocation());

756}

757

759 VisitExpr(E);

760 Record.AddStmt(E->getSubExpr());

762}

763

764void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {

765 VisitExpr(E);

766

767

768 Record.push_back(E->getNumConcatenated());

769 Record.push_back(E->getLength());

770 Record.push_back(E->getCharByteWidth());

771 Record.push_back(llvm::to_underlying(E->getKind()));

772 Record.push_back(E->isPascal());

773

774

775 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)

776 Record.AddSourceLocation(E->getStrTokenLoc(I));

777

778

779 StringRef StrData = E->getBytes();

780 for (unsigned I = 0, N = E->getByteLength(); I != N; ++I)

781 Record.push_back(StrData[I]);

782

784}

785

787 VisitExpr(E);

788 Record.push_back(E->getValue());

789 Record.AddSourceLocation(E->getLocation());

790 Record.push_back(llvm::to_underlying(E->getKind()));

791

793

795}

796

797void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {

798 VisitExpr(E);

799 Record.push_back(E->isProducedByFoldExpansion());

800 Record.AddSourceLocation(E->getLParen());

801 Record.AddSourceLocation(E->getRParen());

802 Record.AddStmt(E->getSubExpr());

804}

805

806void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {

807 VisitExpr(E);

808 Record.push_back(E->getNumExprs());

809 for (auto *SubStmt : E->exprs())

810 Record.AddStmt(SubStmt);

811 Record.AddSourceLocation(E->getLParenLoc());

812 Record.AddSourceLocation(E->getRParenLoc());

814}

815

816void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {

817 VisitExpr(E);

818 bool HasFPFeatures = E->hasStoredFPFeatures();

819

820

821 CurrentPackingBits.addBit(HasFPFeatures);

822 Record.AddStmt(E->getSubExpr());

823 CurrentPackingBits.addBits(E->getOpcode(),

824 5);

825 Record.AddSourceLocation(E->getOperatorLoc());

826 CurrentPackingBits.addBit(E->canOverflow());

827

828 if (HasFPFeatures)

829 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());

831}

832

833void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {

834 VisitExpr(E);

835 Record.push_back(E->getNumComponents());

836 Record.push_back(E->getNumExpressions());

837 Record.AddSourceLocation(E->getOperatorLoc());

838 Record.AddSourceLocation(E->getRParenLoc());

839 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

840 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {

842 Record.push_back(ON.getKind());

848 break;

849

852 break;

853

856 break;

857

860 break;

861 }

862 }

863 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)

864 Record.AddStmt(E->getIndexExpr(I));

866}

867

869 VisitExpr(E);

870 Record.push_back(E->getKind());

871 if (E->isArgumentType())

872 Record.AddTypeSourceInfo(E->getArgumentTypeInfo());

873 else {

875 Record.AddStmt(E->getArgumentExpr());

876 }

877 Record.AddSourceLocation(E->getOperatorLoc());

878 Record.AddSourceLocation(E->getRParenLoc());

880}

881

883 VisitExpr(E);

884 Record.AddStmt(E->getLHS());

885 Record.AddStmt(E->getRHS());

886 Record.AddSourceLocation(E->getRBracketLoc());

888}

889

891 VisitExpr(E);

892 Record.AddStmt(E->getBase());

893 Record.AddStmt(E->getRowIdx());

894 Record.AddStmt(E->getColumnIdx());

895 Record.AddSourceLocation(E->getRBracketLoc());

897}

898

900 VisitExpr(E);

901 Record.writeEnum(E->ASType);

902 Record.AddStmt(E->getBase());

903 Record.AddStmt(E->getLowerBound());

904 Record.AddStmt(E->getLength());

905 if (E->isOMPArraySection())

906 Record.AddStmt(E->getStride());

907 Record.AddSourceLocation(E->getColonLocFirst());

908

909 if (E->isOMPArraySection())

910 Record.AddSourceLocation(E->getColonLocSecond());

911

912 Record.AddSourceLocation(E->getRBracketLoc());

914}

915

917 VisitExpr(E);

918 Record.push_back(E->getDimensions().size());

919 Record.AddStmt(E->getBase());

920 for (Expr *Dim : E->getDimensions())

922 for (SourceRange SR : E->getBracketsRanges())

923 Record.AddSourceRange(SR);

924 Record.AddSourceLocation(E->getLParenLoc());

925 Record.AddSourceLocation(E->getRParenLoc());

927}

928

929void ASTStmtWriter::VisitOMPIteratorExpr(OMPIteratorExpr *E) {

930 VisitExpr(E);

931 Record.push_back(E->numOfIterators());

932 Record.AddSourceLocation(E->getIteratorKwLoc());

933 Record.AddSourceLocation(E->getLParenLoc());

934 Record.AddSourceLocation(E->getRParenLoc());

935 for (unsigned I = 0, End = E->numOfIterators(); I < End; ++I) {

936 Record.AddDeclRef(E->getIteratorDecl(I));

937 Record.AddSourceLocation(E->getAssignLoc(I));

942 Record.AddSourceLocation(E->getColonLoc(I));

944 Record.AddSourceLocation(E->getSecondColonLoc(I));

945

951 }

953}

954

955void ASTStmtWriter::VisitCallExpr(CallExpr *E) {

956 VisitExpr(E);

957

958 Record.push_back(E->getNumArgs());

959 CurrentPackingBits.updateBits();

960 CurrentPackingBits.addBit(static_cast<bool>(E->getADLCallKind()));

961 CurrentPackingBits.addBit(E->hasStoredFPFeatures());

962

963 Record.AddSourceLocation(E->getRParenLoc());

964 Record.AddStmt(E->getCallee());

966 Arg != ArgEnd; ++Arg)

967 Record.AddStmt(*Arg);

968

969 if (E->hasStoredFPFeatures())

970 Record.push_back(E->getFPFeatures().getAsOpaqueInt());

971

972 if (->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()) &&

975

977}

978

979void ASTStmtWriter::VisitRecoveryExpr(RecoveryExpr *E) {

980 VisitExpr(E);

985 Record.AddStmt(Child);

987}

988

989void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {

990 VisitExpr(E);

991

992 bool HasQualifier = E->hasQualifier();

993 bool HasFoundDecl = E->hasFoundDecl();

994 bool HasTemplateInfo = E->hasTemplateKWAndArgsInfo();

995 unsigned NumTemplateArgs = E->getNumTemplateArgs();

996

997

998

999 CurrentPackingBits.updateBits();

1000 CurrentPackingBits.addBit(HasQualifier);

1001 CurrentPackingBits.addBit(HasFoundDecl);

1002 CurrentPackingBits.addBit(HasTemplateInfo);

1003 Record.push_back(NumTemplateArgs);

1004

1005 Record.AddStmt(E->getBase());

1006 Record.AddDeclRef(E->getMemberDecl());

1007 Record.AddDeclarationNameLoc(E->MemberDNLoc,

1008 E->getMemberDecl()->getDeclName());

1009 Record.AddSourceLocation(E->getMemberLoc());

1010 CurrentPackingBits.addBit(E->isArrow());

1011 CurrentPackingBits.addBit(E->hadMultipleCandidates());

1012 CurrentPackingBits.addBits(E->isNonOdrUse(), 2);

1013 Record.AddSourceLocation(E->getOperatorLoc());

1014

1015 if (HasQualifier)

1016 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

1017

1018 if (HasFoundDecl) {

1020 Record.AddDeclRef(FoundDecl.getDecl());

1021 CurrentPackingBits.addBits(FoundDecl.getAccess(), 2);

1022 }

1023

1024 if (HasTemplateInfo)

1027

1029}

1030

1031void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {

1032 VisitExpr(E);

1033 Record.AddStmt(E->getBase());

1034 Record.AddSourceLocation(E->getIsaMemberLoc());

1035 Record.AddSourceLocation(E->getOpLoc());

1036 Record.push_back(E->isArrow());

1038}

1039

1040void ASTStmtWriter::

1042 VisitExpr(E);

1043 Record.AddStmt(E->getSubExpr());

1044 Record.push_back(E->shouldCopy());

1046}

1047

1049 VisitExplicitCastExpr(E);

1050 Record.AddSourceLocation(E->getLParenLoc());

1051 Record.AddSourceLocation(E->getBridgeKeywordLoc());

1052 Record.push_back(E->getBridgeKind());

1054}

1055

1056void ASTStmtWriter::VisitCastExpr(CastExpr *E) {

1057 VisitExpr(E);

1058

1059 Record.push_back(E->path_size());

1060 CurrentPackingBits.updateBits();

1061

1062 CurrentPackingBits.addBits(E->getCastKind(), 7);

1063 CurrentPackingBits.addBit(E->hasStoredFPFeatures());

1064 Record.AddStmt(E->getSubExpr());

1065

1067 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)

1068 Record.AddCXXBaseSpecifier(**PI);

1069

1070 if (E->hasStoredFPFeatures())

1071 Record.push_back(E->getFPFeatures().getAsOpaqueInt());

1072}

1073

1074void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {

1075 VisitExpr(E);

1076

1077

1078

1079 CurrentPackingBits.updateBits();

1080 CurrentPackingBits.addBits(E->getOpcode(), 6);

1081 bool HasFPFeatures = E->hasStoredFPFeatures();

1082 CurrentPackingBits.addBit(HasFPFeatures);

1083 CurrentPackingBits.addBit(E->hasExcludedOverflowPattern());

1084 Record.AddStmt(E->getLHS());

1085 Record.AddStmt(E->getRHS());

1086 Record.AddSourceLocation(E->getOperatorLoc());

1087 if (HasFPFeatures)

1088 Record.push_back(E->getStoredFPFeatures().getAsOpaqueInt());

1089

1093

1095}

1096

1098 VisitBinaryOperator(E);

1099 Record.AddTypeRef(E->getComputationLHSType());

1100 Record.AddTypeRef(E->getComputationResultType());

1101

1105

1107}

1108

1110 VisitExpr(E);

1111 Record.AddStmt(E->getCond());

1112 Record.AddStmt(E->getLHS());

1113 Record.AddStmt(E->getRHS());

1114 Record.AddSourceLocation(E->getQuestionLoc());

1115 Record.AddSourceLocation(E->getColonLoc());

1117}

1118

1119void

1121 VisitExpr(E);

1122 Record.AddStmt(E->getOpaqueValue());

1123 Record.AddStmt(E->getCommon());

1124 Record.AddStmt(E->getCond());

1125 Record.AddStmt(E->getTrueExpr());

1126 Record.AddStmt(E->getFalseExpr());

1127 Record.AddSourceLocation(E->getQuestionLoc());

1128 Record.AddSourceLocation(E->getColonLoc());

1130}

1131

1133 VisitCastExpr(E);

1134 CurrentPackingBits.addBit(E->isPartOfExplicitCast());

1135

1136 if (E->path_size() == 0 && ->hasStoredFPFeatures())

1138

1140}

1141

1143 VisitCastExpr(E);

1144 Record.AddTypeSourceInfo(E->getTypeInfoAsWritten());

1145}

1146

1147void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {

1148 VisitExplicitCastExpr(E);

1149 Record.AddSourceLocation(E->getLParenLoc());

1150 Record.AddSourceLocation(E->getRParenLoc());

1152}

1153

1155 VisitExpr(E);

1156 Record.AddSourceLocation(E->getLParenLoc());

1157 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

1158 Record.AddStmt(E->getInitializer());

1159 Record.push_back(E->isFileScope());

1161}

1162

1164 VisitExpr(E);

1165 Record.AddStmt(E->getBase());

1166 Record.AddIdentifierRef(&E->getAccessor());

1167 Record.AddSourceLocation(E->getAccessorLoc());

1169}

1170

1171void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {

1172 VisitExpr(E);

1173

1174

1175 Record.AddStmt(E->getSyntacticForm());

1176 Record.AddSourceLocation(E->getLBraceLoc());

1177 Record.AddSourceLocation(E->getRBraceLoc());

1178 bool isArrayFiller = isa<Expr *>(E->ArrayFillerOrUnionFieldInit);

1179 Record.push_back(isArrayFiller);

1180 if (isArrayFiller)

1181 Record.AddStmt(E->getArrayFiller());

1182 else

1183 Record.AddDeclRef(E->getInitializedFieldInUnion());

1184 Record.push_back(E->hadArrayRangeDesignator());

1185 Record.push_back(E->getNumInits());

1186 if (isArrayFiller) {

1187

1188

1189 Expr *filler = E->getArrayFiller();

1190 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)

1191 Record.AddStmt(E->getInit(I) != filler ? E->getInit(I) : nullptr);

1192 } else {

1193 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)

1194 Record.AddStmt(E->getInit(I));

1195 }

1197}

1198

1200 VisitExpr(E);

1201 Record.push_back(E->getNumSubExprs());

1202 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)

1203 Record.AddStmt(E->getSubExpr(I));

1204 Record.AddSourceLocation(E->getEqualOrColonLoc());

1205 Record.push_back(E->usesGNUSyntax());

1207 if (D.isFieldDesignator()) {

1208 if (FieldDecl *Field = D.getFieldDecl()) {

1210 Record.AddDeclRef(Field);

1211 } else {

1213 Record.AddIdentifierRef(D.getFieldName());

1214 }

1215 Record.AddSourceLocation(D.getDotLoc());

1216 Record.AddSourceLocation(D.getFieldLoc());

1217 } else if (D.isArrayDesignator()) {

1219 Record.push_back(D.getArrayIndex());

1220 Record.AddSourceLocation(D.getLBracketLoc());

1221 Record.AddSourceLocation(D.getRBracketLoc());

1222 } else {

1223 assert(D.isArrayRangeDesignator() && "Unknown designator");

1225 Record.push_back(D.getArrayIndex());

1226 Record.AddSourceLocation(D.getLBracketLoc());

1227 Record.AddSourceLocation(D.getEllipsisLoc());

1228 Record.AddSourceLocation(D.getRBracketLoc());

1229 }

1230 }

1232}

1233

1235 VisitExpr(E);

1236 Record.AddStmt(E->getBase());

1237 Record.AddStmt(E->getUpdater());

1239}

1240

1241void ASTStmtWriter::VisitNoInitExpr(NoInitExpr *E) {

1242 VisitExpr(E);

1244}

1245

1247 VisitExpr(E);

1248 Record.AddStmt(E->SubExprs[0]);

1249 Record.AddStmt(E->SubExprs[1]);

1251}

1252

1254 VisitExpr(E);

1256}

1257

1259 VisitExpr(E);

1261}

1262

1263void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {

1264 VisitExpr(E);

1265 Record.AddStmt(E->getSubExpr());

1266 Record.AddTypeSourceInfo(E->getWrittenTypeInfo());

1267 Record.AddSourceLocation(E->getBuiltinLoc());

1268 Record.AddSourceLocation(E->getRParenLoc());

1269 Record.push_back(E->isMicrosoftABI());

1271}

1272

1273void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {

1274 VisitExpr(E);

1275 Record.AddDeclRef(cast_or_null(E->getParentContext()));

1278 Record.push_back(llvm::to_underlying(E->getIdentKind()));

1280}

1281

1282void ASTStmtWriter::VisitEmbedExpr(EmbedExpr *E) {

1283 VisitExpr(E);

1286 Record.AddStmt(E->getDataStringLiteral());

1287 Record.writeUInt32(E->getStartingElementPos());

1288 Record.writeUInt32(E->getDataElementCount());

1290}

1291

1292void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {

1293 VisitExpr(E);

1294 Record.AddSourceLocation(E->getAmpAmpLoc());

1295 Record.AddSourceLocation(E->getLabelLoc());

1296 Record.AddDeclRef(E->getLabel());

1298}

1299

1300void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {

1301 VisitExpr(E);

1302 Record.AddStmt(E->getSubStmt());

1303 Record.AddSourceLocation(E->getLParenLoc());

1304 Record.AddSourceLocation(E->getRParenLoc());

1305 Record.push_back(E->getTemplateDepth());

1307}

1308

1309void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {

1310 VisitExpr(E);

1311 Record.AddStmt(E->getCond());

1312 Record.AddStmt(E->getLHS());

1313 Record.AddStmt(E->getRHS());

1314 Record.AddSourceLocation(E->getBuiltinLoc());

1315 Record.AddSourceLocation(E->getRParenLoc());

1316 Record.push_back(E->isConditionDependent() ? false : E->isConditionTrue());

1318}

1319

1320void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {

1321 VisitExpr(E);

1322 Record.AddSourceLocation(E->getTokenLocation());

1324}

1325

1327 VisitExpr(E);

1328 Record.push_back(E->getNumSubExprs());

1329 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)

1330 Record.AddStmt(E->getExpr(I));

1331 Record.AddSourceLocation(E->getBuiltinLoc());

1332 Record.AddSourceLocation(E->getRParenLoc());

1334}

1335

1337 VisitExpr(E);

1338 Record.AddSourceLocation(E->getBuiltinLoc());

1339 Record.AddSourceLocation(E->getRParenLoc());

1340 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

1341 Record.AddStmt(E->getSrcExpr());

1343}

1344

1345void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {

1346 VisitExpr(E);

1347 Record.AddDeclRef(E->getBlockDecl());

1349}

1350

1352 VisitExpr(E);

1353

1354 Record.push_back(E->getNumAssocs());

1355 Record.push_back(E->isExprPredicate());

1356 Record.push_back(E->ResultIndex);

1357 Record.AddSourceLocation(E->getGenericLoc());

1358 Record.AddSourceLocation(E->getDefaultLoc());

1359 Record.AddSourceLocation(E->getRParenLoc());

1360

1361 Stmt **Stmts = E->getTrailingObjects<Stmt *>();

1362

1363

1364

1365 for (unsigned I = 0, N = E->getNumAssocs() + 1; I < N; ++I)

1366 Record.AddStmt(Stmts[I]);

1367

1369 for (unsigned I = 0, N = E->getNumAssocs(); I < N; ++I)

1370 Record.AddTypeSourceInfo(TSIs[I]);

1371

1373}

1374

1376 VisitExpr(E);

1377 Record.push_back(E->getNumSemanticExprs());

1378

1379

1380

1381 unsigned result = E->getResultExprIndex();

1383 Record.push_back(result);

1384

1385 Record.AddStmt(E->getSyntacticForm());

1387 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {

1389 }

1391}

1392

1393void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {

1394 VisitExpr(E);

1395 Record.push_back(E->getOp());

1396 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)

1397 Record.AddStmt(E->getSubExprs()[I]);

1398 Record.AddSourceLocation(E->getBuiltinLoc());

1399 Record.AddSourceLocation(E->getRParenLoc());

1401}

1402

1403

1404

1405

1406

1408 VisitExpr(E);

1409 Record.AddStmt(E->getString());

1410 Record.AddSourceLocation(E->getAtLoc());

1412}

1413

1414void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {

1415 VisitExpr(E);

1416 Record.AddStmt(E->getSubExpr());

1417 Record.AddDeclRef(E->getBoxingMethod());

1420}

1421

1423 VisitExpr(E);

1424 Record.push_back(E->getNumElements());

1425 for (unsigned i = 0; i < E->getNumElements(); i++)

1426 Record.AddStmt(E->getElement(i));

1427 Record.AddDeclRef(E->getArrayWithObjectsMethod());

1430}

1431

1433 VisitExpr(E);

1434 Record.push_back(E->getNumElements());

1435 Record.push_back(E->HasPackExpansions);

1436 for (unsigned i = 0; i < E->getNumElements(); i++) {

1438 Record.AddStmt(Element.Key);

1439 Record.AddStmt(Element.Value);

1440 if (E->HasPackExpansions) {

1441 Record.AddSourceLocation(Element.EllipsisLoc);

1442 unsigned NumExpansions = 0;

1443 if (Element.NumExpansions)

1444 NumExpansions = *Element.NumExpansions + 1;

1445 Record.push_back(NumExpansions);

1446 }

1447 }

1448

1449 Record.AddDeclRef(E->getDictWithObjectsMethod());

1452}

1453

1454void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {

1455 VisitExpr(E);

1456 Record.AddTypeSourceInfo(E->getEncodedTypeSourceInfo());

1457 Record.AddSourceLocation(E->getAtLoc());

1458 Record.AddSourceLocation(E->getRParenLoc());

1460}

1461

1463 VisitExpr(E);

1464 Record.AddSelectorRef(E->getSelector());

1465 Record.AddSourceLocation(E->getAtLoc());

1466 Record.AddSourceLocation(E->getRParenLoc());

1468}

1469

1471 VisitExpr(E);

1472 Record.AddDeclRef(E->getProtocol());

1473 Record.AddSourceLocation(E->getAtLoc());

1474 Record.AddSourceLocation(E->ProtoLoc);

1475 Record.AddSourceLocation(E->getRParenLoc());

1477}

1478

1479void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {

1480 VisitExpr(E);

1481 Record.AddDeclRef(E->getDecl());

1482 Record.AddSourceLocation(E->getLocation());

1483 Record.AddSourceLocation(E->getOpLoc());

1484 Record.AddStmt(E->getBase());

1485 Record.push_back(E->isArrow());

1486 Record.push_back(E->isFreeIvar());

1488}

1489

1491 VisitExpr(E);

1492 Record.push_back(E->SetterAndMethodRefFlags.getInt());

1493 Record.push_back(E->isImplicitProperty());

1494 if (E->isImplicitProperty()) {

1495 Record.AddDeclRef(E->getImplicitPropertyGetter());

1496 Record.AddDeclRef(E->getImplicitPropertySetter());

1497 } else {

1498 Record.AddDeclRef(E->getExplicitProperty());

1499 }

1500 Record.AddSourceLocation(E->getLocation());

1501 Record.AddSourceLocation(E->getReceiverLocation());

1502 if (E->isObjectReceiver()) {

1503 Record.push_back(0);

1504 Record.AddStmt(E->getBase());

1505 } else if (E->isSuperReceiver()) {

1506 Record.push_back(1);

1507 Record.AddTypeRef(E->getSuperReceiverType());

1508 } else {

1509 Record.push_back(2);

1510 Record.AddDeclRef(E->getClassReceiver());

1511 }

1512

1514}

1515

1517 VisitExpr(E);

1518 Record.AddSourceLocation(E->getRBracket());

1519 Record.AddStmt(E->getBaseExpr());

1520 Record.AddStmt(E->getKeyExpr());

1521 Record.AddDeclRef(E->getAtIndexMethodDecl());

1522 Record.AddDeclRef(E->setAtIndexMethodDecl());

1523

1525}

1526

1527void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {

1528 VisitExpr(E);

1529 Record.push_back(E->getNumArgs());

1530 Record.push_back(E->getNumStoredSelLocs());

1531 Record.push_back(E->SelLocsKind);

1532 Record.push_back(E->isDelegateInitCall());

1533 Record.push_back(E->IsImplicit);

1534 Record.push_back((unsigned)E->getReceiverKind());

1535 switch (E->getReceiverKind()) {

1537 Record.AddStmt(E->getInstanceReceiver());

1538 break;

1539

1541 Record.AddTypeSourceInfo(E->getClassReceiverTypeInfo());

1542 break;

1543

1546 Record.AddTypeRef(E->getSuperType());

1547 Record.AddSourceLocation(E->getSuperLoc());

1548 break;

1549 }

1550

1551 if (E->getMethodDecl()) {

1552 Record.push_back(1);

1553 Record.AddDeclRef(E->getMethodDecl());

1554 } else {

1555 Record.push_back(0);

1556 Record.AddSelectorRef(E->getSelector());

1557 }

1558

1559 Record.AddSourceLocation(E->getLeftLoc());

1560 Record.AddSourceLocation(E->getRightLoc());

1561

1563 Arg != ArgEnd; ++Arg)

1564 Record.AddStmt(*Arg);

1565

1567 for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)

1568 Record.AddSourceLocation(Locs[i]);

1569

1571}

1572

1575 Record.AddStmt(S->getElement());

1576 Record.AddStmt(S->getCollection());

1577 Record.AddStmt(S->getBody());

1578 Record.AddSourceLocation(S->getForLoc());

1579 Record.AddSourceLocation(S->getRParenLoc());

1581}

1582

1583void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {

1585 Record.AddStmt(S->getCatchBody());

1586 Record.AddDeclRef(S->getCatchParamDecl());

1587 Record.AddSourceLocation(S->getAtCatchLoc());

1588 Record.AddSourceLocation(S->getRParenLoc());

1590}

1591

1592void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {

1594 Record.AddStmt(S->getFinallyBody());

1595 Record.AddSourceLocation(S->getAtFinallyLoc());

1597}

1598

1600 VisitStmt(S);

1601 Record.AddStmt(S->getSubStmt());

1602 Record.AddSourceLocation(S->getAtLoc());

1604}

1605

1606void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {

1608 Record.push_back(S->getNumCatchStmts());

1609 Record.push_back(S->getFinallyStmt() != nullptr);

1610 Record.AddStmt(S->getTryBody());

1613 if (S->getFinallyStmt())

1614 Record.AddStmt(S->getFinallyStmt());

1615 Record.AddSourceLocation(S->getAtTryLoc());

1617}

1618

1620 VisitStmt(S);

1621 Record.AddStmt(S->getSynchExpr());

1622 Record.AddStmt(S->getSynchBody());

1623 Record.AddSourceLocation(S->getAtSynchronizedLoc());

1625}

1626

1627void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {

1628 VisitStmt(S);

1629 Record.AddStmt(S->getThrowExpr());

1630 Record.AddSourceLocation(S->getThrowLoc());

1632}

1633

1635 VisitExpr(E);

1636 Record.push_back(E->getValue());

1637 Record.AddSourceLocation(E->getLocation());

1639}

1640

1642 VisitExpr(E);

1644 Record.AddVersionTuple(E->getVersion());

1646}

1647

1648

1649

1650

1651

1652void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {

1654 Record.AddSourceLocation(S->getCatchLoc());

1655 Record.AddDeclRef(S->getExceptionDecl());

1656 Record.AddStmt(S->getHandlerBlock());

1658}

1659

1660void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {

1662 Record.push_back(S->getNumHandlers());

1663 Record.AddSourceLocation(S->getTryLoc());

1664 Record.AddStmt(S->getTryBlock());

1665 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)

1666 Record.AddStmt(S->getHandler(i));

1668}

1669

1670void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {

1672 Record.AddSourceLocation(S->getForLoc());

1673 Record.AddSourceLocation(S->getCoawaitLoc());

1674 Record.AddSourceLocation(S->getColonLoc());

1675 Record.AddSourceLocation(S->getRParenLoc());

1676 Record.AddStmt(S->getInit());

1677 Record.AddStmt(S->getRangeStmt());

1678 Record.AddStmt(S->getBeginStmt());

1679 Record.AddStmt(S->getEndStmt());

1680 Record.AddStmt(S->getCond());

1681 Record.AddStmt(S->getInc());

1682 Record.AddStmt(S->getLoopVarStmt());

1683 Record.AddStmt(S->getBody());

1685}

1686

1689 Record.AddSourceLocation(S->getKeywordLoc());

1690 Record.push_back(S->isIfExists());

1691 Record.AddNestedNameSpecifierLoc(S->getQualifierLoc());

1692 Record.AddDeclarationNameInfo(S->getNameInfo());

1693 Record.AddStmt(S->getSubStmt());

1695}

1696

1698 VisitCallExpr(E);

1699 Record.push_back(E->getOperator());

1700 Record.AddSourceRange(E->Range);

1701

1702 if (->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))

1704

1706}

1707

1709 VisitCallExpr(E);

1710

1711 if (->hasStoredFPFeatures() && !static_cast<bool>(E->getADLCallKind()))

1713

1715}

1716

1717void ASTStmtWriter::VisitCXXRewrittenBinaryOperator(

1719 VisitExpr(E);

1720 Record.push_back(E->isReversed());

1721 Record.AddStmt(E->getSemanticForm());

1723}

1724

1726 VisitExpr(E);

1727

1728 Record.push_back(E->getNumArgs());

1729 Record.push_back(E->isElidable());

1730 Record.push_back(E->hadMultipleCandidates());

1731 Record.push_back(E->isListInitialization());

1732 Record.push_back(E->isStdInitListInitialization());

1733 Record.push_back(E->requiresZeroInitialization());

1735 llvm::to_underlying(E->getConstructionKind()));

1736 Record.push_back(E->isImmediateEscalating());

1737 Record.AddSourceLocation(E->getLocation());

1738 Record.AddDeclRef(E->getConstructor());

1739 Record.AddSourceRange(E->getParenOrBraceRange());

1740

1741 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)

1742 Record.AddStmt(E->getArg(I));

1743

1745}

1746

1748 VisitExpr(E);

1749 Record.AddDeclRef(E->getConstructor());

1750 Record.AddSourceLocation(E->getLocation());

1751 Record.push_back(E->constructsVBase());

1752 Record.push_back(E->inheritedFromVBase());

1754}

1755

1757 VisitCXXConstructExpr(E);

1758 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

1760}

1761

1762void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {

1763 VisitExpr(E);

1765 Record.AddSourceRange(E->IntroducerRange);

1767 Record.AddSourceLocation(E->CaptureDefaultLoc);

1770 Record.AddSourceLocation(E->ClosingBrace);

1771

1772

1774 CEnd = E->capture_init_end();

1775 C != CEnd; ++C) {

1777 }

1778

1779

1780

1781

1783}

1784

1786 VisitExpr(E);

1787 Record.AddStmt(E->getSubExpr());

1789}

1790

1792 VisitExplicitCastExpr(E);

1793 Record.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()));

1794 CurrentPackingBits.addBit(E->getAngleBrackets().isValid());

1795 if (E->getAngleBrackets().isValid())

1796 Record.AddSourceRange(E->getAngleBrackets());

1797}

1798

1800 VisitCXXNamedCastExpr(E);

1802}

1803

1805 VisitCXXNamedCastExpr(E);

1807}

1808

1810 VisitCXXNamedCastExpr(E);

1812}

1813

1815 VisitCXXNamedCastExpr(E);

1817}

1818

1820 VisitCXXNamedCastExpr(E);

1822}

1823

1825 VisitExplicitCastExpr(E);

1826 Record.AddSourceLocation(E->getLParenLoc());

1827 Record.AddSourceLocation(E->getRParenLoc());

1829}

1830

1832 VisitExplicitCastExpr(E);

1836}

1837

1839 VisitCallExpr(E);

1840 Record.AddSourceLocation(E->UDSuffixLoc);

1842}

1843

1845 VisitExpr(E);

1846 Record.push_back(E->getValue());

1847 Record.AddSourceLocation(E->getLocation());

1849}

1850

1852 VisitExpr(E);

1853 Record.AddSourceLocation(E->getLocation());

1855}

1856

1857void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {

1858 VisitExpr(E);

1860 if (E->isTypeOperand()) {

1861 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());

1863 } else {

1864 Record.AddStmt(E->getExprOperand());

1866 }

1867}

1868

1869void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {

1870 VisitExpr(E);

1871 Record.AddSourceLocation(E->getLocation());

1872 Record.push_back(E->isImplicit());

1873 Record.push_back(E->isCapturedByCopyInLambdaWithExplicitObjectParameter());

1874

1876}

1877

1878void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {

1879 VisitExpr(E);

1880 Record.AddSourceLocation(E->getThrowLoc());

1881 Record.AddStmt(E->getSubExpr());

1882 Record.push_back(E->isThrownVariableInScope());

1884}

1885

1887 VisitExpr(E);

1888 Record.AddDeclRef(E->getParam());

1889 Record.AddDeclRef(cast_or_null(E->getUsedContext()));

1890 Record.AddSourceLocation(E->getUsedLocation());

1891 Record.push_back(E->hasRewrittenInit());

1892 if (E->hasRewrittenInit())

1893 Record.AddStmt(E->getRewrittenExpr());

1895}

1896

1898 VisitExpr(E);

1899 Record.push_back(E->hasRewrittenInit());

1900 Record.AddDeclRef(E->getField());

1901 Record.AddDeclRef(cast_or_null(E->getUsedContext()));

1903 if (E->hasRewrittenInit())

1904 Record.AddStmt(E->getRewrittenExpr());

1906}

1907

1909 VisitExpr(E);

1910 Record.AddCXXTemporary(E->getTemporary());

1911 Record.AddStmt(E->getSubExpr());

1913}

1914

1916 VisitExpr(E);

1917 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

1918 Record.AddSourceLocation(E->getRParenLoc());

1920}

1921

1922void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {

1923 VisitExpr(E);

1924

1925 Record.push_back(E->isArray());

1926 Record.push_back(E->hasInitializer());

1927 Record.push_back(E->getNumPlacementArgs());

1928 Record.push_back(E->isParenTypeId());

1929

1930 Record.push_back(E->isGlobalNew());

1931 Record.push_back(E->passAlignment());

1932 Record.push_back(E->doesUsualArrayDeleteWantSize());

1935

1936 Record.AddDeclRef(E->getOperatorNew());

1937 Record.AddDeclRef(E->getOperatorDelete());

1938 Record.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo());

1939 if (E->isParenTypeId())

1940 Record.AddSourceRange(E->getTypeIdParens());

1942 Record.AddSourceRange(E->getDirectInitRange());

1943

1945 I != N; ++I)

1947

1949}

1950

1951void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {

1952 VisitExpr(E);

1953 Record.push_back(E->isGlobalDelete());

1954 Record.push_back(E->isArrayForm());

1955 Record.push_back(E->isArrayFormAsWritten());

1956 Record.push_back(E->doesUsualArrayDeleteWantSize());

1957 Record.AddDeclRef(E->getOperatorDelete());

1958 Record.AddStmt(E->getArgument());

1960

1962}

1963

1965 VisitExpr(E);

1966

1967 Record.AddStmt(E->getBase());

1968 Record.push_back(E->isArrow());

1969 Record.AddSourceLocation(E->getOperatorLoc());

1970 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

1971 Record.AddTypeSourceInfo(E->getScopeTypeInfo());

1972 Record.AddSourceLocation(E->getColonColonLoc());

1973 Record.AddSourceLocation(E->getTildeLoc());

1974

1975

1976 Record.AddIdentifierRef(E->getDestroyedTypeIdentifier());

1977 if (E->getDestroyedTypeIdentifier())

1978 Record.AddSourceLocation(E->getDestroyedTypeLoc());

1979 else

1980 Record.AddTypeSourceInfo(E->getDestroyedTypeInfo());

1981

1983}

1984

1986 VisitExpr(E);

1987 Record.push_back(E->getNumObjects());

1988 for (auto &Obj : E->getObjects()) {

1989 if (auto *BD = Obj.dyn_cast<BlockDecl *>()) {

1991 Record.AddDeclRef(BD);

1994 Record.AddStmt(CLE);

1995 }

1996 }

1997

1998 Record.push_back(E->cleanupsHaveSideEffects());

1999 Record.AddStmt(E->getSubExpr());

2001}

2002

2003void ASTStmtWriter::VisitCXXDependentScopeMemberExpr(

2005 VisitExpr(E);

2006

2007

2008

2009 Record.push_back(E->getNumTemplateArgs());

2010 CurrentPackingBits.updateBits();

2011 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());

2012 CurrentPackingBits.addBit(E->hasFirstQualifierFoundInScope());

2013

2014 if (E->hasTemplateKWAndArgsInfo()) {

2019 }

2020

2021 CurrentPackingBits.addBit(E->isArrow());

2022

2023 Record.AddTypeRef(E->getBaseType());

2024 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

2025 CurrentPackingBits.addBit(->isImplicitAccess());

2026 if (->isImplicitAccess())

2027 Record.AddStmt(E->getBase());

2028

2029 Record.AddSourceLocation(E->getOperatorLoc());

2030

2031 if (E->hasFirstQualifierFoundInScope())

2032 Record.AddDeclRef(E->getFirstQualifierFoundInScope());

2033

2034 Record.AddDeclarationNameInfo(E->MemberNameInfo);

2036}

2037

2038void

2040 VisitExpr(E);

2041

2042

2043

2044 CurrentPackingBits.addBit(

2046

2050

2051 CurrentPackingBits.addBits(ArgInfo.NumTemplateArgs, 16);

2054 }

2055

2056 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

2057 Record.AddDeclarationNameInfo(E->NameInfo);

2059}

2060

2061void

2063 VisitExpr(E);

2064 Record.push_back(E->getNumArgs());

2066 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)

2067 Record.AddStmt(*ArgI);

2068 Record.AddTypeSourceInfo(E->getTypeSourceInfo());

2069 Record.AddSourceLocation(E->getLParenLoc());

2070 Record.AddSourceLocation(E->getRParenLoc());

2071 Record.push_back(E->isListInitialization());

2073}

2074

2075void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {

2076 VisitExpr(E);

2077

2078 Record.push_back(E->getNumDecls());

2079

2080 CurrentPackingBits.updateBits();

2081 CurrentPackingBits.addBit(E->hasTemplateKWAndArgsInfo());

2082 if (E->hasTemplateKWAndArgsInfo()) {

2084 *E->getTrailingASTTemplateKWAndArgsInfo();

2087 }

2088

2090 OvE = E->decls_end();

2091 OvI != OvE; ++OvI) {

2092 Record.AddDeclRef(OvI.getDecl());

2093 Record.push_back(OvI.getAccess());

2094 }

2095

2096 Record.AddDeclarationNameInfo(E->getNameInfo());

2097 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

2098}

2099

2101 VisitOverloadExpr(E);

2102 CurrentPackingBits.addBit(E->isArrow());

2103 CurrentPackingBits.addBit(E->hasUnresolvedUsing());

2104 CurrentPackingBits.addBit(->isImplicitAccess());

2105 if (->isImplicitAccess())

2106 Record.AddStmt(E->getBase());

2107

2108 Record.AddSourceLocation(E->getOperatorLoc());

2109

2110 Record.AddTypeRef(E->getBaseType());

2112}

2113

2115 VisitOverloadExpr(E);

2116 CurrentPackingBits.addBit(E->requiresADL());

2117 Record.AddDeclRef(E->getNamingClass());

2119

2121

2122

2124 for (auto *Found :

2125 Record.getASTContext().getTranslationUnitDecl()->lookup(Name))

2126 if (Found->isFromASTFile())

2128

2131 for (auto *NS : ExternalNSs)

2132 for (auto *Found : NS->lookup(Name))

2134 }

2135}

2136

2137void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {

2138 VisitExpr(E);

2143 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)

2144 Record.AddTypeSourceInfo(E->getArg(I));

2146}

2147

2149 VisitExpr(E);

2150 Record.push_back(E->getTrait());

2151 Record.push_back(E->getValue());

2153 Record.AddTypeSourceInfo(E->getQueriedTypeSourceInfo());

2154 Record.AddStmt(E->getDimensionExpression());

2156}

2157

2159 VisitExpr(E);

2160 Record.push_back(E->getTrait());

2161 Record.push_back(E->getValue());

2163 Record.AddStmt(E->getQueriedExpression());

2165}

2166

2167void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {

2168 VisitExpr(E);

2169 Record.push_back(E->getValue());

2171 Record.AddStmt(E->getOperand());

2173}

2174

2176 VisitExpr(E);

2177 Record.AddSourceLocation(E->getEllipsisLoc());

2178 Record.push_back(E->NumExpansions);

2179 Record.AddStmt(E->getPattern());

2181}

2182

2183void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {

2184 VisitExpr(E);

2185 Record.push_back(E->isPartiallySubstituted() ? E->getPartialArguments().size()

2186 : 0);

2187 Record.AddSourceLocation(E->OperatorLoc);

2188 Record.AddSourceLocation(E->PackLoc);

2189 Record.AddSourceLocation(E->RParenLoc);

2190 Record.AddDeclRef(E->Pack);

2191 if (E->isPartiallySubstituted()) {

2192 for (const auto &TA : E->getPartialArguments())

2193 Record.AddTemplateArgument(TA);

2195 Record.push_back(E->getPackLength());

2196 }

2198}

2199

2201 VisitExpr(E);

2202 Record.push_back(E->TransformedExpressions);

2203 Record.push_back(E->FullySubstituted);

2204 Record.AddSourceLocation(E->getEllipsisLoc());

2205 Record.AddSourceLocation(E->getRSquareLoc());

2206 Record.AddStmt(E->getPackIdExpression());

2207 Record.AddStmt(E->getIndexExpr());

2208 for (Expr *Sub : E->getExpressions())

2209 Record.AddStmt(Sub);

2211}

2212

2213void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(

2215 VisitExpr(E);

2216 Record.AddDeclRef(E->getAssociatedDecl());

2217 CurrentPackingBits.addBit(E->isReferenceParameter());

2218 CurrentPackingBits.addBits(E->getIndex(), 12);

2219 CurrentPackingBits.addBit((bool)E->getPackIndex());

2220 if (auto PackIndex = E->getPackIndex())

2221 Record.push_back(*PackIndex + 1);

2222

2223 Record.AddSourceLocation(E->getNameLoc());

2224 Record.AddStmt(E->getReplacement());

2226}

2227

2228void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(

2230 VisitExpr(E);

2231 Record.AddDeclRef(E->getAssociatedDecl());

2232 Record.push_back(E->getIndex());

2233 Record.AddTemplateArgument(E->getArgumentPack());

2234 Record.AddSourceLocation(E->getParameterPackLocation());

2236}

2237

2239 VisitExpr(E);

2240 Record.push_back(E->getNumExpansions());

2241 Record.AddDeclRef(E->getParameterPack());

2242 Record.AddSourceLocation(E->getParameterPackLocation());

2244 I != End; ++I)

2245 Record.AddDeclRef(*I);

2247}

2248

2250 VisitExpr(E);

2251 Record.push_back(static_cast<bool>(E->getLifetimeExtendedTemporaryDecl()));

2252 if (E->getLifetimeExtendedTemporaryDecl())

2253 Record.AddDeclRef(E->getLifetimeExtendedTemporaryDecl());

2254 else

2255 Record.AddStmt(E->getSubExpr());

2257}

2258

2259void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {

2260 VisitExpr(E);

2261 Record.AddSourceLocation(E->LParenLoc);

2262 Record.AddSourceLocation(E->EllipsisLoc);

2263 Record.AddSourceLocation(E->RParenLoc);

2264 Record.push_back(E->NumExpansions);

2265 Record.AddStmt(E->SubExprs[0]);

2266 Record.AddStmt(E->SubExprs[1]);

2267 Record.AddStmt(E->SubExprs[2]);

2268 Record.push_back(E->Opcode);

2270}

2271

2273 VisitExpr(E);

2275 Record.push_back(InitExprs.size());

2276 Record.push_back(E->getUserSpecifiedInitExprs().size());

2277 Record.AddSourceLocation(E->getInitLoc());

2280 for (Expr *InitExpr : E->getInitExprs())

2281 Record.AddStmt(InitExpr);

2282 Expr *ArrayFiller = E->getArrayFiller();

2283 FieldDecl *UnionField = E->getInitializedFieldInUnion();

2284 bool HasArrayFillerOrUnionDecl = ArrayFiller || UnionField;

2285 Record.push_back(HasArrayFillerOrUnionDecl);

2286 if (HasArrayFillerOrUnionDecl) {

2287 Record.push_back(static_cast<bool>(ArrayFiller));

2288 if (ArrayFiller)

2289 Record.AddStmt(ArrayFiller);

2290 else

2291 Record.AddDeclRef(UnionField);

2292 }

2294}

2295

2296void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {

2297 VisitExpr(E);

2298 Record.AddStmt(E->getSourceExpr());

2299 Record.AddSourceLocation(E->getLocation());

2300 Record.push_back(E->isUnique());

2302}

2303

2304void ASTStmtWriter::VisitTypoExpr(TypoExpr *E) {

2305 VisitExpr(E);

2306

2307 llvm_unreachable("Cannot write TypoExpr nodes");

2308}

2309

2310

2311

2312

2313

2315 VisitCallExpr(E);

2316 Record.AddStmt(E->getConfig());

2318}

2319

2320

2321

2322

2323void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {

2324 VisitExpr(E);

2325 Record.AddSourceLocation(E->getBuiltinLoc());

2326 Record.AddSourceLocation(E->getRParenLoc());

2327 Record.AddStmt(E->getSrcExpr());

2329}

2330

2331

2332

2333

2335 VisitExpr(E);

2336 Record.push_back(E->isArrow());

2337 Record.AddStmt(E->getBaseExpr());

2338 Record.AddNestedNameSpecifierLoc(E->getQualifierLoc());

2339 Record.AddSourceLocation(E->getMemberLoc());

2340 Record.AddDeclRef(E->getPropertyDecl());

2342}

2343

2345 VisitExpr(E);

2346 Record.AddStmt(E->getBase());

2347 Record.AddStmt(E->getIdx());

2348 Record.AddSourceLocation(E->getRBracketLoc());

2350}

2351

2352void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {

2353 VisitExpr(E);

2355 Record.AddDeclRef(E->getGuidDecl());

2356 if (E->isTypeOperand()) {

2357 Record.AddTypeSourceInfo(E->getTypeOperandSourceInfo());

2359 } else {

2360 Record.AddStmt(E->getExprOperand());

2362 }

2363}

2364

2365void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {

2367 Record.AddSourceLocation(S->getExceptLoc());

2368 Record.AddStmt(S->getFilterExpr());

2369 Record.AddStmt(S->getBlock());

2371}

2372

2373void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {

2375 Record.AddSourceLocation(S->getFinallyLoc());

2376 Record.AddStmt(S->getBlock());

2378}

2379

2380void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {

2382 Record.push_back(S->getIsCXXTry());

2383 Record.AddSourceLocation(S->getTryLoc());

2384 Record.AddStmt(S->getTryBlock());

2385 Record.AddStmt(S->getHandler());

2387}

2388

2389void ASTStmtWriter::VisitSEHLeaveStmt(SEHLeaveStmt *S) {

2391 Record.AddSourceLocation(S->getLeaveLoc());

2393}

2394

2395

2396

2397

2398

2399void ASTStmtWriter::VisitOMPCanonicalLoop(OMPCanonicalLoop *S) {

2401 for (Stmt *SubStmt : S->SubStmts)

2402 Record.AddStmt(SubStmt);

2404}

2405

2407 Record.writeOMPChildren(E->Data);

2410}

2411

2414 Record.writeUInt32(D->getLoopsNumber());

2415 VisitOMPExecutableDirective(D);

2416}

2417

2419 VisitOMPLoopBasedDirective(D);

2420}

2421

2424 Record.push_back(D->getNumClauses());

2425 VisitOMPExecutableDirective(D);

2427}

2428

2431 VisitOMPExecutableDirective(D);

2432 Record.writeBool(D->hasCancel());

2434}

2435

2437 VisitOMPLoopDirective(D);

2439}

2440

2441void ASTStmtWriter::VisitOMPLoopTransformationDirective(

2443 VisitOMPLoopBasedDirective(D);

2444 Record.writeUInt32(D->getNumGeneratedLoops());

2445}

2446

2448 VisitOMPLoopTransformationDirective(D);

2450}

2451

2453 VisitOMPLoopTransformationDirective(D);

2455}

2456

2458 VisitOMPLoopTransformationDirective(D);

2460}

2461

2463 VisitOMPLoopTransformationDirective(D);

2465}

2466

2467void ASTStmtWriter::VisitOMPForDirective(OMPForDirective *D) {

2468 VisitOMPLoopDirective(D);

2469 Record.writeBool(D->hasCancel());

2471}

2472

2474 VisitOMPLoopDirective(D);

2476}

2477

2480 VisitOMPExecutableDirective(D);

2481 Record.writeBool(D->hasCancel());

2483}

2484

2487 VisitOMPExecutableDirective(D);

2488 Record.writeBool(D->hasCancel());

2490}

2491

2494 VisitOMPExecutableDirective(D);

2496}

2497

2500 VisitOMPExecutableDirective(D);

2502}

2503

2506 VisitOMPExecutableDirective(D);

2508}

2509

2512 VisitOMPExecutableDirective(D);

2513 Record.AddDeclarationNameInfo(D->getDirectiveName());

2515}

2516

2518 VisitOMPLoopDirective(D);

2519 Record.writeBool(D->hasCancel());

2521}

2522

2523void ASTStmtWriter::VisitOMPParallelForSimdDirective(

2525 VisitOMPLoopDirective(D);

2527}

2528

2529void ASTStmtWriter::VisitOMPParallelMasterDirective(

2532 VisitOMPExecutableDirective(D);

2534}

2535

2536void ASTStmtWriter::VisitOMPParallelMaskedDirective(

2539 VisitOMPExecutableDirective(D);

2541}

2542

2543void ASTStmtWriter::VisitOMPParallelSectionsDirective(

2546 VisitOMPExecutableDirective(D);

2547 Record.writeBool(D->hasCancel());

2549}

2550

2553 VisitOMPExecutableDirective(D);

2554 Record.writeBool(D->hasCancel());

2556}

2557

2560 VisitOMPExecutableDirective(D);

2561 Record.writeBool(D->isXLHSInRHSPart());

2562 Record.writeBool(D->isPostfixUpdate());

2563 Record.writeBool(D->isFailOnly());

2565}

2566

2569 VisitOMPExecutableDirective(D);

2571}

2572

2575 VisitOMPExecutableDirective(D);

2577}

2578

2579void ASTStmtWriter::VisitOMPTargetEnterDataDirective(

2582 VisitOMPExecutableDirective(D);

2584}

2585

2586void ASTStmtWriter::VisitOMPTargetExitDataDirective(

2589 VisitOMPExecutableDirective(D);

2591}

2592

2593void ASTStmtWriter::VisitOMPTargetParallelDirective(

2596 VisitOMPExecutableDirective(D);

2597 Record.writeBool(D->hasCancel());

2599}

2600

2601void ASTStmtWriter::VisitOMPTargetParallelForDirective(

2603 VisitOMPLoopDirective(D);

2604 Record.writeBool(D->hasCancel());

2606}

2607

2610 VisitOMPExecutableDirective(D);

2612}

2613

2616 VisitOMPExecutableDirective(D);

2618}

2619

2622 Record.push_back(D->getNumClauses());

2623 VisitOMPExecutableDirective(D);

2625}

2626

2629 VisitOMPExecutableDirective(D);

2631}

2632

2635 Record.push_back(D->getNumClauses());

2636 VisitOMPExecutableDirective(D);

2638}

2639

2642 VisitOMPExecutableDirective(D);

2644}

2645

2648 VisitOMPExecutableDirective(D);

2650}

2651

2654 VisitOMPExecutableDirective(D);

2656}

2657

2660 VisitOMPExecutableDirective(D);

2662}

2663

2666 VisitOMPExecutableDirective(D);

2668}

2669

2672 VisitOMPExecutableDirective(D);

2674}

2675

2676void ASTStmtWriter::VisitOMPCancellationPointDirective(

2679 VisitOMPExecutableDirective(D);

2680 Record.writeEnum(D->getCancelRegion());

2682}

2683

2686 VisitOMPExecutableDirective(D);

2687 Record.writeEnum(D->getCancelRegion());

2689}

2690

2692 VisitOMPLoopDirective(D);

2693 Record.writeBool(D->hasCancel());

2695}

2696

2698 VisitOMPLoopDirective(D);

2700}

2701

2702void ASTStmtWriter::VisitOMPMasterTaskLoopDirective(

2704 VisitOMPLoopDirective(D);

2705 Record.writeBool(D->hasCancel());

2707}

2708

2709void ASTStmtWriter::VisitOMPMaskedTaskLoopDirective(

2711 VisitOMPLoopDirective(D);

2712 Record.writeBool(D->hasCancel());

2714}

2715

2716void ASTStmtWriter::VisitOMPMasterTaskLoopSimdDirective(

2718 VisitOMPLoopDirective(D);

2720}

2721

2722void ASTStmtWriter::VisitOMPMaskedTaskLoopSimdDirective(

2724 VisitOMPLoopDirective(D);

2726}

2727

2728void ASTStmtWriter::VisitOMPParallelMasterTaskLoopDirective(

2730 VisitOMPLoopDirective(D);

2731 Record.writeBool(D->hasCancel());

2733}

2734

2735void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopDirective(

2737 VisitOMPLoopDirective(D);

2738 Record.writeBool(D->hasCancel());

2740}

2741

2742void ASTStmtWriter::VisitOMPParallelMasterTaskLoopSimdDirective(

2744 VisitOMPLoopDirective(D);

2746}

2747

2748void ASTStmtWriter::VisitOMPParallelMaskedTaskLoopSimdDirective(

2750 VisitOMPLoopDirective(D);

2752}

2753

2755 VisitOMPLoopDirective(D);

2757}

2758

2761 VisitOMPExecutableDirective(D);

2763}

2764

2765void ASTStmtWriter::VisitOMPDistributeParallelForDirective(

2767 VisitOMPLoopDirective(D);

2768 Record.writeBool(D->hasCancel());

2770}

2771

2772void ASTStmtWriter::VisitOMPDistributeParallelForSimdDirective(

2774 VisitOMPLoopDirective(D);

2776}

2777

2778void ASTStmtWriter::VisitOMPDistributeSimdDirective(

2780 VisitOMPLoopDirective(D);

2782}

2783

2784void ASTStmtWriter::VisitOMPTargetParallelForSimdDirective(

2786 VisitOMPLoopDirective(D);

2788}

2789

2791 VisitOMPLoopDirective(D);

2793}

2794

2795void ASTStmtWriter::VisitOMPTeamsDistributeDirective(

2797 VisitOMPLoopDirective(D);

2799}

2800

2801void ASTStmtWriter::VisitOMPTeamsDistributeSimdDirective(

2803 VisitOMPLoopDirective(D);

2805}

2806

2807void ASTStmtWriter::VisitOMPTeamsDistributeParallelForSimdDirective(

2809 VisitOMPLoopDirective(D);

2811}

2812

2813void ASTStmtWriter::VisitOMPTeamsDistributeParallelForDirective(

2815 VisitOMPLoopDirective(D);

2816 Record.writeBool(D->hasCancel());

2818}

2819

2822 VisitOMPExecutableDirective(D);

2824}

2825

2826void ASTStmtWriter::VisitOMPTargetTeamsDistributeDirective(

2828 VisitOMPLoopDirective(D);

2830}

2831

2832void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForDirective(

2834 VisitOMPLoopDirective(D);

2835 Record.writeBool(D->hasCancel());

2837}

2838

2839void ASTStmtWriter::VisitOMPTargetTeamsDistributeParallelForSimdDirective(

2841 VisitOMPLoopDirective(D);

2844}

2845

2846void ASTStmtWriter::VisitOMPTargetTeamsDistributeSimdDirective(

2848 VisitOMPLoopDirective(D);

2850}

2851

2854 VisitOMPExecutableDirective(D);

2856}

2857

2860 VisitOMPExecutableDirective(D);

2861 Record.AddSourceLocation(D->getTargetCallLoc());

2863}

2864

2867 VisitOMPExecutableDirective(D);

2869}

2870

2872 VisitOMPLoopDirective(D);

2874}

2875

2876void ASTStmtWriter::VisitOMPTeamsGenericLoopDirective(

2878 VisitOMPLoopDirective(D);

2880}

2881

2882void ASTStmtWriter::VisitOMPTargetTeamsGenericLoopDirective(

2884 VisitOMPLoopDirective(D);

2885 Record.writeBool(D->canBeParallelFor());

2887}

2888

2889void ASTStmtWriter::VisitOMPParallelGenericLoopDirective(

2891 VisitOMPLoopDirective(D);

2893}

2894

2895void ASTStmtWriter::VisitOMPTargetParallelGenericLoopDirective(

2897 VisitOMPLoopDirective(D);

2899}

2900

2901

2902

2903

2905 Record.push_back(S->clauses().size());

2906 Record.writeEnum(S->Kind);

2907 Record.AddSourceRange(S->Range);

2908 Record.AddSourceLocation(S->DirectiveLoc);

2909 Record.writeOpenACCClauseList(S->clauses());

2910}

2911

2912void ASTStmtWriter::VisitOpenACCAssociatedStmtConstruct(

2914 VisitOpenACCConstructStmt(S);

2915 Record.AddStmt(S->getAssociatedStmt());

2916}

2917

2920 VisitOpenACCAssociatedStmtConstruct(S);

2922}

2923

2926 VisitOpenACCAssociatedStmtConstruct(S);

2927 Record.writeEnum(S->getParentComputeConstructKind());

2929}

2930

2933 VisitOpenACCAssociatedStmtConstruct(S);

2935}

2936

2939 VisitOpenACCAssociatedStmtConstruct(S);

2941}

2942

2943void ASTStmtWriter::VisitOpenACCEnterDataConstruct(

2946 VisitOpenACCConstructStmt(S);

2948}

2949

2952 VisitOpenACCConstructStmt(S);

2954}

2955

2958 VisitOpenACCConstructStmt(S);

2960}

2961

2964 VisitOpenACCConstructStmt(S);

2966}

2967

2970 VisitOpenACCConstructStmt(S);

2972}

2973

2976 VisitOpenACCConstructStmt(S);

2978}

2979

2982 VisitOpenACCAssociatedStmtConstruct(S);

2984}

2985

2988 Record.push_back(S->getExprs().size());

2989 VisitOpenACCConstructStmt(S);

2990 Record.AddSourceLocation(S->LParenLoc);

2991 Record.AddSourceLocation(S->RParenLoc);

2992 Record.AddSourceLocation(S->QueuesLoc);

2993

2994 for(Expr *E : S->getExprs())

2996

2998}

2999

3000

3001

3002

3003

3004void ASTStmtWriter::VisitHLSLOutArgExpr(HLSLOutArgExpr *S) {

3005 VisitExpr(S);

3006 Record.AddStmt(S->getOpaqueArgLValue());

3007 Record.AddStmt(S->getCastedTemporary());

3008 Record.AddStmt(S->getWritebackCast());

3009 Record.writeBool(S->isInOut());

3011}

3012

3013

3014

3015

3016

3018 assert(!SwitchCaseIDs.contains(S) && "SwitchCase recorded twice");

3019 unsigned NextID = SwitchCaseIDs.size();

3020 SwitchCaseIDs[S] = NextID;

3021 return NextID;

3022}

3023

3025 assert(SwitchCaseIDs.contains(S) && "SwitchCase hasn't been seen yet");

3026 return SwitchCaseIDs[S];

3027}

3028

3030 SwitchCaseIDs.clear();

3031}

3032

3033

3034

3035void ASTWriter::WriteSubStmt(ASTContext &Context, Stmt *S) {

3038 ++NumStatements;

3039

3040 if (!S) {

3042 return;

3043 }

3044

3045 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);

3046 if (I != SubStmtEntries.end()) {

3047 Record.push_back(I->second);

3049 return;

3050 }

3051

3052#ifndef NDEBUG

3053 assert(!ParentStmts.count(S) && "There is a Stmt cycle!");

3054

3055 struct ParentStmtInserterRAII {

3057 llvm::DenseSet<Stmt *> &ParentStmts;

3058

3059 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)

3060 : S(S), ParentStmts(ParentStmts) {

3061 ParentStmts.insert(S);

3062 }

3063 ~ParentStmtInserterRAII() {

3064 ParentStmts.erase(S);

3065 }

3066 };

3067

3068 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);

3069#endif

3070

3071 Writer.Visit(S);

3072

3073 uint64_t Offset = Writer.Emit();

3074 SubStmtEntries[S] = Offset;

3075}

3076

3077

3078

3079void ASTRecordWriter::FlushStmts() {

3080

3081

3082 assert(Writer->SubStmtEntries.empty() && "unexpected entries in sub-stmt map");

3083 assert(Writer->ParentStmts.empty() && "unexpected entries in parent stmt map");

3084

3085 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {

3086 Writer->WriteSubStmt(getASTContext(), StmtsToEmit[I]);

3087

3088 assert(N == StmtsToEmit.size() && "record modified while being written!");

3089

3090

3091

3092

3094

3095 Writer->SubStmtEntries.clear();

3096 Writer->ParentStmts.clear();

3097 }

3098

3099 StmtsToEmit.clear();

3100}

3101

3102void ASTRecordWriter::FlushSubStmts() {

3103

3104

3105

3106 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {

3107 Writer->WriteSubStmt(getASTContext(), StmtsToEmit[N - I - 1]);

3108 assert(N == StmtsToEmit.size() && "record modified while being written!");

3109 }

3110

3111 StmtsToEmit.clear();

3112}

This file provides AST data structures related to concepts.

Defines the clang::ASTContext interface.

static void addConstraintSatisfaction(ASTRecordWriter &Record, const ASTConstraintSatisfaction &Satisfaction)

static void addSubstitutionDiagnostic(ASTRecordWriter &Record, const concepts::Requirement::SubstitutionDiagnostic *D)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the C++ template declaration subclasses.

static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)

Produce a diagnostic highlighting some portion of a literal.

llvm::MachO::Record Record

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

void ReadKnownNamespaces(SmallVectorImpl< NamespaceDecl * > &Namespaces) override

Load the set of namespaces that are known to the external source, which will be used during typo corr...

An object for streaming information to a record.

void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &ArgInfo, const TemplateArgumentLoc *Args)

ASTStmtWriter(const ASTStmtWriter &)=delete

ASTStmtWriter & operator=(const ASTStmtWriter &)=delete

ASTStmtWriter(ASTContext &Context, ASTWriter &Writer, ASTWriter::RecordData &Record)

Writes an AST file containing the contents of a translation unit.

unsigned getBinaryOperatorAbbrev() const

bool isWritingStdCXXNamedModules() const

unsigned getExprImplicitCastAbbrev() const

unsigned getSwitchCaseID(SwitchCase *S)

Retrieve the ID for the given switch-case statement.

unsigned getDeclRefExprAbbrev() const

unsigned getCXXOperatorCallExprAbbrev()

void ClearSwitchCaseIDs()

LocalDeclID GetDeclRef(const Decl *D)

Force a declaration to be emitted and get its local ID to the module file been writing.

unsigned getCXXMemberCallExprAbbrev()

ASTReader * getChain() const

unsigned getCompoundAssignOperatorAbbrev() const

unsigned RecordSwitchCaseID(SwitchCase *S)

Record an ID for the given switch-case statement.

unsigned getCharacterLiteralAbbrev() const

unsigned getCompoundStmtAbbrev() const

void AddToken(const Token &Tok, RecordDataImpl &Record)

Emit a token.

SmallVector< uint64_t, 64 > RecordData

unsigned getCallExprAbbrev() const

unsigned getIntegerLiteralAbbrev() const

AddrLabelExpr - The GNU address of label extension, representing &&label.

Represents the index of the current element of an array being initialized by an ArrayInitLoopExpr.

Represents a loop initializing the elements of an array.

This class represents BOTH the OpenMP Array Section and OpenACC 'subarray', with a boolean differenti...

ArraySubscriptExpr - [C99 6.5.2.1] Array Subscripting.

An Embarcadero array type trait, as used in the implementation of __array_rank and __array_extent.

AsTypeExpr - Clang builtin function __builtin_astype [OpenCL 6.2.4.2] This AST node provides support ...

AsmStmt is the base class for GCCAsmStmt and MSAsmStmt.

AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*, __atomic_load,...

Represents an attribute applied to a statement.

BinaryConditionalOperator - The GNU extension to the conditional operator which allows the middle ope...

A builtin binary operation expression such as "x + y" or "x <= y".

A simple helper class to pack several bits in order into (a) 32 bit integer(s).

Represents a block literal declaration, which is like an unnamed FunctionDecl.

BlockExpr - Adaptor class for mixing a BlockDecl with expressions.

BreakStmt - This represents a break.

Represents a C++2a __builtin_bit_cast(T, v) expression.

CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr....

Represents a call to a CUDA kernel function.

A C++ addrspace_cast expression (currently only enabled for OpenCL).

Represents a base class of a C++ class.

Represents binding an expression to a temporary.

A boolean literal, per ([C++ lex.bool] Boolean literals).

CXXCatchStmt - This represents a C++ catch block.

A C++ const_cast expression (C++ [expr.const.cast]).

Represents a call to a C++ constructor.

A default argument (C++ [dcl.fct.default]).

A use of a default initializer in a constructor or in aggregate initialization.

Represents a delete expression for memory deallocation and destructor calls, e.g.

Represents a C++ member access expression where the actual member referenced could not be resolved be...

A C++ dynamic_cast expression (C++ [expr.dynamic.cast]).

Represents a folding of a pack over an operator.

CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for statement, represented as 'for (ra...

Represents an explicit C++ type conversion that uses "functional" notation (C++ [expr....

Represents a call to an inherited base class constructor from an inheriting constructor.

Represents a call to a member function that may be written either with member call syntax (e....

Abstract class common to all of the C++ "named"/"keyword" casts.

Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".

Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).

The null pointer literal (C++11 [lex.nullptr])

A call to an overloaded operator written using operator syntax.

Represents a list-initialization with parenthesis.

Represents a C++ pseudo-destructor (C++ [expr.pseudo]).

A C++ reinterpret_cast expression (C++ [expr.reinterpret.cast]).

A rewritten comparison expression that was originally written using operator syntax.

An expression "T()" which creates an rvalue of a non-class type T.

A C++ static_cast expression (C++ [expr.static.cast]).

Implicit construction of a std::initializer_list object from an array temporary within list-initia...

Represents a C++ functional cast expression that builds a temporary object.

Represents the this expression in C++.

A C++ throw-expression (C++ [except.throw]).

CXXTryStmt - A C++ try block, including all handlers.

A C++ typeid expression (C++ [expr.typeid]), which gets the type_info that corresponds to the supplie...

Describes an explicit type conversion that uses functional notion but could not be resolved because o...

A Microsoft C++ __uuidof expression, which gets the _GUID that corresponds to the supplied type or ex...

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

This captures a statement into a function.

CaseStmt - Represent a case statement.

CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...

ChooseExpr - GNU builtin-in function __builtin_choose_expr.

Represents a 'co_await' expression.

CompoundAssignOperator - For compound assignments (e.g.

CompoundLiteralExpr - [C99 6.5.2.5].

CompoundStmt - This represents a group of statements like { stmt stmt }.

A reference to a concept and its template args, as it appears in the code.

Represents the specialization of a concept - evaluates to a prvalue of type bool.

ConditionalOperator - The ?: ternary operator.

ConstantExpr - An expression that occurs in a constant context and optionally the result of evaluatin...

ContinueStmt - This represents a continue.

ConvertVectorExpr - Clang builtin function __builtin_convertvector This AST node provides support for...

Represents a 'co_return' statement in the C++ Coroutines TS.

Represents the body of a coroutine.

ArrayRef< Stmt const * > getParamMoves() const

Represents an expression that might suspend coroutine execution; either a co_await or co_yield expres...

Represents a 'co_yield' expression.

A POD class for pairing a NamedDecl* with an access specifier.

A reference to a declared variable, function, enum, etc.

DeclStmt - Adaptor class for mixing declarations with statements and expressions.

Decl - This represents one declaration (or definition), e.g.

AccessSpecifier getAccess() const

The name of a declaration.

NameKind

The kind of the name stored in this DeclarationName.

Represents a 'co_await' expression while the type of the promise is dependent.

A qualified reference to a name whose declaration cannot yet be resolved.

Represents a single C99 designator.

Represents a C99 designated initializer expression.

DoStmt - This represents a 'do/while' stmt.

Represents a reference to #emded data.

ExplicitCastExpr - An explicit cast written in the source code.

Represents an expression – generally a full-expression – that introduces cleanups to be run at the en...

This represents one expression.

bool isValueDependent() const

Determines whether the value of this expression depends on.

ExprValueKind getValueKind() const

getValueKind - The value kind that this expression produces.

ExprObjectKind getObjectKind() const

getObjectKind - The object kind that this expression produces.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

ExprDependence getDependence() const

An expression trait intrinsic.

ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...

Represents a member of a struct/union/class.

ForStmt - This represents a 'for (init;cond;inc)' stmt.

Represents a reference to a function parameter pack or init-capture pack that has been substituted bu...

VarDecl *const * iterator

Iterators over the parameters which the parameter pack expanded into.

This represents a GCC inline-assembly statement extension.

GNUNullExpr - Implements the GNU __null extension, which is a name for a null pointer constant that h...

Represents a C11 generic selection.

GotoStmt - This represents a direct goto.

This class represents temporary values used to represent inout and out arguments in HLSL.

IfStmt - This represents an if/then/else.

ImaginaryLiteral - We support imaginary integer and floating point literals, like "1....

ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...

Represents an implicitly-generated value initialization of an object of a given type.

IndirectGotoStmt - This represents an indirect goto.

Describes an C or C++ initializer list.

LabelStmt - Represents a label, which has a substatement.

A C++ lambda expression, which produces a function object (of unspecified type) that can be invoked l...

This represents a Microsoft inline-assembly statement extension.

Representation of a Microsoft __if_exists or __if_not_exists statement with a dependent name.

A member reference to an MSPropertyDecl.

MS property subscript expression.

Represents a prvalue temporary that is written into memory so that a reference can bind to it.

MatrixSubscriptExpr - Matrix subscript expression for the MatrixType extension.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

Represents a place-holder for an object not to be initialized by anything.

NullStmt - This is the null statement ";": C99 6.8.3p3.

An explicit cast in C or a C-style cast in C++, which uses the syntax ([s1][s2]......

This represents '#pragma omp atomic' directive.

This represents '#pragma omp barrier' directive.

This represents '#pragma omp cancel' directive.

This represents '#pragma omp cancellation point' directive.

Representation of an OpenMP canonical loop.

This represents '#pragma omp critical' directive.

This represents '#pragma omp depobj' directive.

This represents '#pragma omp dispatch' directive.

This represents '#pragma omp distribute' directive.

This represents '#pragma omp distribute parallel for' composite directive.

This represents '#pragma omp distribute parallel for simd' composite directive.

This represents '#pragma omp distribute simd' composite directive.

This represents '#pragma omp error' directive.

This is a basic class for representing single OpenMP executable directive.

This represents '#pragma omp flush' directive.

This represents '#pragma omp for' directive.

This represents '#pragma omp for simd' directive.

This represents '#pragma omp loop' directive.

Represents the '#pragma omp interchange' loop transformation directive.

This represents '#pragma omp interop' directive.

OpenMP 5.0 [2.1.6 Iterators] Iterators are identifiers that expand to multiple values in the clause o...

The base class for all loop-based directives, including loop transformation directives.

This is a common base class for loop directives ('omp simd', 'omp for', 'omp for simd' etc....

The base class for all loop transformation directives.

This represents '#pragma omp masked' directive.

This represents '#pragma omp masked taskloop' directive.

This represents '#pragma omp masked taskloop simd' directive.

This represents '#pragma omp master' directive.

This represents '#pragma omp master taskloop' directive.

This represents '#pragma omp master taskloop simd' directive.

This represents '#pragma omp ordered' directive.

This represents '#pragma omp parallel' directive.

This represents '#pragma omp parallel for' directive.

This represents '#pragma omp parallel for simd' directive.

This represents '#pragma omp parallel loop' directive.

This represents '#pragma omp parallel masked' directive.

This represents '#pragma omp parallel masked taskloop' directive.

This represents '#pragma omp parallel masked taskloop simd' directive.

This represents '#pragma omp parallel master' directive.

This represents '#pragma omp parallel master taskloop' directive.

This represents '#pragma omp parallel master taskloop simd' directive.

This represents '#pragma omp parallel sections' directive.

Represents the '#pragma omp reverse' loop transformation directive.

This represents '#pragma omp scan' directive.

This represents '#pragma omp scope' directive.

This represents '#pragma omp section' directive.

This represents '#pragma omp sections' directive.

This represents '#pragma omp simd' directive.

This represents '#pragma omp single' directive.

This represents '#pragma omp target data' directive.

This represents '#pragma omp target' directive.

This represents '#pragma omp target enter data' directive.

This represents '#pragma omp target exit data' directive.

This represents '#pragma omp target parallel' directive.

This represents '#pragma omp target parallel for' directive.

This represents '#pragma omp target parallel for simd' directive.

This represents '#pragma omp target parallel loop' directive.

This represents '#pragma omp target simd' directive.

This represents '#pragma omp target teams' directive.

This represents '#pragma omp target teams distribute' combined directive.

This represents '#pragma omp target teams distribute parallel for' combined directive.

This represents '#pragma omp target teams distribute parallel for simd' combined directive.

This represents '#pragma omp target teams distribute simd' combined directive.

This represents '#pragma omp target teams loop' directive.

This represents '#pragma omp target update' directive.

This represents '#pragma omp task' directive.

This represents '#pragma omp taskloop' directive.

This represents '#pragma omp taskloop simd' directive.

This represents '#pragma omp taskgroup' directive.

This represents '#pragma omp taskwait' directive.

This represents '#pragma omp taskyield' directive.

This represents '#pragma omp teams' directive.

This represents '#pragma omp teams distribute' directive.

This represents '#pragma omp teams distribute parallel for' composite directive.

This represents '#pragma omp teams distribute parallel for simd' composite directive.

This represents '#pragma omp teams distribute simd' combined directive.

This represents '#pragma omp teams loop' directive.

This represents the '#pragma omp tile' loop transformation directive.

This represents the '#pragma omp unroll' loop transformation directive.

ObjCArrayLiteral - used for objective-c array containers; as in: @["Hello", NSApp,...

Represents Objective-C's @catch statement.

Represents Objective-C's @finally statement.

Represents Objective-C's @synchronized statement.

Represents Objective-C's @throw statement.

Represents Objective-C's @try ... @catch ... @finally statement.

Represents Objective-C's @autoreleasepool Statement.

A runtime availability query.

ObjCBoolLiteralExpr - Objective-C Boolean Literal.

ObjCBoxedExpr - used for generalized expression boxing.

An Objective-C "bridged" cast expression, which casts between Objective-C pointers and C pointers,...

ObjCDictionaryLiteral - AST node to represent objective-c dictionary literals; as in:"name" : NSUserN...

ObjCEncodeExpr, used for @encode in Objective-C.

Represents Objective-C's collection statement.

ObjCIndirectCopyRestoreExpr - Represents the passing of a function argument by indirect copy-restore ...

ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.

ObjCIvarRefExpr - A reference to an ObjC instance variable.

An expression that sends a message to the given Objective-C object or class.

@ SuperInstance

The receiver is the instance of the superclass object.

@ Instance

The receiver is an object instance.

@ SuperClass

The receiver is a superclass.

@ Class

The receiver is a class.

ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.

ObjCProtocolExpr used for protocol expression in Objective-C.

ObjCSelectorExpr used for @selector in Objective-C.

ObjCStringLiteral, used for Objective-C string literals i.e.

ObjCSubscriptRefExpr - used for array and dictionary subscripting.

OffsetOfExpr - [C99 7.17] - This represents an expression of the form offsetof(record-type,...

Helper class for OffsetOfExpr.

unsigned getArrayExprIndex() const

For an array element node, returns the index into the array of expressions.

FieldDecl * getField() const

For a field offsetof node, returns the field.

IdentifierInfo * getFieldName() const

For a field or identifier offsetof node, returns the name of the field.

SourceRange getSourceRange() const LLVM_READONLY

Retrieve the source range that covers this offsetof node.

@ Array

An index into an array.

@ Identifier

A field in a dependent type, known only by its name.

@ Base

An implicit indirection through a C++ base class, when the field found is in a base class.

Kind getKind() const

Determine what kind of offsetof node this is.

CXXBaseSpecifier * getBase() const

For a base class node, returns the base specifier.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

This is a base class for any OpenACC statement-level constructs that have an associated statement.

This expression type represents an asterisk in an OpenACC Size-Expr, used in the 'tile' and 'gang' cl...

This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...

This is the base class for an OpenACC statement-level construct, other construct types are expected t...

This class represents a 'loop' construct.

A reference to an overloaded function set, either an UnresolvedLookupExpr or an UnresolvedMemberExpr.

Represents a C++11 pack expansion that produces a sequence of expressions.

ParenExpr - This represents a parenthesized expression, e.g.

Represents a parameter to a function.

[C99 6.4.2.2] - A predefined identifier such as func.

PseudoObjectExpr - An expression which accesses a pseudo-object l-value.

Expr *const * semantics_iterator

Frontend produces RecoveryExprs on semantic errors that prevent creating other well-formed expression...

C++2a [expr.prim.req]: A requires-expression provides a concise way to express requirements on templa...

ReturnStmt - This represents a return, optionally of an expression: return; return 4;.

Represents a __leave statement.

SYCLKernelCallStmt represents the transformation that is applied to the body of a function declared w...

static std::enable_if_t< std::is_base_of_v< Attr, AttrInfo >, SourceLocation > getAttrLoc(const AttrInfo &AL)

A helper function to provide Attribute Location for the Attr types AND the ParsedAttr.

ShuffleVectorExpr - clang-specific builtin-in function __builtin_shufflevector.

Represents an expression that computes the length of a parameter pack.

Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(), __builtin_FUNCTION(),...

Encodes a location in the source.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

StmtExpr - This is the GNU Statement Expression extension: ({int X=4; X;}).

StmtVisitor - This class implements a simple visitor for Stmt subclasses.

Stmt - This represents one statement.

SourceLocation getEndLoc() const LLVM_READONLY

LambdaExprBitfields LambdaExprBits

StmtClass getStmtClass() const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

TypeTraitExprBitfields TypeTraitExprBits

CXXNewExprBitfields CXXNewExprBits

ConstantExprBitfields ConstantExprBits

RequiresExprBitfields RequiresExprBits

DependentScopeDeclRefExprBitfields DependentScopeDeclRefExprBits

SourceLocation getBeginLoc() const LLVM_READONLY

void AddString(StringRef V) const

StringLiteral - This represents a string literal expression, e.g.

Represents a reference to a non-type template parameter that has been substituted with a template arg...

Represents a reference to a non-type template parameter pack that has been substituted with a non-tem...

SwitchStmt - This represents a 'switch' stmt.

Location wrapper for a TemplateArgument.

A container of type source information.

A type trait used in the implementation of various C++11 and Library TR1 trait templates.

TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...

UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand.

UnaryOperator - This represents the unary-expression's (except sizeof and alignof),...

A reference to a name which we were able to look up during parsing but could not resolve to a specifi...

Represents a C++ member access expression for which lookup produced a set of overloaded functions.

The iterator over UnresolvedSets.

A call to a literal operator (C++11 [over.literal]) written as a user-defined literal (C++11 [lit....

Represents a call to the builtin function __builtin_va_arg.

WhileStmt - This represents a 'while' stmt.

@ SS_ConstraintsNotSatisfied

A static requirement that can be used in a requires-expression to check properties of types and expre...

StmtCode

Record codes for each kind of statement or expression.

@ STMT_OMP_SECTION_DIRECTIVE

@ STMT_OPENACC_COMBINED_CONSTRUCT

@ EXPR_DESIGNATED_INIT

A DesignatedInitExpr record.

@ EXPR_COMPOUND_LITERAL

A CompoundLiteralExpr record.

@ STMT_OMP_ASSUME_DIRECTIVE

@ STMT_OPENACC_HOST_DATA_CONSTRUCT

@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE

@ EXPR_OBJC_IVAR_REF_EXPR

An ObjCIvarRefExpr record.

@ STMT_OMP_SCOPE_DIRECTIVE

@ STMT_OMP_PARALLEL_FOR_SIMD_DIRECTIVE

@ EXPR_MEMBER

A MemberExpr record.

@ STMT_OMP_TARGET_TEAMS_DIRECTIVE

@ EXPR_CXX_TEMPORARY_OBJECT

A CXXTemporaryObjectExpr record.

@ EXPR_CXX_UNRESOLVED_LOOKUP

@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE

@ EXPR_COMPOUND_ASSIGN_OPERATOR

A CompoundAssignOperator record.

@ EXPR_EXPR_WITH_CLEANUPS

@ EXPR_CXX_STATIC_CAST

A CXXStaticCastExpr record.

@ STMT_OMP_META_DIRECTIVE

@ EXPR_OBJC_STRING_LITERAL

An ObjCStringLiteral record.

@ EXPR_CXX_PROPERTY_REF_EXPR

@ EXPR_SYCL_UNIQUE_STABLE_NAME

@ STMT_OMP_TARGET_DATA_DIRECTIVE

@ STMT_OMP_BARRIER_DIRECTIVE

@ EXPR_VA_ARG

A VAArgExpr record.

@ STMT_OMP_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE

@ STMT_OPENACC_SHUTDOWN_CONSTRUCT

@ EXPR_OBJC_ISA

An ObjCIsa Expr record.

@ STMT_OMP_SINGLE_DIRECTIVE

@ STMT_OPENACC_EXIT_DATA_CONSTRUCT

@ EXPR_CXX_OPERATOR_CALL

A CXXOperatorCallExpr record.

@ STMT_OBJC_AT_TRY

An ObjCAtTryStmt record.

@ STMT_OMP_TARGET_EXIT_DATA_DIRECTIVE

@ EXPR_CXX_UNRESOLVED_CONSTRUCT

@ EXPR_FIXEDPOINT_LITERAL

@ STMT_DO

A DoStmt record.

@ STMT_OBJC_CATCH

An ObjCAtCatchStmt record.

@ STMT_OMP_TARGET_DIRECTIVE

@ STMT_IF

An IfStmt record.

@ EXPR_CXX_EXPRESSION_TRAIT

@ EXPR_STRING_LITERAL

A StringLiteral record.

@ EXPR_OBJC_AVAILABILITY_CHECK

An ObjCAvailabilityCheckExpr record.

@ STMT_OMP_PARALLEL_MASKED_TASKLOOP_DIRECTIVE

@ EXPR_PSEUDO_OBJECT

A PseudoObjectExpr record.

@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE

@ EXPR_IMPLICIT_CAST

An ImplicitCastExpr record.

@ STMT_OMP_FLUSH_DIRECTIVE

@ STMT_CAPTURED

A CapturedStmt record.

@ STMT_OMP_TARGET_PARALLEL_FOR_SIMD_DIRECTIVE

@ STMT_OMP_MASTER_TASKLOOP_DIRECTIVE

@ STMT_OMP_TILE_DIRECTIVE

@ STMT_OMP_CANCELLATION_POINT_DIRECTIVE

@ STMT_GCCASM

A GCC-style AsmStmt record.

@ EXPR_IMAGINARY_LITERAL

An ImaginaryLiteral record.

@ STMT_OMP_INTERCHANGE_DIRECTIVE

@ STMT_WHILE

A WhileStmt record.

@ EXPR_CONVERT_VECTOR

A ConvertVectorExpr record.

@ EXPR_OBJC_SUBSCRIPT_REF_EXPR

An ObjCSubscriptRefExpr record.

@ STMT_OPENACC_COMPUTE_CONSTRUCT

@ STMT_OMP_TASKWAIT_DIRECTIVE

@ STMT_OMP_TASKYIELD_DIRECTIVE

@ EXPR_STMT

A StmtExpr record.

@ STMT_OMP_PARALLEL_GENERIC_LOOP_DIRECTIVE

@ EXPR_CXX_REINTERPRET_CAST

A CXXReinterpretCastExpr record.

@ EXPR_DESIGNATED_INIT_UPDATE

A DesignatedInitUpdateExpr record.

@ STMT_OBJC_AT_SYNCHRONIZED

An ObjCAtSynchronizedStmt record.

@ STMT_OMP_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE

@ STMT_OMP_TASKLOOP_SIMD_DIRECTIVE

@ STMT_MS_DEPENDENT_EXISTS

@ EXPR_BUILTIN_BIT_CAST

A BuiltinBitCastExpr record.

@ EXPR_CXX_PROPERTY_SUBSCRIPT_EXPR

@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD_DIRECTIVE

@ EXPR_CXX_PSEUDO_DESTRUCTOR

@ STMT_OMP_MASKED_DIRECTIVE

@ STMT_SYCLKERNELCALL

A SYCLKernelCallStmt record.

@ STMT_OMP_TARGET_ENTER_DATA_DIRECTIVE

@ EXPR_CHARACTER_LITERAL

A CharacterLiteral record.

@ EXPR_OBJC_ENCODE

An ObjCEncodeExpr record.

@ STMT_OMP_PARALLEL_SECTIONS_DIRECTIVE

@ STMT_OMP_PARALLEL_FOR_DIRECTIVE

@ EXPR_CSTYLE_CAST

A CStyleCastExpr record.

@ STMT_OMP_PARALLEL_DIRECTIVE

@ EXPR_OBJC_BOXED_EXPRESSION

@ EXPR_OBJC_BOOL_LITERAL

An ObjCBoolLiteralExpr record.

@ EXPR_CXX_BIND_TEMPORARY

@ STMT_OMP_ATOMIC_DIRECTIVE

@ STMT_OMP_ORDERED_DIRECTIVE

@ EXPR_EXT_VECTOR_ELEMENT

An ExtVectorElementExpr record.

@ STMT_OMP_TEAMS_GENERIC_LOOP_DIRECTIVE

@ STMT_OMP_CRITICAL_DIRECTIVE

@ EXPR_ATOMIC

An AtomicExpr record.

@ STMT_OPENACC_ENTER_DATA_CONSTRUCT

@ STMT_OMP_CANCEL_DIRECTIVE

@ EXPR_OFFSETOF

An OffsetOfExpr record.

@ STMT_RETURN

A ReturnStmt record.

@ STMT_OBJC_FOR_COLLECTION

An ObjCForCollectionStmt record.

@ STMT_OMP_TARGET_TEAMS_DISTRIBUTE_DIRECTIVE

@ EXPR_ARRAY_INIT_LOOP

An ArrayInitLoopExpr record.

@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_DIRECTIVE

@ STMT_OMP_PARALLEL_MASKED_TASKLOOP_SIMD_DIRECTIVE

@ STMT_CONTINUE

A ContinueStmt record.

@ EXPR_PREDEFINED

A PredefinedExpr record.

@ EXPR_OPENACC_ASTERISK_SIZE

@ STMT_OMP_DEPOBJ_DIRECTIVE

@ EXPR_CXX_BOOL_LITERAL

A CXXBoolLiteralExpr record.

@ EXPR_PAREN_LIST

A ParenListExpr record.

@ EXPR_CXX_PAREN_LIST_INIT

A CXXParenListInitExpr record.

@ STMT_OMP_DISPATCH_DIRECTIVE

@ STMT_OMP_MASTER_TASKLOOP_SIMD_DIRECTIVE

@ STMT_OPENACC_DATA_CONSTRUCT

@ STMT_OMP_TASKLOOP_DIRECTIVE

@ STMT_COMPOUND

A CompoundStmt record.

@ STMT_OMP_CANONICAL_LOOP

@ STMT_FOR

A ForStmt record.

@ STMT_ATTRIBUTED

An AttributedStmt record.

@ STMT_OMP_PARALLEL_MASTER_DIRECTIVE

@ STMT_OPENACC_WAIT_CONSTRUCT

@ STMT_OMP_TARGET_TEAMS_GENERIC_LOOP_DIRECTIVE

@ STMT_OMP_TEAMS_DIRECTIVE

@ STMT_OMP_TARGET_PARALLEL_DIRECTIVE

@ EXPR_CXX_REWRITTEN_BINARY_OPERATOR

A CXXRewrittenBinaryOperator record.

@ STMT_GOTO

A GotoStmt record.

@ EXPR_NO_INIT

An NoInitExpr record.

@ EXPR_OBJC_ARRAY_LITERAL

@ STMT_OMP_ERROR_DIRECTIVE

@ EXPR_OBJC_PROTOCOL_EXPR

An ObjCProtocolExpr record.

@ STMT_OMP_GENERIC_LOOP_DIRECTIVE

@ EXPR_ARRAY_INIT_INDEX

An ArrayInitIndexExpr record.

@ STMT_OMP_TASK_DIRECTIVE

@ STMT_OPENACC_INIT_CONSTRUCT

@ EXPR_CXX_CONSTRUCT

A CXXConstructExpr record.

@ STMT_OMP_PARALLEL_MASKED_DIRECTIVE

@ STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_DIRECTIVE

@ STMT_OPENACC_UPDATE_CONSTRUCT

@ STMT_OMP_PARALLEL_MASTER_TASKLOOP_SIMD_DIRECTIVE

@ EXPR_OBJC_DICTIONARY_LITERAL

@ STMT_OMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_DIRECTIVE

@ EXPR_CXX_DYNAMIC_CAST

A CXXDynamicCastExpr record.

@ STMT_CXX_TRY

A CXXTryStmt record.

@ EXPR_GENERIC_SELECTION

A GenericSelectionExpr record.

@ STMT_OMP_TARGET_SIMD_DIRECTIVE

@ EXPR_OBJC_INDIRECT_COPY_RESTORE

An ObjCIndirectCopyRestoreExpr record.

@ EXPR_CXX_INHERITED_CTOR_INIT

A CXXInheritedCtorInitExpr record.

@ EXPR_CALL

A CallExpr record.

@ EXPR_GNU_NULL

A GNUNullExpr record.

@ EXPR_BINARY_CONDITIONAL_OPERATOR

@ EXPR_OBJC_PROPERTY_REF_EXPR

An ObjCPropertyRefExpr record.

@ STMT_OMP_TARGET_PARALLEL_FOR_DIRECTIVE

@ STMT_OMP_FOR_SIMD_DIRECTIVE

@ STMT_OMP_MASKED_TASKLOOP_DIRECTIVE

@ EXPR_CXX_CONST_CAST

A CXXConstCastExpr record.

@ STMT_OMP_SCAN_DIRECTIVE

@ STMT_REF_PTR

A reference to a previously [de]serialized Stmt record.

@ EXPR_OBJC_MESSAGE_EXPR

An ObjCMessageExpr record.

@ EXPR_CXX_DEPENDENT_SCOPE_DECL_REF

@ STMT_OMP_TEAMS_DISTRIBUTE_DIRECTIVE

@ STMT_CASE

A CaseStmt record.

@ EXPR_CONSTANT

A constant expression context.

@ EXPR_FUNCTION_PARM_PACK

@ STMT_STOP

A marker record that indicates that we are at the end of an expression.

@ EXPR_CXX_NULL_PTR_LITERAL

@ STMT_OMP_TARGET_UPDATE_DIRECTIVE

@ STMT_MSASM

A MS-style AsmStmt record.

@ STMT_OMP_DISTRIBUTE_DIRECTIVE

@ EXPR_CONDITIONAL_OPERATOR

A ConditionOperator record.

@ EXPR_BINARY_OPERATOR

A BinaryOperator record.

@ EXPR_CXX_STD_INITIALIZER_LIST

A CXXStdInitializerListExpr record.

@ STMT_OMP_TASKGROUP_DIRECTIVE

@ STMT_OMP_REVERSE_DIRECTIVE

@ EXPR_SHUFFLE_VECTOR

A ShuffleVectorExpr record.

@ STMT_OBJC_FINALLY

An ObjCAtFinallyStmt record.

@ EXPR_OBJC_SELECTOR_EXPR

An ObjCSelectorExpr record.

@ EXPR_FLOATING_LITERAL

A FloatingLiteral record.

@ STMT_OMP_MASTER_DIRECTIVE

@ EXPR_CXX_DEPENDENT_SCOPE_MEMBER

@ STMT_NULL_PTR

A NULL expression.

@ STMT_DEFAULT

A DefaultStmt record.

@ EXPR_CHOOSE

A ChooseExpr record.

@ STMT_OMP_UNROLL_DIRECTIVE

@ STMT_NULL

A NullStmt record.

@ STMT_OMP_SIMD_DIRECTIVE

@ EXPR_DECL_REF

A DeclRefExpr record.

@ STMT_OPENACC_LOOP_CONSTRUCT

@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM

@ EXPR_INIT_LIST

An InitListExpr record.

@ EXPR_IMPLICIT_VALUE_INIT

An ImplicitValueInitExpr record.

@ STMT_OBJC_AUTORELEASE_POOL

An ObjCAutoreleasePoolStmt record.

@ STMT_OPENACC_SET_CONSTRUCT

@ EXPR_RECOVERY

A RecoveryExpr record.

@ EXPR_PAREN

A ParenExpr record.

@ STMT_OMP_TARGET_PARALLEL_GENERIC_LOOP_DIRECTIVE

@ STMT_LABEL

A LabelStmt record.

@ EXPR_CXX_FUNCTIONAL_CAST

A CXXFunctionalCastExpr record.

@ EXPR_USER_DEFINED_LITERAL

A UserDefinedLiteral record.

@ EXPR_INTEGER_LITERAL

An IntegerLiteral record.

@ EXPR_SOURCE_LOC

A SourceLocExpr record.

@ EXPR_MATERIALIZE_TEMPORARY

@ EXPR_CXX_MEMBER_CALL

A CXXMemberCallExpr record.

@ STMT_OMP_INTEROP_DIRECTIVE

@ STMT_SWITCH

A SwitchStmt record.

@ STMT_DECL

A DeclStmt record.

@ EXPR_CXX_UNRESOLVED_MEMBER

@ STMT_OMP_SECTIONS_DIRECTIVE

@ EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK

@ EXPR_CXX_SCALAR_VALUE_INIT

@ STMT_OMP_MASKED_TASKLOOP_SIMD_DIRECTIVE

@ STMT_OMP_DISTRIBUTE_SIMD_DIRECTIVE

@ EXPR_SIZEOF_ALIGN_OF

A SizefAlignOfExpr record.

@ STMT_BREAK

A BreakStmt record.

@ STMT_OBJC_AT_THROW

An ObjCAtThrowStmt record.

@ EXPR_ADDR_LABEL

An AddrLabelExpr record.

@ STMT_CXX_FOR_RANGE

A CXXForRangeStmt record.

@ EXPR_CXX_ADDRSPACE_CAST

A CXXAddrspaceCastExpr record.

@ EXPR_ARRAY_SUBSCRIPT

An ArraySubscriptExpr record.

@ EXPR_CONCEPT_SPECIALIZATION

@ EXPR_UNARY_OPERATOR

A UnaryOperator record.

@ STMT_CXX_CATCH

A CXXCatchStmt record.

@ EXPR_BUILTIN_PP_EMBED

A EmbedExpr record.

@ STMT_INDIRECT_GOTO

An IndirectGotoStmt record.

@ DESIG_ARRAY_RANGE

GNU array range designator.

@ DESIG_FIELD_NAME

Field designator where only the field name is known.

@ DESIG_FIELD_DECL

Field designator where the field has been resolved to a declaration.

@ DESIG_ARRAY

Array designator.

The JSON file list parser is used to communicate input to InstallAPI.

@ OK_Ordinary

An ordinary object is located at an address in memory.

@ VK_PRValue

A pr-value expression (in the C++11 taxonomy) produces a temporary value.

The result of a constraint satisfaction check, containing the necessary information to diagnose an un...

Represents an explicit template argument list in C++, e.g., the "" in "sort".

SourceLocation LAngleLoc

The source location of the left angle bracket ('<').

unsigned NumTemplateArgs

The number of template arguments in TemplateArgs.

SourceLocation RAngleLoc

The source location of the right angle bracket ('>').

SourceLocation TemplateKWLoc

The source location of the template keyword; this is used as part of the representation of qualified ...

Iterator range representation begin:end[:step].

Helper expressions and declaration for OMPIteratorExpr class for each iteration space.

Expr * CounterUpdate

Updater for the internal counter: ++CounterVD;.

Expr * Upper

Normalized upper bound.

Expr * Update

Update expression for the originally specified iteration variable, calculated as VD = Begin + Counter...

VarDecl * CounterVD

Internal normalized counter.

An element in an Objective-C dictionary literal.

Iterator for iterating over Stmt * arrays that contain only T *.