1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements serialization for Statements and Expressions.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Serialization/ASTWriter.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/StmtVisitor.h"
19 #include "llvm/Bitcode/BitstreamWriter.h"
20 using namespace clang;
22 //===----------------------------------------------------------------------===//
23 // Statement/expression serialization
24 //===----------------------------------------------------------------------===//
27 class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
29 ASTWriter::RecordData &Record;
32 serialization::StmtCode Code;
35 ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
36 : Writer(Writer), Record(Record) { }
39 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args);
41 void VisitStmt(Stmt *S);
42 #define STMT(Type, Base) \
43 void Visit##Type(Type *);
44 #include "clang/AST/StmtNodes.inc"
49 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList &Args) {
50 Writer.AddSourceLocation(Args.LAngleLoc, Record);
51 Writer.AddSourceLocation(Args.RAngleLoc, Record);
52 for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
53 Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record);
56 void ASTStmtWriter::VisitStmt(Stmt *S) {
59 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
61 Writer.AddSourceLocation(S->getSemiLoc(), Record);
62 Writer.AddSourceLocation(S->LeadingEmptyMacro, Record);
63 Code = serialization::STMT_NULL;
66 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
68 Record.push_back(S->size());
69 for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
72 Writer.AddSourceLocation(S->getLBracLoc(), Record);
73 Writer.AddSourceLocation(S->getRBracLoc(), Record);
74 Code = serialization::STMT_COMPOUND;
77 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
79 Record.push_back(Writer.getSwitchCaseID(S));
82 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
84 Writer.AddStmt(S->getLHS());
85 Writer.AddStmt(S->getRHS());
86 Writer.AddStmt(S->getSubStmt());
87 Writer.AddSourceLocation(S->getCaseLoc(), Record);
88 Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
89 Writer.AddSourceLocation(S->getColonLoc(), Record);
90 Code = serialization::STMT_CASE;
93 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
95 Writer.AddStmt(S->getSubStmt());
96 Writer.AddSourceLocation(S->getDefaultLoc(), Record);
97 Writer.AddSourceLocation(S->getColonLoc(), Record);
98 Code = serialization::STMT_DEFAULT;
101 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
103 Writer.AddDeclRef(S->getDecl(), Record);
104 Writer.AddStmt(S->getSubStmt());
105 Writer.AddSourceLocation(S->getIdentLoc(), Record);
106 Code = serialization::STMT_LABEL;
109 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
111 Writer.AddDeclRef(S->getConditionVariable(), Record);
112 Writer.AddStmt(S->getCond());
113 Writer.AddStmt(S->getThen());
114 Writer.AddStmt(S->getElse());
115 Writer.AddSourceLocation(S->getIfLoc(), Record);
116 Writer.AddSourceLocation(S->getElseLoc(), Record);
117 Code = serialization::STMT_IF;
120 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
122 Writer.AddDeclRef(S->getConditionVariable(), Record);
123 Writer.AddStmt(S->getCond());
124 Writer.AddStmt(S->getBody());
125 Writer.AddSourceLocation(S->getSwitchLoc(), Record);
126 Record.push_back(S->isAllEnumCasesCovered());
127 for (SwitchCase *SC = S->getSwitchCaseList(); SC;
128 SC = SC->getNextSwitchCase())
129 Record.push_back(Writer.RecordSwitchCaseID(SC));
130 Code = serialization::STMT_SWITCH;
133 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
135 Writer.AddDeclRef(S->getConditionVariable(), Record);
136 Writer.AddStmt(S->getCond());
137 Writer.AddStmt(S->getBody());
138 Writer.AddSourceLocation(S->getWhileLoc(), Record);
139 Code = serialization::STMT_WHILE;
142 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
144 Writer.AddStmt(S->getCond());
145 Writer.AddStmt(S->getBody());
146 Writer.AddSourceLocation(S->getDoLoc(), Record);
147 Writer.AddSourceLocation(S->getWhileLoc(), Record);
148 Writer.AddSourceLocation(S->getRParenLoc(), Record);
149 Code = serialization::STMT_DO;
152 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
154 Writer.AddStmt(S->getInit());
155 Writer.AddStmt(S->getCond());
156 Writer.AddDeclRef(S->getConditionVariable(), Record);
157 Writer.AddStmt(S->getInc());
158 Writer.AddStmt(S->getBody());
159 Writer.AddSourceLocation(S->getForLoc(), Record);
160 Writer.AddSourceLocation(S->getLParenLoc(), Record);
161 Writer.AddSourceLocation(S->getRParenLoc(), Record);
162 Code = serialization::STMT_FOR;
165 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
167 Writer.AddDeclRef(S->getLabel(), Record);
168 Writer.AddSourceLocation(S->getGotoLoc(), Record);
169 Writer.AddSourceLocation(S->getLabelLoc(), Record);
170 Code = serialization::STMT_GOTO;
173 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
175 Writer.AddSourceLocation(S->getGotoLoc(), Record);
176 Writer.AddSourceLocation(S->getStarLoc(), Record);
177 Writer.AddStmt(S->getTarget());
178 Code = serialization::STMT_INDIRECT_GOTO;
181 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
183 Writer.AddSourceLocation(S->getContinueLoc(), Record);
184 Code = serialization::STMT_CONTINUE;
187 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
189 Writer.AddSourceLocation(S->getBreakLoc(), Record);
190 Code = serialization::STMT_BREAK;
193 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
195 Writer.AddStmt(S->getRetValue());
196 Writer.AddSourceLocation(S->getReturnLoc(), Record);
197 Writer.AddDeclRef(S->getNRVOCandidate(), Record);
198 Code = serialization::STMT_RETURN;
201 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
203 Writer.AddSourceLocation(S->getStartLoc(), Record);
204 Writer.AddSourceLocation(S->getEndLoc(), Record);
205 DeclGroupRef DG = S->getDeclGroup();
206 for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
207 Writer.AddDeclRef(*D, Record);
208 Code = serialization::STMT_DECL;
211 void ASTStmtWriter::VisitAsmStmt(AsmStmt *S) {
213 Record.push_back(S->getNumOutputs());
214 Record.push_back(S->getNumInputs());
215 Record.push_back(S->getNumClobbers());
216 Writer.AddSourceLocation(S->getAsmLoc(), Record);
217 Writer.AddSourceLocation(S->getRParenLoc(), Record);
218 Record.push_back(S->isVolatile());
219 Record.push_back(S->isSimple());
220 Record.push_back(S->isMSAsm());
221 Writer.AddStmt(S->getAsmString());
224 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
225 Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
226 Writer.AddStmt(S->getOutputConstraintLiteral(I));
227 Writer.AddStmt(S->getOutputExpr(I));
231 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
232 Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
233 Writer.AddStmt(S->getInputConstraintLiteral(I));
234 Writer.AddStmt(S->getInputExpr(I));
238 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
239 Writer.AddStmt(S->getClobber(I));
241 Code = serialization::STMT_ASM;
244 void ASTStmtWriter::VisitExpr(Expr *E) {
246 Writer.AddTypeRef(E->getType(), Record);
247 Record.push_back(E->isTypeDependent());
248 Record.push_back(E->isValueDependent());
249 Record.push_back(E->isInstantiationDependent());
250 Record.push_back(E->containsUnexpandedParameterPack());
251 Record.push_back(E->getValueKind());
252 Record.push_back(E->getObjectKind());
255 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
257 Writer.AddSourceLocation(E->getLocation(), Record);
258 Record.push_back(E->getIdentType()); // FIXME: stable encoding
259 Code = serialization::EXPR_PREDEFINED;
262 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
265 Record.push_back(E->hasQualifier());
266 Record.push_back(E->getDecl() != E->getFoundDecl());
267 Record.push_back(E->hasExplicitTemplateArgs());
269 if (E->hasExplicitTemplateArgs()) {
270 unsigned NumTemplateArgs = E->getNumTemplateArgs();
271 Record.push_back(NumTemplateArgs);
274 DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
276 if ((!E->hasExplicitTemplateArgs()) && (!E->hasQualifier()) &&
277 (E->getDecl() == E->getFoundDecl()) &&
278 nk == DeclarationName::Identifier) {
279 AbbrevToUse = Writer.getDeclRefExprAbbrev();
282 if (E->hasQualifier())
283 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
285 if (E->getDecl() != E->getFoundDecl())
286 Writer.AddDeclRef(E->getFoundDecl(), Record);
288 if (E->hasExplicitTemplateArgs())
289 AddExplicitTemplateArgumentList(E->getExplicitTemplateArgs());
291 Writer.AddDeclRef(E->getDecl(), Record);
292 Writer.AddSourceLocation(E->getLocation(), Record);
293 Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
294 Code = serialization::EXPR_DECL_REF;
297 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
299 Writer.AddSourceLocation(E->getLocation(), Record);
300 Writer.AddAPInt(E->getValue(), Record);
302 if (E->getValue().getBitWidth() == 32) {
303 AbbrevToUse = Writer.getIntegerLiteralAbbrev();
306 Code = serialization::EXPR_INTEGER_LITERAL;
309 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
311 Writer.AddAPFloat(E->getValue(), Record);
312 Record.push_back(E->isExact());
313 Writer.AddSourceLocation(E->getLocation(), Record);
314 Code = serialization::EXPR_FLOATING_LITERAL;
317 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
319 Writer.AddStmt(E->getSubExpr());
320 Code = serialization::EXPR_IMAGINARY_LITERAL;
323 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
325 Record.push_back(E->getByteLength());
326 Record.push_back(E->getNumConcatenated());
327 Record.push_back(E->isWide());
328 Record.push_back(E->isPascal());
329 // FIXME: String data should be stored as a blob at the end of the
330 // StringLiteral. However, we can't do so now because we have no
331 // provision for coping with abbreviations when we're jumping around
332 // the AST file during deserialization.
333 Record.append(E->getString().begin(), E->getString().end());
334 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
335 Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
336 Code = serialization::EXPR_STRING_LITERAL;
339 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
341 Record.push_back(E->getValue());
342 Writer.AddSourceLocation(E->getLocation(), Record);
343 Record.push_back(E->isWide());
345 AbbrevToUse = Writer.getCharacterLiteralAbbrev();
347 Code = serialization::EXPR_CHARACTER_LITERAL;
350 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
352 Writer.AddSourceLocation(E->getLParen(), Record);
353 Writer.AddSourceLocation(E->getRParen(), Record);
354 Writer.AddStmt(E->getSubExpr());
355 Code = serialization::EXPR_PAREN;
358 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
360 Record.push_back(E->NumExprs);
361 for (unsigned i=0; i != E->NumExprs; ++i)
362 Writer.AddStmt(E->Exprs[i]);
363 Writer.AddSourceLocation(E->LParenLoc, Record);
364 Writer.AddSourceLocation(E->RParenLoc, Record);
365 Code = serialization::EXPR_PAREN_LIST;
368 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
370 Writer.AddStmt(E->getSubExpr());
371 Record.push_back(E->getOpcode()); // FIXME: stable encoding
372 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
373 Code = serialization::EXPR_UNARY_OPERATOR;
376 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
378 Record.push_back(E->getNumComponents());
379 Record.push_back(E->getNumExpressions());
380 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
381 Writer.AddSourceLocation(E->getRParenLoc(), Record);
382 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
383 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
384 const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I);
385 Record.push_back(ON.getKind()); // FIXME: Stable encoding
386 Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
387 Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
388 switch (ON.getKind()) {
389 case OffsetOfExpr::OffsetOfNode::Array:
390 Record.push_back(ON.getArrayExprIndex());
393 case OffsetOfExpr::OffsetOfNode::Field:
394 Writer.AddDeclRef(ON.getField(), Record);
397 case OffsetOfExpr::OffsetOfNode::Identifier:
398 Writer.AddIdentifierRef(ON.getFieldName(), Record);
401 case OffsetOfExpr::OffsetOfNode::Base:
402 Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
406 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
407 Writer.AddStmt(E->getIndexExpr(I));
408 Code = serialization::EXPR_OFFSETOF;
411 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
413 Record.push_back(E->getKind());
414 if (E->isArgumentType())
415 Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
418 Writer.AddStmt(E->getArgumentExpr());
420 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
421 Writer.AddSourceLocation(E->getRParenLoc(), Record);
422 Code = serialization::EXPR_SIZEOF_ALIGN_OF;
425 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
427 Writer.AddStmt(E->getLHS());
428 Writer.AddStmt(E->getRHS());
429 Writer.AddSourceLocation(E->getRBracketLoc(), Record);
430 Code = serialization::EXPR_ARRAY_SUBSCRIPT;
433 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
435 Record.push_back(E->getNumArgs());
436 Writer.AddSourceLocation(E->getRParenLoc(), Record);
437 Writer.AddStmt(E->getCallee());
438 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
439 Arg != ArgEnd; ++Arg)
440 Writer.AddStmt(*Arg);
441 Code = serialization::EXPR_CALL;
444 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
445 // Don't call VisitExpr, we'll write everything here.
447 Record.push_back(E->hasQualifier());
448 if (E->hasQualifier())
449 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
451 Record.push_back(E->hasExplicitTemplateArgs());
452 if (E->hasExplicitTemplateArgs()) {
453 unsigned NumTemplateArgs = E->getNumTemplateArgs();
454 Record.push_back(NumTemplateArgs);
455 Writer.AddSourceLocation(E->getLAngleLoc(), Record);
456 Writer.AddSourceLocation(E->getRAngleLoc(), Record);
457 for (unsigned i=0; i != NumTemplateArgs; ++i)
458 Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
461 DeclAccessPair FoundDecl = E->getFoundDecl();
462 Writer.AddDeclRef(FoundDecl.getDecl(), Record);
463 Record.push_back(FoundDecl.getAccess());
465 Writer.AddTypeRef(E->getType(), Record);
466 Record.push_back(E->getValueKind());
467 Record.push_back(E->getObjectKind());
468 Writer.AddStmt(E->getBase());
469 Writer.AddDeclRef(E->getMemberDecl(), Record);
470 Writer.AddSourceLocation(E->getMemberLoc(), Record);
471 Record.push_back(E->isArrow());
472 Writer.AddDeclarationNameLoc(E->MemberDNLoc,
473 E->getMemberDecl()->getDeclName(), Record);
474 Code = serialization::EXPR_MEMBER;
477 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
479 Writer.AddStmt(E->getBase());
480 Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
481 Record.push_back(E->isArrow());
482 Code = serialization::EXPR_OBJC_ISA;
486 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
488 Writer.AddStmt(E->getSubExpr());
489 Record.push_back(E->shouldCopy());
490 Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
493 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
494 VisitExplicitCastExpr(E);
495 Writer.AddSourceLocation(E->getLParenLoc(), Record);
496 Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record);
497 Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
498 Code = serialization::EXPR_OBJC_BRIDGED_CAST;
501 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
503 Record.push_back(E->path_size());
504 Writer.AddStmt(E->getSubExpr());
505 Record.push_back(E->getCastKind()); // FIXME: stable encoding
507 for (CastExpr::path_iterator
508 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
509 Writer.AddCXXBaseSpecifier(**PI, Record);
512 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
514 Writer.AddStmt(E->getLHS());
515 Writer.AddStmt(E->getRHS());
516 Record.push_back(E->getOpcode()); // FIXME: stable encoding
517 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
518 Code = serialization::EXPR_BINARY_OPERATOR;
521 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
522 VisitBinaryOperator(E);
523 Writer.AddTypeRef(E->getComputationLHSType(), Record);
524 Writer.AddTypeRef(E->getComputationResultType(), Record);
525 Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
528 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
530 Writer.AddStmt(E->getCond());
531 Writer.AddStmt(E->getLHS());
532 Writer.AddStmt(E->getRHS());
533 Writer.AddSourceLocation(E->getQuestionLoc(), Record);
534 Writer.AddSourceLocation(E->getColonLoc(), Record);
535 Code = serialization::EXPR_CONDITIONAL_OPERATOR;
539 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
541 Writer.AddStmt(E->getOpaqueValue());
542 Writer.AddStmt(E->getCommon());
543 Writer.AddStmt(E->getCond());
544 Writer.AddStmt(E->getTrueExpr());
545 Writer.AddStmt(E->getFalseExpr());
546 Writer.AddSourceLocation(E->getQuestionLoc(), Record);
547 Writer.AddSourceLocation(E->getColonLoc(), Record);
548 Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
551 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
553 Code = serialization::EXPR_IMPLICIT_CAST;
556 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
558 Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
561 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
562 VisitExplicitCastExpr(E);
563 Writer.AddSourceLocation(E->getLParenLoc(), Record);
564 Writer.AddSourceLocation(E->getRParenLoc(), Record);
565 Code = serialization::EXPR_CSTYLE_CAST;
568 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
570 Writer.AddSourceLocation(E->getLParenLoc(), Record);
571 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
572 Writer.AddStmt(E->getInitializer());
573 Record.push_back(E->isFileScope());
574 Code = serialization::EXPR_COMPOUND_LITERAL;
577 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
579 Writer.AddStmt(E->getBase());
580 Writer.AddIdentifierRef(&E->getAccessor(), Record);
581 Writer.AddSourceLocation(E->getAccessorLoc(), Record);
582 Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
585 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
587 Writer.AddStmt(E->getSyntacticForm());
588 Writer.AddSourceLocation(E->getLBraceLoc(), Record);
589 Writer.AddSourceLocation(E->getRBraceLoc(), Record);
590 bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
591 Record.push_back(isArrayFiller);
593 Writer.AddStmt(E->getArrayFiller());
595 Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
596 Record.push_back(E->hadArrayRangeDesignator());
597 Record.push_back(E->getNumInits());
599 // ArrayFiller may have filled "holes" due to designated initializer.
600 // Replace them by 0 to indicate that the filler goes in that place.
601 Expr *filler = E->getArrayFiller();
602 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
603 Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : 0);
605 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
606 Writer.AddStmt(E->getInit(I));
608 Code = serialization::EXPR_INIT_LIST;
611 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
613 Record.push_back(E->getNumSubExprs());
614 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
615 Writer.AddStmt(E->getSubExpr(I));
616 Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
617 Record.push_back(E->usesGNUSyntax());
618 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
619 DEnd = E->designators_end();
621 if (D->isFieldDesignator()) {
622 if (FieldDecl *Field = D->getField()) {
623 Record.push_back(serialization::DESIG_FIELD_DECL);
624 Writer.AddDeclRef(Field, Record);
626 Record.push_back(serialization::DESIG_FIELD_NAME);
627 Writer.AddIdentifierRef(D->getFieldName(), Record);
629 Writer.AddSourceLocation(D->getDotLoc(), Record);
630 Writer.AddSourceLocation(D->getFieldLoc(), Record);
631 } else if (D->isArrayDesignator()) {
632 Record.push_back(serialization::DESIG_ARRAY);
633 Record.push_back(D->getFirstExprIndex());
634 Writer.AddSourceLocation(D->getLBracketLoc(), Record);
635 Writer.AddSourceLocation(D->getRBracketLoc(), Record);
637 assert(D->isArrayRangeDesignator() && "Unknown designator");
638 Record.push_back(serialization::DESIG_ARRAY_RANGE);
639 Record.push_back(D->getFirstExprIndex());
640 Writer.AddSourceLocation(D->getLBracketLoc(), Record);
641 Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
642 Writer.AddSourceLocation(D->getRBracketLoc(), Record);
645 Code = serialization::EXPR_DESIGNATED_INIT;
648 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
650 Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
653 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
655 Writer.AddStmt(E->getSubExpr());
656 Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
657 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
658 Writer.AddSourceLocation(E->getRParenLoc(), Record);
659 Code = serialization::EXPR_VA_ARG;
662 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
664 Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
665 Writer.AddSourceLocation(E->getLabelLoc(), Record);
666 Writer.AddDeclRef(E->getLabel(), Record);
667 Code = serialization::EXPR_ADDR_LABEL;
670 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
672 Writer.AddStmt(E->getSubStmt());
673 Writer.AddSourceLocation(E->getLParenLoc(), Record);
674 Writer.AddSourceLocation(E->getRParenLoc(), Record);
675 Code = serialization::EXPR_STMT;
678 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
680 Writer.AddStmt(E->getCond());
681 Writer.AddStmt(E->getLHS());
682 Writer.AddStmt(E->getRHS());
683 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
684 Writer.AddSourceLocation(E->getRParenLoc(), Record);
685 Code = serialization::EXPR_CHOOSE;
688 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
690 Writer.AddSourceLocation(E->getTokenLocation(), Record);
691 Code = serialization::EXPR_GNU_NULL;
694 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
696 Record.push_back(E->getNumSubExprs());
697 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
698 Writer.AddStmt(E->getExpr(I));
699 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
700 Writer.AddSourceLocation(E->getRParenLoc(), Record);
701 Code = serialization::EXPR_SHUFFLE_VECTOR;
704 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
706 Writer.AddDeclRef(E->getBlockDecl(), Record);
707 Code = serialization::EXPR_BLOCK;
710 void ASTStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
712 Writer.AddDeclRef(E->getDecl(), Record);
713 Writer.AddSourceLocation(E->getLocation(), Record);
714 Record.push_back(E->isByRef());
715 Record.push_back(E->isConstQualAdded());
716 Code = serialization::EXPR_BLOCK_DECL_REF;
719 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
721 Record.push_back(E->getNumAssocs());
723 Writer.AddStmt(E->getControllingExpr());
724 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
725 Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
726 Writer.AddStmt(E->getAssocExpr(I));
728 Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
730 Writer.AddSourceLocation(E->getGenericLoc(), Record);
731 Writer.AddSourceLocation(E->getDefaultLoc(), Record);
732 Writer.AddSourceLocation(E->getRParenLoc(), Record);
733 Code = serialization::EXPR_GENERIC_SELECTION;
736 //===----------------------------------------------------------------------===//
737 // Objective-C Expressions and Statements.
738 //===----------------------------------------------------------------------===//
740 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
742 Writer.AddStmt(E->getString());
743 Writer.AddSourceLocation(E->getAtLoc(), Record);
744 Code = serialization::EXPR_OBJC_STRING_LITERAL;
747 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
749 Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
750 Writer.AddSourceLocation(E->getAtLoc(), Record);
751 Writer.AddSourceLocation(E->getRParenLoc(), Record);
752 Code = serialization::EXPR_OBJC_ENCODE;
755 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
757 Writer.AddSelectorRef(E->getSelector(), Record);
758 Writer.AddSourceLocation(E->getAtLoc(), Record);
759 Writer.AddSourceLocation(E->getRParenLoc(), Record);
760 Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
763 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
765 Writer.AddDeclRef(E->getProtocol(), Record);
766 Writer.AddSourceLocation(E->getAtLoc(), Record);
767 Writer.AddSourceLocation(E->getRParenLoc(), Record);
768 Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
771 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
773 Writer.AddDeclRef(E->getDecl(), Record);
774 Writer.AddSourceLocation(E->getLocation(), Record);
775 Writer.AddStmt(E->getBase());
776 Record.push_back(E->isArrow());
777 Record.push_back(E->isFreeIvar());
778 Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
781 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
783 Record.push_back(E->isImplicitProperty());
784 if (E->isImplicitProperty()) {
785 Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
786 Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
788 Writer.AddDeclRef(E->getExplicitProperty(), Record);
790 Writer.AddSourceLocation(E->getLocation(), Record);
791 Writer.AddSourceLocation(E->getReceiverLocation(), Record);
792 if (E->isObjectReceiver()) {
794 Writer.AddStmt(E->getBase());
795 } else if (E->isSuperReceiver()) {
797 Writer.AddTypeRef(E->getSuperReceiverType(), Record);
800 Writer.AddDeclRef(E->getClassReceiver(), Record);
803 Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
806 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
808 Record.push_back(E->getNumArgs());
809 Record.push_back(E->isDelegateInitCall());
810 Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
811 switch (E->getReceiverKind()) {
812 case ObjCMessageExpr::Instance:
813 Writer.AddStmt(E->getInstanceReceiver());
816 case ObjCMessageExpr::Class:
817 Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
820 case ObjCMessageExpr::SuperClass:
821 case ObjCMessageExpr::SuperInstance:
822 Writer.AddTypeRef(E->getSuperType(), Record);
823 Writer.AddSourceLocation(E->getSuperLoc(), Record);
827 if (E->getMethodDecl()) {
829 Writer.AddDeclRef(E->getMethodDecl(), Record);
832 Writer.AddSelectorRef(E->getSelector(), Record);
835 Writer.AddSourceLocation(E->getLeftLoc(), Record);
836 Writer.AddSourceLocation(E->getRightLoc(), Record);
837 Writer.AddSourceLocation(E->getSelectorLoc(), Record);
839 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
840 Arg != ArgEnd; ++Arg)
841 Writer.AddStmt(*Arg);
842 Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
845 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
847 Writer.AddStmt(S->getElement());
848 Writer.AddStmt(S->getCollection());
849 Writer.AddStmt(S->getBody());
850 Writer.AddSourceLocation(S->getForLoc(), Record);
851 Writer.AddSourceLocation(S->getRParenLoc(), Record);
852 Code = serialization::STMT_OBJC_FOR_COLLECTION;
855 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
856 Writer.AddStmt(S->getCatchBody());
857 Writer.AddDeclRef(S->getCatchParamDecl(), Record);
858 Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
859 Writer.AddSourceLocation(S->getRParenLoc(), Record);
860 Code = serialization::STMT_OBJC_CATCH;
863 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
864 Writer.AddStmt(S->getFinallyBody());
865 Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
866 Code = serialization::STMT_OBJC_FINALLY;
869 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
870 Writer.AddStmt(S->getSubStmt());
871 Writer.AddSourceLocation(S->getAtLoc(), Record);
872 Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
875 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
876 Record.push_back(S->getNumCatchStmts());
877 Record.push_back(S->getFinallyStmt() != 0);
878 Writer.AddStmt(S->getTryBody());
879 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
880 Writer.AddStmt(S->getCatchStmt(I));
881 if (S->getFinallyStmt())
882 Writer.AddStmt(S->getFinallyStmt());
883 Writer.AddSourceLocation(S->getAtTryLoc(), Record);
884 Code = serialization::STMT_OBJC_AT_TRY;
887 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
888 Writer.AddStmt(S->getSynchExpr());
889 Writer.AddStmt(S->getSynchBody());
890 Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
891 Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
894 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
895 Writer.AddStmt(S->getThrowExpr());
896 Writer.AddSourceLocation(S->getThrowLoc(), Record);
897 Code = serialization::STMT_OBJC_AT_THROW;
900 //===----------------------------------------------------------------------===//
901 // C++ Expressions and Statements.
902 //===----------------------------------------------------------------------===//
904 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
906 Writer.AddSourceLocation(S->getCatchLoc(), Record);
907 Writer.AddDeclRef(S->getExceptionDecl(), Record);
908 Writer.AddStmt(S->getHandlerBlock());
909 Code = serialization::STMT_CXX_CATCH;
912 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
914 Record.push_back(S->getNumHandlers());
915 Writer.AddSourceLocation(S->getTryLoc(), Record);
916 Writer.AddStmt(S->getTryBlock());
917 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
918 Writer.AddStmt(S->getHandler(i));
919 Code = serialization::STMT_CXX_TRY;
922 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
924 Writer.AddSourceLocation(S->getForLoc(), Record);
925 Writer.AddSourceLocation(S->getColonLoc(), Record);
926 Writer.AddSourceLocation(S->getRParenLoc(), Record);
927 Writer.AddStmt(S->getRangeStmt());
928 Writer.AddStmt(S->getBeginEndStmt());
929 Writer.AddStmt(S->getCond());
930 Writer.AddStmt(S->getInc());
931 Writer.AddStmt(S->getLoopVarStmt());
932 Writer.AddStmt(S->getBody());
933 Code = serialization::STMT_CXX_FOR_RANGE;
936 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
938 Record.push_back(E->getOperator());
939 Code = serialization::EXPR_CXX_OPERATOR_CALL;
942 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
944 Code = serialization::EXPR_CXX_MEMBER_CALL;
947 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
949 Record.push_back(E->getNumArgs());
950 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
951 Writer.AddStmt(E->getArg(I));
952 Writer.AddDeclRef(E->getConstructor(), Record);
953 Writer.AddSourceLocation(E->getLocation(), Record);
954 Record.push_back(E->isElidable());
955 Record.push_back(E->requiresZeroInitialization());
956 Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
957 Writer.AddSourceRange(E->getParenRange(), Record);
958 Code = serialization::EXPR_CXX_CONSTRUCT;
961 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
962 VisitCXXConstructExpr(E);
963 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
964 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
967 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
968 VisitExplicitCastExpr(E);
969 Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
973 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
974 VisitCXXNamedCastExpr(E);
975 Code = serialization::EXPR_CXX_STATIC_CAST;
978 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
979 VisitCXXNamedCastExpr(E);
980 Code = serialization::EXPR_CXX_DYNAMIC_CAST;
983 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
984 VisitCXXNamedCastExpr(E);
985 Code = serialization::EXPR_CXX_REINTERPRET_CAST;
988 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
989 VisitCXXNamedCastExpr(E);
990 Code = serialization::EXPR_CXX_CONST_CAST;
993 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
994 VisitExplicitCastExpr(E);
995 Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
996 Writer.AddSourceLocation(E->getRParenLoc(), Record);
997 Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1000 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1002 Record.push_back(E->getValue());
1003 Writer.AddSourceLocation(E->getLocation(), Record);
1004 Code = serialization::EXPR_CXX_BOOL_LITERAL;
1007 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1009 Writer.AddSourceLocation(E->getLocation(), Record);
1010 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1013 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1015 Writer.AddSourceRange(E->getSourceRange(), Record);
1016 if (E->isTypeOperand()) {
1017 Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1018 Code = serialization::EXPR_CXX_TYPEID_TYPE;
1020 Writer.AddStmt(E->getExprOperand());
1021 Code = serialization::EXPR_CXX_TYPEID_EXPR;
1025 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1027 Writer.AddSourceLocation(E->getLocation(), Record);
1028 Record.push_back(E->isImplicit());
1029 Code = serialization::EXPR_CXX_THIS;
1032 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1034 Writer.AddSourceLocation(E->getThrowLoc(), Record);
1035 Writer.AddStmt(E->getSubExpr());
1036 Record.push_back(E->isThrownVariableInScope());
1037 Code = serialization::EXPR_CXX_THROW;
1040 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1043 bool HasOtherExprStored = E->Param.getInt();
1044 // Store these first, the reader reads them before creation.
1045 Record.push_back(HasOtherExprStored);
1046 if (HasOtherExprStored)
1047 Writer.AddStmt(E->getExpr());
1048 Writer.AddDeclRef(E->getParam(), Record);
1049 Writer.AddSourceLocation(E->getUsedLocation(), Record);
1051 Code = serialization::EXPR_CXX_DEFAULT_ARG;
1054 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1056 Writer.AddCXXTemporary(E->getTemporary(), Record);
1057 Writer.AddStmt(E->getSubExpr());
1058 Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1061 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1063 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1064 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1065 Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1068 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1070 Record.push_back(E->isGlobalNew());
1071 Record.push_back(E->hasInitializer());
1072 Record.push_back(E->doesUsualArrayDeleteWantSize());
1073 Record.push_back(E->isArray());
1074 Record.push_back(E->getNumPlacementArgs());
1075 Record.push_back(E->getNumConstructorArgs());
1076 Writer.AddDeclRef(E->getOperatorNew(), Record);
1077 Writer.AddDeclRef(E->getOperatorDelete(), Record);
1078 Writer.AddDeclRef(E->getConstructor(), Record);
1079 Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1080 Writer.AddSourceRange(E->getTypeIdParens(), Record);
1081 Writer.AddSourceLocation(E->getStartLoc(), Record);
1082 Writer.AddSourceLocation(E->getEndLoc(), Record);
1083 Writer.AddSourceLocation(E->getConstructorLParen(), Record);
1084 Writer.AddSourceLocation(E->getConstructorRParen(), Record);
1085 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1089 Code = serialization::EXPR_CXX_NEW;
1092 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1094 Record.push_back(E->isGlobalDelete());
1095 Record.push_back(E->isArrayForm());
1096 Record.push_back(E->isArrayFormAsWritten());
1097 Record.push_back(E->doesUsualArrayDeleteWantSize());
1098 Writer.AddDeclRef(E->getOperatorDelete(), Record);
1099 Writer.AddStmt(E->getArgument());
1100 Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1102 Code = serialization::EXPR_CXX_DELETE;
1105 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1108 Writer.AddStmt(E->getBase());
1109 Record.push_back(E->isArrow());
1110 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1111 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1112 Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1113 Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1114 Writer.AddSourceLocation(E->getTildeLoc(), Record);
1116 // PseudoDestructorTypeStorage.
1117 Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1118 if (E->getDestroyedTypeIdentifier())
1119 Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1121 Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1123 Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1126 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1128 Record.push_back(E->getNumTemporaries());
1129 for (unsigned i = 0, e = E->getNumTemporaries(); i != e; ++i)
1130 Writer.AddCXXTemporary(E->getTemporary(i), Record);
1132 Writer.AddStmt(E->getSubExpr());
1133 Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1137 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1140 // Don't emit anything here, hasExplicitTemplateArgs() must be
1143 Record.push_back(E->hasExplicitTemplateArgs());
1144 if (E->hasExplicitTemplateArgs()) {
1145 const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1146 Record.push_back(Args.NumTemplateArgs);
1147 AddExplicitTemplateArgumentList(Args);
1150 if (!E->isImplicitAccess())
1151 Writer.AddStmt(E->getBase());
1154 Writer.AddTypeRef(E->getBaseType(), Record);
1155 Record.push_back(E->isArrow());
1156 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1157 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1158 Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1159 Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1160 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1164 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1167 // Don't emit anything here, hasExplicitTemplateArgs() must be
1169 Record.push_back(E->hasExplicitTemplateArgs());
1170 if (E->hasExplicitTemplateArgs()) {
1171 const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1172 Record.push_back(Args.NumTemplateArgs);
1173 AddExplicitTemplateArgumentList(Args);
1176 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1177 Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1178 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1182 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1184 Record.push_back(E->arg_size());
1185 for (CXXUnresolvedConstructExpr::arg_iterator
1186 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1187 Writer.AddStmt(*ArgI);
1188 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1189 Writer.AddSourceLocation(E->getLParenLoc(), Record);
1190 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1191 Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1194 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1197 // Don't emit anything here, hasExplicitTemplateArgs() must be emitted first.
1198 Record.push_back(E->hasExplicitTemplateArgs());
1199 if (E->hasExplicitTemplateArgs()) {
1200 const ExplicitTemplateArgumentList &Args = E->getExplicitTemplateArgs();
1201 Record.push_back(Args.NumTemplateArgs);
1202 AddExplicitTemplateArgumentList(Args);
1205 Record.push_back(E->getNumDecls());
1206 for (OverloadExpr::decls_iterator
1207 OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1208 Writer.AddDeclRef(OvI.getDecl(), Record);
1209 Record.push_back(OvI.getAccess());
1212 Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1213 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1216 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1217 VisitOverloadExpr(E);
1218 Record.push_back(E->isArrow());
1219 Record.push_back(E->hasUnresolvedUsing());
1220 Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0);
1221 Writer.AddTypeRef(E->getBaseType(), Record);
1222 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1223 Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1226 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1227 VisitOverloadExpr(E);
1228 Record.push_back(E->requiresADL());
1229 if (E->requiresADL())
1230 Record.push_back(E->isStdAssociatedNamespace());
1231 Record.push_back(E->isOverloaded());
1232 Writer.AddDeclRef(E->getNamingClass(), Record);
1233 Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1236 void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1238 Record.push_back(E->getTrait());
1239 Record.push_back(E->getValue());
1240 Writer.AddSourceRange(E->getSourceRange(), Record);
1241 Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1242 Code = serialization::EXPR_CXX_UNARY_TYPE_TRAIT;
1245 void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1247 Record.push_back(E->getTrait());
1248 Record.push_back(E->getValue());
1249 Writer.AddSourceRange(E->getSourceRange(), Record);
1250 Writer.AddTypeSourceInfo(E->getLhsTypeSourceInfo(), Record);
1251 Writer.AddTypeSourceInfo(E->getRhsTypeSourceInfo(), Record);
1252 Code = serialization::EXPR_BINARY_TYPE_TRAIT;
1255 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1257 Record.push_back(E->getTrait());
1258 Record.push_back(E->getValue());
1259 Writer.AddSourceRange(E->getSourceRange(), Record);
1260 Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1261 Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1264 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1266 Record.push_back(E->getTrait());
1267 Record.push_back(E->getValue());
1268 Writer.AddSourceRange(E->getSourceRange(), Record);
1269 Writer.AddStmt(E->getQueriedExpression());
1270 Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1273 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1275 Record.push_back(E->getValue());
1276 Writer.AddSourceRange(E->getSourceRange(), Record);
1277 Writer.AddStmt(E->getOperand());
1278 Code = serialization::EXPR_CXX_NOEXCEPT;
1281 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1283 Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1284 Record.push_back(E->NumExpansions);
1285 Writer.AddStmt(E->getPattern());
1286 Code = serialization::EXPR_PACK_EXPANSION;
1289 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1291 Writer.AddSourceLocation(E->OperatorLoc, Record);
1292 Writer.AddSourceLocation(E->PackLoc, Record);
1293 Writer.AddSourceLocation(E->RParenLoc, Record);
1294 Record.push_back(E->Length);
1295 Writer.AddDeclRef(E->Pack, Record);
1296 Code = serialization::EXPR_SIZEOF_PACK;
1299 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1300 SubstNonTypeTemplateParmExpr *E) {
1302 Writer.AddDeclRef(E->getParameter(), Record);
1303 Writer.AddSourceLocation(E->getNameLoc(), Record);
1304 Writer.AddStmt(E->getReplacement());
1305 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1308 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1309 SubstNonTypeTemplateParmPackExpr *E) {
1311 Writer.AddDeclRef(E->getParameterPack(), Record);
1312 Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1313 Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1314 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1317 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1319 Writer.AddStmt(E->Temporary);
1320 Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1323 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1325 Record.push_back(Writer.getOpaqueValueID(E));
1326 Writer.AddSourceLocation(E->getLocation(), Record);
1327 Code = serialization::EXPR_OPAQUE_VALUE;
1330 //===----------------------------------------------------------------------===//
1331 // CUDA Expressions and Statements.
1332 //===----------------------------------------------------------------------===//
1334 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1336 Writer.AddStmt(E->getConfig());
1337 Code = serialization::EXPR_CUDA_KERNEL_CALL;
1340 //===----------------------------------------------------------------------===//
1341 // OpenCL Expressions and Statements.
1342 //===----------------------------------------------------------------------===//
1343 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1345 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1346 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1347 Writer.AddStmt(E->getSrcExpr());
1348 Code = serialization::EXPR_ASTYPE;
1351 //===----------------------------------------------------------------------===//
1352 // Microsoft Expressions and Statements.
1353 //===----------------------------------------------------------------------===//
1354 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1356 Writer.AddSourceRange(E->getSourceRange(), Record);
1357 if (E->isTypeOperand()) {
1358 Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1359 Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1361 Writer.AddStmt(E->getExprOperand());
1362 Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1366 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1368 Writer.AddSourceLocation(S->getExceptLoc(), Record);
1369 Writer.AddStmt(S->getFilterExpr());
1370 Writer.AddStmt(S->getBlock());
1371 Code = serialization::STMT_SEH_EXCEPT;
1374 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1376 Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1377 Writer.AddStmt(S->getBlock());
1378 Code = serialization::STMT_SEH_FINALLY;
1381 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1383 Record.push_back(S->getIsCXXTry());
1384 Writer.AddSourceLocation(S->getTryLoc(), Record);
1385 Writer.AddStmt(S->getTryBlock());
1386 Writer.AddStmt(S->getHandler());
1387 Code = serialization::STMT_SEH_TRY;
1390 //===----------------------------------------------------------------------===//
1391 // ASTWriter Implementation
1392 //===----------------------------------------------------------------------===//
1394 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
1395 assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
1396 "SwitchCase recorded twice");
1397 unsigned NextID = SwitchCaseIDs.size();
1398 SwitchCaseIDs[S] = NextID;
1402 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
1403 assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
1404 "SwitchCase hasn't been seen yet");
1405 return SwitchCaseIDs[S];
1408 void ASTWriter::ClearSwitchCaseIDs() {
1409 SwitchCaseIDs.clear();
1412 unsigned ASTWriter::getOpaqueValueID(OpaqueValueExpr *e) {
1413 unsigned &entry = OpaqueValues[e];
1414 if (!entry) entry = OpaqueValues.size();
1418 /// \brief Write the given substatement or subexpression to the
1420 void ASTWriter::WriteSubStmt(Stmt *S) {
1422 ASTStmtWriter Writer(*this, Record);
1426 Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
1430 // Redirect ASTWriter::AddStmt to collect sub stmts.
1431 llvm::SmallVector<Stmt *, 16> SubStmts;
1432 CollectedStmts = &SubStmts;
1434 Writer.Code = serialization::STMT_NULL_PTR;
1435 Writer.AbbrevToUse = 0;
1439 if (Writer.Code == serialization::STMT_NULL_PTR) {
1440 SourceManager &SrcMgr
1441 = DeclIDs.begin()->first->getASTContext().getSourceManager();
1443 assert(0 && "Unhandled sub statement writing AST file");
1447 // Revert ASTWriter::AddStmt.
1448 CollectedStmts = &StmtsToEmit;
1450 // Write the sub stmts in reverse order, last to first. When reading them back
1451 // we will read them in correct order by "pop"ing them from the Stmts stack.
1452 // This simplifies reading and allows to store a variable number of sub stmts
1453 // without knowing it in advance.
1454 while (!SubStmts.empty())
1455 WriteSubStmt(SubStmts.pop_back_val());
1457 Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
1460 /// \brief Flush all of the statements that have been added to the
1461 /// queue via AddStmt().
1462 void ASTWriter::FlushStmts() {
1465 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
1466 WriteSubStmt(StmtsToEmit[I]);
1468 assert(N == StmtsToEmit.size() &&
1469 "Substatement written via AddStmt rather than WriteSubStmt!");
1471 // Note that we are at the end of a full expression. Any
1472 // expression records that follow this one are part of a different
1474 Stream.EmitRecord(serialization::STMT_STOP, Record);
1477 StmtsToEmit.clear();