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
;
34 ASTStmtWriter(ASTWriter
&Writer
, ASTWriter::RecordData
&Record
)
35 : Writer(Writer
), Record(Record
) { }
38 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList
&Args
);
40 void VisitStmt(Stmt
*S
);
41 void VisitNullStmt(NullStmt
*S
);
42 void VisitCompoundStmt(CompoundStmt
*S
);
43 void VisitSwitchCase(SwitchCase
*S
);
44 void VisitCaseStmt(CaseStmt
*S
);
45 void VisitDefaultStmt(DefaultStmt
*S
);
46 void VisitLabelStmt(LabelStmt
*S
);
47 void VisitIfStmt(IfStmt
*S
);
48 void VisitSwitchStmt(SwitchStmt
*S
);
49 void VisitWhileStmt(WhileStmt
*S
);
50 void VisitDoStmt(DoStmt
*S
);
51 void VisitForStmt(ForStmt
*S
);
52 void VisitGotoStmt(GotoStmt
*S
);
53 void VisitIndirectGotoStmt(IndirectGotoStmt
*S
);
54 void VisitContinueStmt(ContinueStmt
*S
);
55 void VisitBreakStmt(BreakStmt
*S
);
56 void VisitReturnStmt(ReturnStmt
*S
);
57 void VisitDeclStmt(DeclStmt
*S
);
58 void VisitAsmStmt(AsmStmt
*S
);
59 void VisitExpr(Expr
*E
);
60 void VisitPredefinedExpr(PredefinedExpr
*E
);
61 void VisitDeclRefExpr(DeclRefExpr
*E
);
62 void VisitIntegerLiteral(IntegerLiteral
*E
);
63 void VisitFloatingLiteral(FloatingLiteral
*E
);
64 void VisitImaginaryLiteral(ImaginaryLiteral
*E
);
65 void VisitStringLiteral(StringLiteral
*E
);
66 void VisitCharacterLiteral(CharacterLiteral
*E
);
67 void VisitParenExpr(ParenExpr
*E
);
68 void VisitParenListExpr(ParenListExpr
*E
);
69 void VisitUnaryOperator(UnaryOperator
*E
);
70 void VisitOffsetOfExpr(OffsetOfExpr
*E
);
71 void VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr
*E
);
72 void VisitArraySubscriptExpr(ArraySubscriptExpr
*E
);
73 void VisitCallExpr(CallExpr
*E
);
74 void VisitMemberExpr(MemberExpr
*E
);
75 void VisitCastExpr(CastExpr
*E
);
76 void VisitBinaryOperator(BinaryOperator
*E
);
77 void VisitCompoundAssignOperator(CompoundAssignOperator
*E
);
78 void VisitConditionalOperator(ConditionalOperator
*E
);
79 void VisitBinaryConditionalOperator(BinaryConditionalOperator
*E
);
80 void VisitImplicitCastExpr(ImplicitCastExpr
*E
);
81 void VisitExplicitCastExpr(ExplicitCastExpr
*E
);
82 void VisitCStyleCastExpr(CStyleCastExpr
*E
);
83 void VisitCompoundLiteralExpr(CompoundLiteralExpr
*E
);
84 void VisitExtVectorElementExpr(ExtVectorElementExpr
*E
);
85 void VisitInitListExpr(InitListExpr
*E
);
86 void VisitDesignatedInitExpr(DesignatedInitExpr
*E
);
87 void VisitImplicitValueInitExpr(ImplicitValueInitExpr
*E
);
88 void VisitVAArgExpr(VAArgExpr
*E
);
89 void VisitAddrLabelExpr(AddrLabelExpr
*E
);
90 void VisitStmtExpr(StmtExpr
*E
);
91 void VisitChooseExpr(ChooseExpr
*E
);
92 void VisitGNUNullExpr(GNUNullExpr
*E
);
93 void VisitShuffleVectorExpr(ShuffleVectorExpr
*E
);
94 void VisitBlockExpr(BlockExpr
*E
);
95 void VisitBlockDeclRefExpr(BlockDeclRefExpr
*E
);
96 void VisitGenericSelectionExpr(GenericSelectionExpr
*E
);
98 // Objective-C Expressions
99 void VisitObjCStringLiteral(ObjCStringLiteral
*E
);
100 void VisitObjCEncodeExpr(ObjCEncodeExpr
*E
);
101 void VisitObjCSelectorExpr(ObjCSelectorExpr
*E
);
102 void VisitObjCProtocolExpr(ObjCProtocolExpr
*E
);
103 void VisitObjCIvarRefExpr(ObjCIvarRefExpr
*E
);
104 void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr
*E
);
105 void VisitObjCMessageExpr(ObjCMessageExpr
*E
);
106 void VisitObjCIsaExpr(ObjCIsaExpr
*E
);
108 // Objective-C Statements
109 void VisitObjCForCollectionStmt(ObjCForCollectionStmt
*);
110 void VisitObjCAtCatchStmt(ObjCAtCatchStmt
*);
111 void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt
*);
112 void VisitObjCAtTryStmt(ObjCAtTryStmt
*);
113 void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt
*);
114 void VisitObjCAtThrowStmt(ObjCAtThrowStmt
*);
117 void VisitCXXCatchStmt(CXXCatchStmt
*S
);
118 void VisitCXXTryStmt(CXXTryStmt
*S
);
119 void VisitCXXForRangeStmt(CXXForRangeStmt
*);
121 void VisitCXXOperatorCallExpr(CXXOperatorCallExpr
*E
);
122 void VisitCXXMemberCallExpr(CXXMemberCallExpr
*E
);
123 void VisitCXXConstructExpr(CXXConstructExpr
*E
);
124 void VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr
*E
);
125 void VisitCXXNamedCastExpr(CXXNamedCastExpr
*E
);
126 void VisitCXXStaticCastExpr(CXXStaticCastExpr
*E
);
127 void VisitCXXDynamicCastExpr(CXXDynamicCastExpr
*E
);
128 void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr
*E
);
129 void VisitCXXConstCastExpr(CXXConstCastExpr
*E
);
130 void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr
*E
);
131 void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr
*E
);
132 void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr
*E
);
133 void VisitCXXTypeidExpr(CXXTypeidExpr
*E
);
134 void VisitCXXUuidofExpr(CXXUuidofExpr
*E
);
135 void VisitCXXThisExpr(CXXThisExpr
*E
);
136 void VisitCXXThrowExpr(CXXThrowExpr
*E
);
137 void VisitCXXDefaultArgExpr(CXXDefaultArgExpr
*E
);
138 void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr
*E
);
140 void VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr
*E
);
141 void VisitCXXNewExpr(CXXNewExpr
*E
);
142 void VisitCXXDeleteExpr(CXXDeleteExpr
*E
);
143 void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr
*E
);
145 void VisitExprWithCleanups(ExprWithCleanups
*E
);
146 void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr
*E
);
147 void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr
*E
);
148 void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr
*E
);
150 void VisitOverloadExpr(OverloadExpr
*E
);
151 void VisitUnresolvedMemberExpr(UnresolvedMemberExpr
*E
);
152 void VisitUnresolvedLookupExpr(UnresolvedLookupExpr
*E
);
154 void VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr
*E
);
155 void VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr
*E
);
156 void VisitExpressionTraitExpr(ExpressionTraitExpr
*E
);
157 void VisitCXXNoexceptExpr(CXXNoexceptExpr
*E
);
158 void VisitPackExpansionExpr(PackExpansionExpr
*E
);
159 void VisitSizeOfPackExpr(SizeOfPackExpr
*E
);
160 void VisitSubstNonTypeTemplateParmPackExpr(
161 SubstNonTypeTemplateParmPackExpr
*E
);
162 void VisitOpaqueValueExpr(OpaqueValueExpr
*E
);
165 void VisitCUDAKernelCallExpr(CUDAKernelCallExpr
*E
);
170 AddExplicitTemplateArgumentList(const ExplicitTemplateArgumentList
&Args
) {
171 Writer
.AddSourceLocation(Args
.LAngleLoc
, Record
);
172 Writer
.AddSourceLocation(Args
.RAngleLoc
, Record
);
173 for (unsigned i
=0; i
!= Args
.NumTemplateArgs
; ++i
)
174 Writer
.AddTemplateArgumentLoc(Args
.getTemplateArgs()[i
], Record
);
177 void ASTStmtWriter::VisitStmt(Stmt
*S
) {
180 void ASTStmtWriter::VisitNullStmt(NullStmt
*S
) {
182 Writer
.AddSourceLocation(S
->getSemiLoc(), Record
);
183 Record
.push_back(S
->LeadingEmptyMacro
);
184 Code
= serialization::STMT_NULL
;
187 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt
*S
) {
189 Record
.push_back(S
->size());
190 for (CompoundStmt::body_iterator CS
= S
->body_begin(), CSEnd
= S
->body_end();
193 Writer
.AddSourceLocation(S
->getLBracLoc(), Record
);
194 Writer
.AddSourceLocation(S
->getRBracLoc(), Record
);
195 Code
= serialization::STMT_COMPOUND
;
198 void ASTStmtWriter::VisitSwitchCase(SwitchCase
*S
) {
200 Record
.push_back(Writer
.getSwitchCaseID(S
));
203 void ASTStmtWriter::VisitCaseStmt(CaseStmt
*S
) {
205 Writer
.AddStmt(S
->getLHS());
206 Writer
.AddStmt(S
->getRHS());
207 Writer
.AddStmt(S
->getSubStmt());
208 Writer
.AddSourceLocation(S
->getCaseLoc(), Record
);
209 Writer
.AddSourceLocation(S
->getEllipsisLoc(), Record
);
210 Writer
.AddSourceLocation(S
->getColonLoc(), Record
);
211 Code
= serialization::STMT_CASE
;
214 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt
*S
) {
216 Writer
.AddStmt(S
->getSubStmt());
217 Writer
.AddSourceLocation(S
->getDefaultLoc(), Record
);
218 Writer
.AddSourceLocation(S
->getColonLoc(), Record
);
219 Code
= serialization::STMT_DEFAULT
;
222 void ASTStmtWriter::VisitLabelStmt(LabelStmt
*S
) {
224 Writer
.AddDeclRef(S
->getDecl(), Record
);
225 Writer
.AddStmt(S
->getSubStmt());
226 Writer
.AddSourceLocation(S
->getIdentLoc(), Record
);
227 Code
= serialization::STMT_LABEL
;
230 void ASTStmtWriter::VisitIfStmt(IfStmt
*S
) {
232 Writer
.AddDeclRef(S
->getConditionVariable(), Record
);
233 Writer
.AddStmt(S
->getCond());
234 Writer
.AddStmt(S
->getThen());
235 Writer
.AddStmt(S
->getElse());
236 Writer
.AddSourceLocation(S
->getIfLoc(), Record
);
237 Writer
.AddSourceLocation(S
->getElseLoc(), Record
);
238 Code
= serialization::STMT_IF
;
241 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt
*S
) {
243 Writer
.AddDeclRef(S
->getConditionVariable(), Record
);
244 Writer
.AddStmt(S
->getCond());
245 Writer
.AddStmt(S
->getBody());
246 Writer
.AddSourceLocation(S
->getSwitchLoc(), Record
);
247 Record
.push_back(S
->isAllEnumCasesCovered());
248 for (SwitchCase
*SC
= S
->getSwitchCaseList(); SC
;
249 SC
= SC
->getNextSwitchCase())
250 Record
.push_back(Writer
.RecordSwitchCaseID(SC
));
251 Code
= serialization::STMT_SWITCH
;
254 void ASTStmtWriter::VisitWhileStmt(WhileStmt
*S
) {
256 Writer
.AddDeclRef(S
->getConditionVariable(), Record
);
257 Writer
.AddStmt(S
->getCond());
258 Writer
.AddStmt(S
->getBody());
259 Writer
.AddSourceLocation(S
->getWhileLoc(), Record
);
260 Code
= serialization::STMT_WHILE
;
263 void ASTStmtWriter::VisitDoStmt(DoStmt
*S
) {
265 Writer
.AddStmt(S
->getCond());
266 Writer
.AddStmt(S
->getBody());
267 Writer
.AddSourceLocation(S
->getDoLoc(), Record
);
268 Writer
.AddSourceLocation(S
->getWhileLoc(), Record
);
269 Writer
.AddSourceLocation(S
->getRParenLoc(), Record
);
270 Code
= serialization::STMT_DO
;
273 void ASTStmtWriter::VisitForStmt(ForStmt
*S
) {
275 Writer
.AddStmt(S
->getInit());
276 Writer
.AddStmt(S
->getCond());
277 Writer
.AddDeclRef(S
->getConditionVariable(), Record
);
278 Writer
.AddStmt(S
->getInc());
279 Writer
.AddStmt(S
->getBody());
280 Writer
.AddSourceLocation(S
->getForLoc(), Record
);
281 Writer
.AddSourceLocation(S
->getLParenLoc(), Record
);
282 Writer
.AddSourceLocation(S
->getRParenLoc(), Record
);
283 Code
= serialization::STMT_FOR
;
286 void ASTStmtWriter::VisitGotoStmt(GotoStmt
*S
) {
288 Writer
.AddDeclRef(S
->getLabel(), Record
);
289 Writer
.AddSourceLocation(S
->getGotoLoc(), Record
);
290 Writer
.AddSourceLocation(S
->getLabelLoc(), Record
);
291 Code
= serialization::STMT_GOTO
;
294 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt
*S
) {
296 Writer
.AddSourceLocation(S
->getGotoLoc(), Record
);
297 Writer
.AddSourceLocation(S
->getStarLoc(), Record
);
298 Writer
.AddStmt(S
->getTarget());
299 Code
= serialization::STMT_INDIRECT_GOTO
;
302 void ASTStmtWriter::VisitContinueStmt(ContinueStmt
*S
) {
304 Writer
.AddSourceLocation(S
->getContinueLoc(), Record
);
305 Code
= serialization::STMT_CONTINUE
;
308 void ASTStmtWriter::VisitBreakStmt(BreakStmt
*S
) {
310 Writer
.AddSourceLocation(S
->getBreakLoc(), Record
);
311 Code
= serialization::STMT_BREAK
;
314 void ASTStmtWriter::VisitReturnStmt(ReturnStmt
*S
) {
316 Writer
.AddStmt(S
->getRetValue());
317 Writer
.AddSourceLocation(S
->getReturnLoc(), Record
);
318 Writer
.AddDeclRef(S
->getNRVOCandidate(), Record
);
319 Code
= serialization::STMT_RETURN
;
322 void ASTStmtWriter::VisitDeclStmt(DeclStmt
*S
) {
324 Writer
.AddSourceLocation(S
->getStartLoc(), Record
);
325 Writer
.AddSourceLocation(S
->getEndLoc(), Record
);
326 DeclGroupRef DG
= S
->getDeclGroup();
327 for (DeclGroupRef::iterator D
= DG
.begin(), DEnd
= DG
.end(); D
!= DEnd
; ++D
)
328 Writer
.AddDeclRef(*D
, Record
);
329 Code
= serialization::STMT_DECL
;
332 void ASTStmtWriter::VisitAsmStmt(AsmStmt
*S
) {
334 Record
.push_back(S
->getNumOutputs());
335 Record
.push_back(S
->getNumInputs());
336 Record
.push_back(S
->getNumClobbers());
337 Writer
.AddSourceLocation(S
->getAsmLoc(), Record
);
338 Writer
.AddSourceLocation(S
->getRParenLoc(), Record
);
339 Record
.push_back(S
->isVolatile());
340 Record
.push_back(S
->isSimple());
341 Record
.push_back(S
->isMSAsm());
342 Writer
.AddStmt(S
->getAsmString());
345 for (unsigned I
= 0, N
= S
->getNumOutputs(); I
!= N
; ++I
) {
346 Writer
.AddIdentifierRef(S
->getOutputIdentifier(I
), Record
);
347 Writer
.AddStmt(S
->getOutputConstraintLiteral(I
));
348 Writer
.AddStmt(S
->getOutputExpr(I
));
352 for (unsigned I
= 0, N
= S
->getNumInputs(); I
!= N
; ++I
) {
353 Writer
.AddIdentifierRef(S
->getInputIdentifier(I
), Record
);
354 Writer
.AddStmt(S
->getInputConstraintLiteral(I
));
355 Writer
.AddStmt(S
->getInputExpr(I
));
359 for (unsigned I
= 0, N
= S
->getNumClobbers(); I
!= N
; ++I
)
360 Writer
.AddStmt(S
->getClobber(I
));
362 Code
= serialization::STMT_ASM
;
365 void ASTStmtWriter::VisitExpr(Expr
*E
) {
367 Writer
.AddTypeRef(E
->getType(), Record
);
368 Record
.push_back(E
->isTypeDependent());
369 Record
.push_back(E
->isValueDependent());
370 Record
.push_back(E
->containsUnexpandedParameterPack());
371 Record
.push_back(E
->getValueKind());
372 Record
.push_back(E
->getObjectKind());
375 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr
*E
) {
377 Writer
.AddSourceLocation(E
->getLocation(), Record
);
378 Record
.push_back(E
->getIdentType()); // FIXME: stable encoding
379 Code
= serialization::EXPR_PREDEFINED
;
382 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr
*E
) {
385 Record
.push_back(E
->hasQualifier());
386 Record
.push_back(E
->hasExplicitTemplateArgs());
388 if (E
->hasExplicitTemplateArgs()) {
389 unsigned NumTemplateArgs
= E
->getNumTemplateArgs();
390 Record
.push_back(NumTemplateArgs
);
393 if (E
->hasQualifier())
394 Writer
.AddNestedNameSpecifierLoc(E
->getQualifierLoc(), Record
);
396 if (E
->hasExplicitTemplateArgs())
397 AddExplicitTemplateArgumentList(E
->getExplicitTemplateArgs());
399 Writer
.AddDeclRef(E
->getDecl(), Record
);
400 Writer
.AddSourceLocation(E
->getLocation(), Record
);
401 Writer
.AddDeclarationNameLoc(E
->DNLoc
, E
->getDecl()->getDeclName(), Record
);
402 Code
= serialization::EXPR_DECL_REF
;
405 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral
*E
) {
407 Writer
.AddSourceLocation(E
->getLocation(), Record
);
408 Writer
.AddAPInt(E
->getValue(), Record
);
409 Code
= serialization::EXPR_INTEGER_LITERAL
;
412 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral
*E
) {
414 Writer
.AddAPFloat(E
->getValue(), Record
);
415 Record
.push_back(E
->isExact());
416 Writer
.AddSourceLocation(E
->getLocation(), Record
);
417 Code
= serialization::EXPR_FLOATING_LITERAL
;
420 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral
*E
) {
422 Writer
.AddStmt(E
->getSubExpr());
423 Code
= serialization::EXPR_IMAGINARY_LITERAL
;
426 void ASTStmtWriter::VisitStringLiteral(StringLiteral
*E
) {
428 Record
.push_back(E
->getByteLength());
429 Record
.push_back(E
->getNumConcatenated());
430 Record
.push_back(E
->isWide());
431 Record
.push_back(E
->isPascal());
432 // FIXME: String data should be stored as a blob at the end of the
433 // StringLiteral. However, we can't do so now because we have no
434 // provision for coping with abbreviations when we're jumping around
435 // the AST file during deserialization.
436 Record
.append(E
->getString().begin(), E
->getString().end());
437 for (unsigned I
= 0, N
= E
->getNumConcatenated(); I
!= N
; ++I
)
438 Writer
.AddSourceLocation(E
->getStrTokenLoc(I
), Record
);
439 Code
= serialization::EXPR_STRING_LITERAL
;
442 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral
*E
) {
444 Record
.push_back(E
->getValue());
445 Writer
.AddSourceLocation(E
->getLocation(), Record
);
446 Record
.push_back(E
->isWide());
447 Code
= serialization::EXPR_CHARACTER_LITERAL
;
450 void ASTStmtWriter::VisitParenExpr(ParenExpr
*E
) {
452 Writer
.AddSourceLocation(E
->getLParen(), Record
);
453 Writer
.AddSourceLocation(E
->getRParen(), Record
);
454 Writer
.AddStmt(E
->getSubExpr());
455 Code
= serialization::EXPR_PAREN
;
458 void ASTStmtWriter::VisitParenListExpr(ParenListExpr
*E
) {
460 Record
.push_back(E
->NumExprs
);
461 for (unsigned i
=0; i
!= E
->NumExprs
; ++i
)
462 Writer
.AddStmt(E
->Exprs
[i
]);
463 Writer
.AddSourceLocation(E
->LParenLoc
, Record
);
464 Writer
.AddSourceLocation(E
->RParenLoc
, Record
);
465 Code
= serialization::EXPR_PAREN_LIST
;
468 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator
*E
) {
470 Writer
.AddStmt(E
->getSubExpr());
471 Record
.push_back(E
->getOpcode()); // FIXME: stable encoding
472 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
473 Code
= serialization::EXPR_UNARY_OPERATOR
;
476 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr
*E
) {
478 Record
.push_back(E
->getNumComponents());
479 Record
.push_back(E
->getNumExpressions());
480 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
481 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
482 Writer
.AddTypeSourceInfo(E
->getTypeSourceInfo(), Record
);
483 for (unsigned I
= 0, N
= E
->getNumComponents(); I
!= N
; ++I
) {
484 const OffsetOfExpr::OffsetOfNode
&ON
= E
->getComponent(I
);
485 Record
.push_back(ON
.getKind()); // FIXME: Stable encoding
486 Writer
.AddSourceLocation(ON
.getSourceRange().getBegin(), Record
);
487 Writer
.AddSourceLocation(ON
.getSourceRange().getEnd(), Record
);
488 switch (ON
.getKind()) {
489 case OffsetOfExpr::OffsetOfNode::Array
:
490 Record
.push_back(ON
.getArrayExprIndex());
493 case OffsetOfExpr::OffsetOfNode::Field
:
494 Writer
.AddDeclRef(ON
.getField(), Record
);
497 case OffsetOfExpr::OffsetOfNode::Identifier
:
498 Writer
.AddIdentifierRef(ON
.getFieldName(), Record
);
501 case OffsetOfExpr::OffsetOfNode::Base
:
502 Writer
.AddCXXBaseSpecifier(*ON
.getBase(), Record
);
506 for (unsigned I
= 0, N
= E
->getNumExpressions(); I
!= N
; ++I
)
507 Writer
.AddStmt(E
->getIndexExpr(I
));
508 Code
= serialization::EXPR_OFFSETOF
;
511 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr
*E
) {
513 Record
.push_back(E
->getKind());
514 if (E
->isArgumentType())
515 Writer
.AddTypeSourceInfo(E
->getArgumentTypeInfo(), Record
);
518 Writer
.AddStmt(E
->getArgumentExpr());
520 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
521 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
522 Code
= serialization::EXPR_SIZEOF_ALIGN_OF
;
525 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr
*E
) {
527 Writer
.AddStmt(E
->getLHS());
528 Writer
.AddStmt(E
->getRHS());
529 Writer
.AddSourceLocation(E
->getRBracketLoc(), Record
);
530 Code
= serialization::EXPR_ARRAY_SUBSCRIPT
;
533 void ASTStmtWriter::VisitCallExpr(CallExpr
*E
) {
535 Record
.push_back(E
->getNumArgs());
536 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
537 Writer
.AddStmt(E
->getCallee());
538 for (CallExpr::arg_iterator Arg
= E
->arg_begin(), ArgEnd
= E
->arg_end();
539 Arg
!= ArgEnd
; ++Arg
)
540 Writer
.AddStmt(*Arg
);
541 Code
= serialization::EXPR_CALL
;
544 void ASTStmtWriter::VisitMemberExpr(MemberExpr
*E
) {
545 // Don't call VisitExpr, we'll write everything here.
547 Record
.push_back(E
->hasQualifier());
548 if (E
->hasQualifier())
549 Writer
.AddNestedNameSpecifierLoc(E
->getQualifierLoc(), Record
);
551 Record
.push_back(E
->hasExplicitTemplateArgs());
552 if (E
->hasExplicitTemplateArgs()) {
553 unsigned NumTemplateArgs
= E
->getNumTemplateArgs();
554 Record
.push_back(NumTemplateArgs
);
555 Writer
.AddSourceLocation(E
->getLAngleLoc(), Record
);
556 Writer
.AddSourceLocation(E
->getRAngleLoc(), Record
);
557 for (unsigned i
=0; i
!= NumTemplateArgs
; ++i
)
558 Writer
.AddTemplateArgumentLoc(E
->getTemplateArgs()[i
], Record
);
561 DeclAccessPair FoundDecl
= E
->getFoundDecl();
562 Writer
.AddDeclRef(FoundDecl
.getDecl(), Record
);
563 Record
.push_back(FoundDecl
.getAccess());
565 Writer
.AddTypeRef(E
->getType(), Record
);
566 Record
.push_back(E
->getValueKind());
567 Record
.push_back(E
->getObjectKind());
568 Writer
.AddStmt(E
->getBase());
569 Writer
.AddDeclRef(E
->getMemberDecl(), Record
);
570 Writer
.AddSourceLocation(E
->getMemberLoc(), Record
);
571 Record
.push_back(E
->isArrow());
572 Writer
.AddDeclarationNameLoc(E
->MemberDNLoc
,
573 E
->getMemberDecl()->getDeclName(), Record
);
574 Code
= serialization::EXPR_MEMBER
;
577 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr
*E
) {
579 Writer
.AddStmt(E
->getBase());
580 Writer
.AddSourceLocation(E
->getIsaMemberLoc(), Record
);
581 Record
.push_back(E
->isArrow());
582 Code
= serialization::EXPR_OBJC_ISA
;
585 void ASTStmtWriter::VisitCastExpr(CastExpr
*E
) {
587 Record
.push_back(E
->path_size());
588 Writer
.AddStmt(E
->getSubExpr());
589 Record
.push_back(E
->getCastKind()); // FIXME: stable encoding
591 for (CastExpr::path_iterator
592 PI
= E
->path_begin(), PE
= E
->path_end(); PI
!= PE
; ++PI
)
593 Writer
.AddCXXBaseSpecifier(**PI
, Record
);
596 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator
*E
) {
598 Writer
.AddStmt(E
->getLHS());
599 Writer
.AddStmt(E
->getRHS());
600 Record
.push_back(E
->getOpcode()); // FIXME: stable encoding
601 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
602 Code
= serialization::EXPR_BINARY_OPERATOR
;
605 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator
*E
) {
606 VisitBinaryOperator(E
);
607 Writer
.AddTypeRef(E
->getComputationLHSType(), Record
);
608 Writer
.AddTypeRef(E
->getComputationResultType(), Record
);
609 Code
= serialization::EXPR_COMPOUND_ASSIGN_OPERATOR
;
612 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator
*E
) {
614 Writer
.AddStmt(E
->getCond());
615 Writer
.AddStmt(E
->getLHS());
616 Writer
.AddStmt(E
->getRHS());
617 Writer
.AddSourceLocation(E
->getQuestionLoc(), Record
);
618 Writer
.AddSourceLocation(E
->getColonLoc(), Record
);
619 Code
= serialization::EXPR_CONDITIONAL_OPERATOR
;
623 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator
*E
) {
625 Writer
.AddStmt(E
->getOpaqueValue());
626 Writer
.AddStmt(E
->getCommon());
627 Writer
.AddStmt(E
->getCond());
628 Writer
.AddStmt(E
->getTrueExpr());
629 Writer
.AddStmt(E
->getFalseExpr());
630 Writer
.AddSourceLocation(E
->getQuestionLoc(), Record
);
631 Writer
.AddSourceLocation(E
->getColonLoc(), Record
);
632 Code
= serialization::EXPR_BINARY_CONDITIONAL_OPERATOR
;
635 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr
*E
) {
637 Code
= serialization::EXPR_IMPLICIT_CAST
;
640 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr
*E
) {
642 Writer
.AddTypeSourceInfo(E
->getTypeInfoAsWritten(), Record
);
645 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr
*E
) {
646 VisitExplicitCastExpr(E
);
647 Writer
.AddSourceLocation(E
->getLParenLoc(), Record
);
648 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
649 Code
= serialization::EXPR_CSTYLE_CAST
;
652 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr
*E
) {
654 Writer
.AddSourceLocation(E
->getLParenLoc(), Record
);
655 Writer
.AddTypeSourceInfo(E
->getTypeSourceInfo(), Record
);
656 Writer
.AddStmt(E
->getInitializer());
657 Record
.push_back(E
->isFileScope());
658 Code
= serialization::EXPR_COMPOUND_LITERAL
;
661 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr
*E
) {
663 Writer
.AddStmt(E
->getBase());
664 Writer
.AddIdentifierRef(&E
->getAccessor(), Record
);
665 Writer
.AddSourceLocation(E
->getAccessorLoc(), Record
);
666 Code
= serialization::EXPR_EXT_VECTOR_ELEMENT
;
669 void ASTStmtWriter::VisitInitListExpr(InitListExpr
*E
) {
671 Writer
.AddStmt(E
->getSyntacticForm());
672 Writer
.AddSourceLocation(E
->getLBraceLoc(), Record
);
673 Writer
.AddSourceLocation(E
->getRBraceLoc(), Record
);
674 bool isArrayFiller
= E
->ArrayFillerOrUnionFieldInit
.is
<Expr
*>();
675 Record
.push_back(isArrayFiller
);
677 Writer
.AddStmt(E
->getArrayFiller());
679 Writer
.AddDeclRef(E
->getInitializedFieldInUnion(), Record
);
680 Record
.push_back(E
->hadArrayRangeDesignator());
681 Record
.push_back(E
->getNumInits());
683 // ArrayFiller may have filled "holes" due to designated initializer.
684 // Replace them by 0 to indicate that the filler goes in that place.
685 Expr
*filler
= E
->getArrayFiller();
686 for (unsigned I
= 0, N
= E
->getNumInits(); I
!= N
; ++I
)
687 Writer
.AddStmt(E
->getInit(I
) != filler
? E
->getInit(I
) : 0);
689 for (unsigned I
= 0, N
= E
->getNumInits(); I
!= N
; ++I
)
690 Writer
.AddStmt(E
->getInit(I
));
692 Code
= serialization::EXPR_INIT_LIST
;
695 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr
*E
) {
697 Record
.push_back(E
->getNumSubExprs());
698 for (unsigned I
= 0, N
= E
->getNumSubExprs(); I
!= N
; ++I
)
699 Writer
.AddStmt(E
->getSubExpr(I
));
700 Writer
.AddSourceLocation(E
->getEqualOrColonLoc(), Record
);
701 Record
.push_back(E
->usesGNUSyntax());
702 for (DesignatedInitExpr::designators_iterator D
= E
->designators_begin(),
703 DEnd
= E
->designators_end();
705 if (D
->isFieldDesignator()) {
706 if (FieldDecl
*Field
= D
->getField()) {
707 Record
.push_back(serialization::DESIG_FIELD_DECL
);
708 Writer
.AddDeclRef(Field
, Record
);
710 Record
.push_back(serialization::DESIG_FIELD_NAME
);
711 Writer
.AddIdentifierRef(D
->getFieldName(), Record
);
713 Writer
.AddSourceLocation(D
->getDotLoc(), Record
);
714 Writer
.AddSourceLocation(D
->getFieldLoc(), Record
);
715 } else if (D
->isArrayDesignator()) {
716 Record
.push_back(serialization::DESIG_ARRAY
);
717 Record
.push_back(D
->getFirstExprIndex());
718 Writer
.AddSourceLocation(D
->getLBracketLoc(), Record
);
719 Writer
.AddSourceLocation(D
->getRBracketLoc(), Record
);
721 assert(D
->isArrayRangeDesignator() && "Unknown designator");
722 Record
.push_back(serialization::DESIG_ARRAY_RANGE
);
723 Record
.push_back(D
->getFirstExprIndex());
724 Writer
.AddSourceLocation(D
->getLBracketLoc(), Record
);
725 Writer
.AddSourceLocation(D
->getEllipsisLoc(), Record
);
726 Writer
.AddSourceLocation(D
->getRBracketLoc(), Record
);
729 Code
= serialization::EXPR_DESIGNATED_INIT
;
732 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr
*E
) {
734 Code
= serialization::EXPR_IMPLICIT_VALUE_INIT
;
737 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr
*E
) {
739 Writer
.AddStmt(E
->getSubExpr());
740 Writer
.AddTypeSourceInfo(E
->getWrittenTypeInfo(), Record
);
741 Writer
.AddSourceLocation(E
->getBuiltinLoc(), Record
);
742 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
743 Code
= serialization::EXPR_VA_ARG
;
746 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr
*E
) {
748 Writer
.AddSourceLocation(E
->getAmpAmpLoc(), Record
);
749 Writer
.AddSourceLocation(E
->getLabelLoc(), Record
);
750 Writer
.AddDeclRef(E
->getLabel(), Record
);
751 Code
= serialization::EXPR_ADDR_LABEL
;
754 void ASTStmtWriter::VisitStmtExpr(StmtExpr
*E
) {
756 Writer
.AddStmt(E
->getSubStmt());
757 Writer
.AddSourceLocation(E
->getLParenLoc(), Record
);
758 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
759 Code
= serialization::EXPR_STMT
;
762 void ASTStmtWriter::VisitChooseExpr(ChooseExpr
*E
) {
764 Writer
.AddStmt(E
->getCond());
765 Writer
.AddStmt(E
->getLHS());
766 Writer
.AddStmt(E
->getRHS());
767 Writer
.AddSourceLocation(E
->getBuiltinLoc(), Record
);
768 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
769 Code
= serialization::EXPR_CHOOSE
;
772 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr
*E
) {
774 Writer
.AddSourceLocation(E
->getTokenLocation(), Record
);
775 Code
= serialization::EXPR_GNU_NULL
;
778 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr
*E
) {
780 Record
.push_back(E
->getNumSubExprs());
781 for (unsigned I
= 0, N
= E
->getNumSubExprs(); I
!= N
; ++I
)
782 Writer
.AddStmt(E
->getExpr(I
));
783 Writer
.AddSourceLocation(E
->getBuiltinLoc(), Record
);
784 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
785 Code
= serialization::EXPR_SHUFFLE_VECTOR
;
788 void ASTStmtWriter::VisitBlockExpr(BlockExpr
*E
) {
790 Writer
.AddDeclRef(E
->getBlockDecl(), Record
);
791 Code
= serialization::EXPR_BLOCK
;
794 void ASTStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr
*E
) {
796 Writer
.AddDeclRef(E
->getDecl(), Record
);
797 Writer
.AddSourceLocation(E
->getLocation(), Record
);
798 Record
.push_back(E
->isByRef());
799 Record
.push_back(E
->isConstQualAdded());
800 Code
= serialization::EXPR_BLOCK_DECL_REF
;
803 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr
*E
) {
805 Record
.push_back(E
->getNumAssocs());
807 Writer
.AddStmt(E
->getControllingExpr());
808 for (unsigned I
= 0, N
= E
->getNumAssocs(); I
!= N
; ++I
) {
809 Writer
.AddTypeSourceInfo(E
->getAssocTypeSourceInfo(I
), Record
);
810 Writer
.AddStmt(E
->getAssocExpr(I
));
812 Record
.push_back(E
->isResultDependent() ? -1U : E
->getResultIndex());
814 Writer
.AddSourceLocation(E
->getGenericLoc(), Record
);
815 Writer
.AddSourceLocation(E
->getDefaultLoc(), Record
);
816 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
817 Code
= serialization::EXPR_GENERIC_SELECTION
;
820 //===----------------------------------------------------------------------===//
821 // Objective-C Expressions and Statements.
822 //===----------------------------------------------------------------------===//
824 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral
*E
) {
826 Writer
.AddStmt(E
->getString());
827 Writer
.AddSourceLocation(E
->getAtLoc(), Record
);
828 Code
= serialization::EXPR_OBJC_STRING_LITERAL
;
831 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr
*E
) {
833 Writer
.AddTypeSourceInfo(E
->getEncodedTypeSourceInfo(), Record
);
834 Writer
.AddSourceLocation(E
->getAtLoc(), Record
);
835 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
836 Code
= serialization::EXPR_OBJC_ENCODE
;
839 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr
*E
) {
841 Writer
.AddSelectorRef(E
->getSelector(), Record
);
842 Writer
.AddSourceLocation(E
->getAtLoc(), Record
);
843 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
844 Code
= serialization::EXPR_OBJC_SELECTOR_EXPR
;
847 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr
*E
) {
849 Writer
.AddDeclRef(E
->getProtocol(), Record
);
850 Writer
.AddSourceLocation(E
->getAtLoc(), Record
);
851 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
852 Code
= serialization::EXPR_OBJC_PROTOCOL_EXPR
;
855 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr
*E
) {
857 Writer
.AddDeclRef(E
->getDecl(), Record
);
858 Writer
.AddSourceLocation(E
->getLocation(), Record
);
859 Writer
.AddStmt(E
->getBase());
860 Record
.push_back(E
->isArrow());
861 Record
.push_back(E
->isFreeIvar());
862 Code
= serialization::EXPR_OBJC_IVAR_REF_EXPR
;
865 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr
*E
) {
867 Record
.push_back(E
->isImplicitProperty());
868 if (E
->isImplicitProperty()) {
869 Writer
.AddDeclRef(E
->getImplicitPropertyGetter(), Record
);
870 Writer
.AddDeclRef(E
->getImplicitPropertySetter(), Record
);
872 Writer
.AddDeclRef(E
->getExplicitProperty(), Record
);
874 Writer
.AddSourceLocation(E
->getLocation(), Record
);
875 Writer
.AddSourceLocation(E
->getReceiverLocation(), Record
);
876 if (E
->isObjectReceiver()) {
878 Writer
.AddStmt(E
->getBase());
879 } else if (E
->isSuperReceiver()) {
881 Writer
.AddTypeRef(E
->getSuperReceiverType(), Record
);
884 Writer
.AddDeclRef(E
->getClassReceiver(), Record
);
887 Code
= serialization::EXPR_OBJC_PROPERTY_REF_EXPR
;
890 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr
*E
) {
892 Record
.push_back(E
->getNumArgs());
893 Record
.push_back((unsigned)E
->getReceiverKind()); // FIXME: stable encoding
894 switch (E
->getReceiverKind()) {
895 case ObjCMessageExpr::Instance
:
896 Writer
.AddStmt(E
->getInstanceReceiver());
899 case ObjCMessageExpr::Class
:
900 Writer
.AddTypeSourceInfo(E
->getClassReceiverTypeInfo(), Record
);
903 case ObjCMessageExpr::SuperClass
:
904 case ObjCMessageExpr::SuperInstance
:
905 Writer
.AddTypeRef(E
->getSuperType(), Record
);
906 Writer
.AddSourceLocation(E
->getSuperLoc(), Record
);
910 if (E
->getMethodDecl()) {
912 Writer
.AddDeclRef(E
->getMethodDecl(), Record
);
915 Writer
.AddSelectorRef(E
->getSelector(), Record
);
918 Writer
.AddSourceLocation(E
->getLeftLoc(), Record
);
919 Writer
.AddSourceLocation(E
->getRightLoc(), Record
);
920 Writer
.AddSourceLocation(E
->getSelectorLoc(), Record
);
922 for (CallExpr::arg_iterator Arg
= E
->arg_begin(), ArgEnd
= E
->arg_end();
923 Arg
!= ArgEnd
; ++Arg
)
924 Writer
.AddStmt(*Arg
);
925 Code
= serialization::EXPR_OBJC_MESSAGE_EXPR
;
928 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt
*S
) {
930 Writer
.AddStmt(S
->getElement());
931 Writer
.AddStmt(S
->getCollection());
932 Writer
.AddStmt(S
->getBody());
933 Writer
.AddSourceLocation(S
->getForLoc(), Record
);
934 Writer
.AddSourceLocation(S
->getRParenLoc(), Record
);
935 Code
= serialization::STMT_OBJC_FOR_COLLECTION
;
938 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt
*S
) {
939 Writer
.AddStmt(S
->getCatchBody());
940 Writer
.AddDeclRef(S
->getCatchParamDecl(), Record
);
941 Writer
.AddSourceLocation(S
->getAtCatchLoc(), Record
);
942 Writer
.AddSourceLocation(S
->getRParenLoc(), Record
);
943 Code
= serialization::STMT_OBJC_CATCH
;
946 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt
*S
) {
947 Writer
.AddStmt(S
->getFinallyBody());
948 Writer
.AddSourceLocation(S
->getAtFinallyLoc(), Record
);
949 Code
= serialization::STMT_OBJC_FINALLY
;
952 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt
*S
) {
953 Record
.push_back(S
->getNumCatchStmts());
954 Record
.push_back(S
->getFinallyStmt() != 0);
955 Writer
.AddStmt(S
->getTryBody());
956 for (unsigned I
= 0, N
= S
->getNumCatchStmts(); I
!= N
; ++I
)
957 Writer
.AddStmt(S
->getCatchStmt(I
));
958 if (S
->getFinallyStmt())
959 Writer
.AddStmt(S
->getFinallyStmt());
960 Writer
.AddSourceLocation(S
->getAtTryLoc(), Record
);
961 Code
= serialization::STMT_OBJC_AT_TRY
;
964 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt
*S
) {
965 Writer
.AddStmt(S
->getSynchExpr());
966 Writer
.AddStmt(S
->getSynchBody());
967 Writer
.AddSourceLocation(S
->getAtSynchronizedLoc(), Record
);
968 Code
= serialization::STMT_OBJC_AT_SYNCHRONIZED
;
971 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt
*S
) {
972 Writer
.AddStmt(S
->getThrowExpr());
973 Writer
.AddSourceLocation(S
->getThrowLoc(), Record
);
974 Code
= serialization::STMT_OBJC_AT_THROW
;
977 //===----------------------------------------------------------------------===//
978 // C++ Expressions and Statements.
979 //===----------------------------------------------------------------------===//
981 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt
*S
) {
983 Writer
.AddSourceLocation(S
->getCatchLoc(), Record
);
984 Writer
.AddDeclRef(S
->getExceptionDecl(), Record
);
985 Writer
.AddStmt(S
->getHandlerBlock());
986 Code
= serialization::STMT_CXX_CATCH
;
989 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt
*S
) {
991 Record
.push_back(S
->getNumHandlers());
992 Writer
.AddSourceLocation(S
->getTryLoc(), Record
);
993 Writer
.AddStmt(S
->getTryBlock());
994 for (unsigned i
= 0, e
= S
->getNumHandlers(); i
!= e
; ++i
)
995 Writer
.AddStmt(S
->getHandler(i
));
996 Code
= serialization::STMT_CXX_TRY
;
999 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt
*S
) {
1001 Writer
.AddSourceLocation(S
->getForLoc(), Record
);
1002 Writer
.AddSourceLocation(S
->getColonLoc(), Record
);
1003 Writer
.AddSourceLocation(S
->getRParenLoc(), Record
);
1004 Writer
.AddStmt(S
->getRangeStmt());
1005 Writer
.AddStmt(S
->getBeginEndStmt());
1006 Writer
.AddStmt(S
->getCond());
1007 Writer
.AddStmt(S
->getInc());
1008 Writer
.AddStmt(S
->getLoopVarStmt());
1009 Writer
.AddStmt(S
->getBody());
1010 Code
= serialization::STMT_CXX_FOR_RANGE
;
1013 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr
*E
) {
1015 Record
.push_back(E
->getOperator());
1016 Code
= serialization::EXPR_CXX_OPERATOR_CALL
;
1019 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr
*E
) {
1021 Code
= serialization::EXPR_CXX_MEMBER_CALL
;
1024 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr
*E
) {
1026 Record
.push_back(E
->getNumArgs());
1027 for (unsigned I
= 0, N
= E
->getNumArgs(); I
!= N
; ++I
)
1028 Writer
.AddStmt(E
->getArg(I
));
1029 Writer
.AddDeclRef(E
->getConstructor(), Record
);
1030 Writer
.AddSourceLocation(E
->getLocation(), Record
);
1031 Record
.push_back(E
->isElidable());
1032 Record
.push_back(E
->requiresZeroInitialization());
1033 Record
.push_back(E
->getConstructionKind()); // FIXME: stable encoding
1034 Writer
.AddSourceRange(E
->getParenRange(), Record
);
1035 Code
= serialization::EXPR_CXX_CONSTRUCT
;
1038 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr
*E
) {
1039 VisitCXXConstructExpr(E
);
1040 Writer
.AddTypeSourceInfo(E
->getTypeSourceInfo(), Record
);
1041 Code
= serialization::EXPR_CXX_TEMPORARY_OBJECT
;
1044 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr
*E
) {
1045 VisitExplicitCastExpr(E
);
1046 Writer
.AddSourceRange(SourceRange(E
->getOperatorLoc(), E
->getRParenLoc()),
1050 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr
*E
) {
1051 VisitCXXNamedCastExpr(E
);
1052 Code
= serialization::EXPR_CXX_STATIC_CAST
;
1055 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr
*E
) {
1056 VisitCXXNamedCastExpr(E
);
1057 Code
= serialization::EXPR_CXX_DYNAMIC_CAST
;
1060 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr
*E
) {
1061 VisitCXXNamedCastExpr(E
);
1062 Code
= serialization::EXPR_CXX_REINTERPRET_CAST
;
1065 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr
*E
) {
1066 VisitCXXNamedCastExpr(E
);
1067 Code
= serialization::EXPR_CXX_CONST_CAST
;
1070 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr
*E
) {
1071 VisitExplicitCastExpr(E
);
1072 Writer
.AddSourceLocation(E
->getTypeBeginLoc(), Record
);
1073 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
1074 Code
= serialization::EXPR_CXX_FUNCTIONAL_CAST
;
1077 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr
*E
) {
1079 Record
.push_back(E
->getValue());
1080 Writer
.AddSourceLocation(E
->getLocation(), Record
);
1081 Code
= serialization::EXPR_CXX_BOOL_LITERAL
;
1084 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr
*E
) {
1086 Writer
.AddSourceLocation(E
->getLocation(), Record
);
1087 Code
= serialization::EXPR_CXX_NULL_PTR_LITERAL
;
1090 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr
*E
) {
1092 Writer
.AddSourceRange(E
->getSourceRange(), Record
);
1093 if (E
->isTypeOperand()) {
1094 Writer
.AddTypeSourceInfo(E
->getTypeOperandSourceInfo(), Record
);
1095 Code
= serialization::EXPR_CXX_TYPEID_TYPE
;
1097 Writer
.AddStmt(E
->getExprOperand());
1098 Code
= serialization::EXPR_CXX_TYPEID_EXPR
;
1102 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr
*E
) {
1104 Writer
.AddSourceRange(E
->getSourceRange(), Record
);
1105 if (E
->isTypeOperand()) {
1106 Writer
.AddTypeSourceInfo(E
->getTypeOperandSourceInfo(), Record
);
1107 Code
= serialization::EXPR_CXX_UUIDOF_TYPE
;
1109 Writer
.AddStmt(E
->getExprOperand());
1110 Code
= serialization::EXPR_CXX_UUIDOF_EXPR
;
1114 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr
*E
) {
1116 Writer
.AddSourceLocation(E
->getLocation(), Record
);
1117 Record
.push_back(E
->isImplicit());
1118 Code
= serialization::EXPR_CXX_THIS
;
1121 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr
*E
) {
1123 Writer
.AddSourceLocation(E
->getThrowLoc(), Record
);
1124 Writer
.AddStmt(E
->getSubExpr());
1125 Code
= serialization::EXPR_CXX_THROW
;
1128 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr
*E
) {
1131 bool HasOtherExprStored
= E
->Param
.getInt();
1132 // Store these first, the reader reads them before creation.
1133 Record
.push_back(HasOtherExprStored
);
1134 if (HasOtherExprStored
)
1135 Writer
.AddStmt(E
->getExpr());
1136 Writer
.AddDeclRef(E
->getParam(), Record
);
1137 Writer
.AddSourceLocation(E
->getUsedLocation(), Record
);
1139 Code
= serialization::EXPR_CXX_DEFAULT_ARG
;
1142 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr
*E
) {
1144 Writer
.AddCXXTemporary(E
->getTemporary(), Record
);
1145 Writer
.AddStmt(E
->getSubExpr());
1146 Code
= serialization::EXPR_CXX_BIND_TEMPORARY
;
1149 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr
*E
) {
1151 Writer
.AddTypeSourceInfo(E
->getTypeSourceInfo(), Record
);
1152 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
1153 Code
= serialization::EXPR_CXX_SCALAR_VALUE_INIT
;
1156 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr
*E
) {
1158 Record
.push_back(E
->isGlobalNew());
1159 Record
.push_back(E
->hasInitializer());
1160 Record
.push_back(E
->doesUsualArrayDeleteWantSize());
1161 Record
.push_back(E
->isArray());
1162 Record
.push_back(E
->getNumPlacementArgs());
1163 Record
.push_back(E
->getNumConstructorArgs());
1164 Writer
.AddDeclRef(E
->getOperatorNew(), Record
);
1165 Writer
.AddDeclRef(E
->getOperatorDelete(), Record
);
1166 Writer
.AddDeclRef(E
->getConstructor(), Record
);
1167 Writer
.AddTypeSourceInfo(E
->getAllocatedTypeSourceInfo(), Record
);
1168 Writer
.AddSourceRange(E
->getTypeIdParens(), Record
);
1169 Writer
.AddSourceLocation(E
->getStartLoc(), Record
);
1170 Writer
.AddSourceLocation(E
->getEndLoc(), Record
);
1171 Writer
.AddSourceLocation(E
->getConstructorLParen(), Record
);
1172 Writer
.AddSourceLocation(E
->getConstructorRParen(), Record
);
1173 for (CXXNewExpr::arg_iterator I
= E
->raw_arg_begin(), e
= E
->raw_arg_end();
1177 Code
= serialization::EXPR_CXX_NEW
;
1180 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr
*E
) {
1182 Record
.push_back(E
->isGlobalDelete());
1183 Record
.push_back(E
->isArrayForm());
1184 Record
.push_back(E
->isArrayFormAsWritten());
1185 Record
.push_back(E
->doesUsualArrayDeleteWantSize());
1186 Writer
.AddDeclRef(E
->getOperatorDelete(), Record
);
1187 Writer
.AddStmt(E
->getArgument());
1188 Writer
.AddSourceLocation(E
->getSourceRange().getBegin(), Record
);
1190 Code
= serialization::EXPR_CXX_DELETE
;
1193 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr
*E
) {
1196 Writer
.AddStmt(E
->getBase());
1197 Record
.push_back(E
->isArrow());
1198 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
1199 Writer
.AddNestedNameSpecifierLoc(E
->getQualifierLoc(), Record
);
1200 Writer
.AddTypeSourceInfo(E
->getScopeTypeInfo(), Record
);
1201 Writer
.AddSourceLocation(E
->getColonColonLoc(), Record
);
1202 Writer
.AddSourceLocation(E
->getTildeLoc(), Record
);
1204 // PseudoDestructorTypeStorage.
1205 Writer
.AddIdentifierRef(E
->getDestroyedTypeIdentifier(), Record
);
1206 if (E
->getDestroyedTypeIdentifier())
1207 Writer
.AddSourceLocation(E
->getDestroyedTypeLoc(), Record
);
1209 Writer
.AddTypeSourceInfo(E
->getDestroyedTypeInfo(), Record
);
1211 Code
= serialization::EXPR_CXX_PSEUDO_DESTRUCTOR
;
1214 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups
*E
) {
1216 Record
.push_back(E
->getNumTemporaries());
1217 for (unsigned i
= 0, e
= E
->getNumTemporaries(); i
!= e
; ++i
)
1218 Writer
.AddCXXTemporary(E
->getTemporary(i
), Record
);
1220 Writer
.AddStmt(E
->getSubExpr());
1221 Code
= serialization::EXPR_EXPR_WITH_CLEANUPS
;
1225 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr
*E
){
1228 // Don't emit anything here, hasExplicitTemplateArgs() must be
1231 Record
.push_back(E
->hasExplicitTemplateArgs());
1232 if (E
->hasExplicitTemplateArgs()) {
1233 const ExplicitTemplateArgumentList
&Args
= E
->getExplicitTemplateArgs();
1234 Record
.push_back(Args
.NumTemplateArgs
);
1235 AddExplicitTemplateArgumentList(Args
);
1238 if (!E
->isImplicitAccess())
1239 Writer
.AddStmt(E
->getBase());
1242 Writer
.AddTypeRef(E
->getBaseType(), Record
);
1243 Record
.push_back(E
->isArrow());
1244 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
1245 Writer
.AddNestedNameSpecifierLoc(E
->getQualifierLoc(), Record
);
1246 Writer
.AddDeclRef(E
->getFirstQualifierFoundInScope(), Record
);
1247 Writer
.AddDeclarationNameInfo(E
->MemberNameInfo
, Record
);
1248 Code
= serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER
;
1252 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr
*E
) {
1255 // Don't emit anything here, hasExplicitTemplateArgs() must be
1257 Record
.push_back(E
->hasExplicitTemplateArgs());
1258 if (E
->hasExplicitTemplateArgs()) {
1259 const ExplicitTemplateArgumentList
&Args
= E
->getExplicitTemplateArgs();
1260 Record
.push_back(Args
.NumTemplateArgs
);
1261 AddExplicitTemplateArgumentList(Args
);
1264 Writer
.AddNestedNameSpecifierLoc(E
->getQualifierLoc(), Record
);
1265 Writer
.AddDeclarationNameInfo(E
->NameInfo
, Record
);
1266 Code
= serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF
;
1270 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr
*E
) {
1272 Record
.push_back(E
->arg_size());
1273 for (CXXUnresolvedConstructExpr::arg_iterator
1274 ArgI
= E
->arg_begin(), ArgE
= E
->arg_end(); ArgI
!= ArgE
; ++ArgI
)
1275 Writer
.AddStmt(*ArgI
);
1276 Writer
.AddTypeSourceInfo(E
->getTypeSourceInfo(), Record
);
1277 Writer
.AddSourceLocation(E
->getLParenLoc(), Record
);
1278 Writer
.AddSourceLocation(E
->getRParenLoc(), Record
);
1279 Code
= serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT
;
1282 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr
*E
) {
1285 // Don't emit anything here, hasExplicitTemplateArgs() must be emitted first.
1286 Record
.push_back(E
->hasExplicitTemplateArgs());
1287 if (E
->hasExplicitTemplateArgs()) {
1288 const ExplicitTemplateArgumentList
&Args
= E
->getExplicitTemplateArgs();
1289 Record
.push_back(Args
.NumTemplateArgs
);
1290 AddExplicitTemplateArgumentList(Args
);
1293 Record
.push_back(E
->getNumDecls());
1294 for (OverloadExpr::decls_iterator
1295 OvI
= E
->decls_begin(), OvE
= E
->decls_end(); OvI
!= OvE
; ++OvI
) {
1296 Writer
.AddDeclRef(OvI
.getDecl(), Record
);
1297 Record
.push_back(OvI
.getAccess());
1300 Writer
.AddDeclarationNameInfo(E
->NameInfo
, Record
);
1301 Writer
.AddNestedNameSpecifierLoc(E
->getQualifierLoc(), Record
);
1304 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr
*E
) {
1305 VisitOverloadExpr(E
);
1306 Record
.push_back(E
->isArrow());
1307 Record
.push_back(E
->hasUnresolvedUsing());
1308 Writer
.AddStmt(!E
->isImplicitAccess() ? E
->getBase() : 0);
1309 Writer
.AddTypeRef(E
->getBaseType(), Record
);
1310 Writer
.AddSourceLocation(E
->getOperatorLoc(), Record
);
1311 Code
= serialization::EXPR_CXX_UNRESOLVED_MEMBER
;
1314 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr
*E
) {
1315 VisitOverloadExpr(E
);
1316 Record
.push_back(E
->requiresADL());
1317 if (E
->requiresADL())
1318 Record
.push_back(E
->isStdAssociatedNamespace());
1319 Record
.push_back(E
->isOverloaded());
1320 Writer
.AddDeclRef(E
->getNamingClass(), Record
);
1321 Code
= serialization::EXPR_CXX_UNRESOLVED_LOOKUP
;
1324 void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr
*E
) {
1326 Record
.push_back(E
->getTrait());
1327 Record
.push_back(E
->getValue());
1328 Writer
.AddSourceRange(E
->getSourceRange(), Record
);
1329 Writer
.AddTypeSourceInfo(E
->getQueriedTypeSourceInfo(), Record
);
1330 Code
= serialization::EXPR_CXX_UNARY_TYPE_TRAIT
;
1333 void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr
*E
) {
1335 Record
.push_back(E
->getTrait());
1336 Record
.push_back(E
->getValue());
1337 Writer
.AddSourceRange(E
->getSourceRange(), Record
);
1338 Writer
.AddTypeSourceInfo(E
->getLhsTypeSourceInfo(), Record
);
1339 Writer
.AddTypeSourceInfo(E
->getRhsTypeSourceInfo(), Record
);
1340 Code
= serialization::EXPR_BINARY_TYPE_TRAIT
;
1343 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr
*E
) {
1345 Record
.push_back(E
->getTrait());
1346 Record
.push_back(E
->getValue());
1347 Writer
.AddSourceRange(E
->getSourceRange(), Record
);
1348 Writer
.AddStmt(E
->getQueriedExpression());
1349 Code
= serialization::EXPR_CXX_EXPRESSION_TRAIT
;
1352 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr
*E
) {
1354 Record
.push_back(E
->getValue());
1355 Writer
.AddSourceRange(E
->getSourceRange(), Record
);
1356 Writer
.AddStmt(E
->getOperand());
1357 Code
= serialization::EXPR_CXX_NOEXCEPT
;
1360 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr
*E
) {
1362 Writer
.AddSourceLocation(E
->getEllipsisLoc(), Record
);
1363 Record
.push_back(E
->NumExpansions
);
1364 Writer
.AddStmt(E
->getPattern());
1365 Code
= serialization::EXPR_PACK_EXPANSION
;
1368 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr
*E
) {
1370 Writer
.AddSourceLocation(E
->OperatorLoc
, Record
);
1371 Writer
.AddSourceLocation(E
->PackLoc
, Record
);
1372 Writer
.AddSourceLocation(E
->RParenLoc
, Record
);
1373 Record
.push_back(E
->Length
);
1374 Writer
.AddDeclRef(E
->Pack
, Record
);
1375 Code
= serialization::EXPR_SIZEOF_PACK
;
1378 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1379 SubstNonTypeTemplateParmPackExpr
*E
) {
1381 Writer
.AddDeclRef(E
->Param
, Record
);
1382 Writer
.AddTemplateArgument(E
->getArgumentPack(), Record
);
1383 Writer
.AddSourceLocation(E
->NameLoc
, Record
);
1384 Code
= serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK
;
1387 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr
*E
) {
1389 Record
.push_back(Writer
.getOpaqueValueID(E
));
1390 Writer
.AddSourceLocation(E
->getLocation(), Record
);
1391 Code
= serialization::EXPR_OPAQUE_VALUE
;
1394 //===----------------------------------------------------------------------===//
1395 // CUDA Expressions and Statements.
1396 //===----------------------------------------------------------------------===//
1398 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr
*E
) {
1400 Writer
.AddStmt(E
->getConfig());
1401 Code
= serialization::EXPR_CUDA_KERNEL_CALL
;
1404 //===----------------------------------------------------------------------===//
1405 // ASTWriter Implementation
1406 //===----------------------------------------------------------------------===//
1408 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase
*S
) {
1409 assert(SwitchCaseIDs
.find(S
) == SwitchCaseIDs
.end() &&
1410 "SwitchCase recorded twice");
1411 unsigned NextID
= SwitchCaseIDs
.size();
1412 SwitchCaseIDs
[S
] = NextID
;
1416 unsigned ASTWriter::getSwitchCaseID(SwitchCase
*S
) {
1417 assert(SwitchCaseIDs
.find(S
) != SwitchCaseIDs
.end() &&
1418 "SwitchCase hasn't been seen yet");
1419 return SwitchCaseIDs
[S
];
1422 void ASTWriter::ClearSwitchCaseIDs() {
1423 SwitchCaseIDs
.clear();
1426 unsigned ASTWriter::getOpaqueValueID(OpaqueValueExpr
*e
) {
1427 unsigned &entry
= OpaqueValues
[e
];
1428 if (!entry
) entry
= OpaqueValues
.size();
1432 /// \brief Write the given substatement or subexpression to the
1434 void ASTWriter::WriteSubStmt(Stmt
*S
) {
1436 ASTStmtWriter
Writer(*this, Record
);
1440 Stream
.EmitRecord(serialization::STMT_NULL_PTR
, Record
);
1444 // Redirect ASTWriter::AddStmt to collect sub stmts.
1445 llvm::SmallVector
<Stmt
*, 16> SubStmts
;
1446 CollectedStmts
= &SubStmts
;
1448 Writer
.Code
= serialization::STMT_NULL_PTR
;
1452 if (Writer
.Code
== serialization::STMT_NULL_PTR
) {
1453 SourceManager
&SrcMgr
1454 = DeclIDs
.begin()->first
->getASTContext().getSourceManager();
1456 assert(0 && "Unhandled sub statement writing AST file");
1460 // Revert ASTWriter::AddStmt.
1461 CollectedStmts
= &StmtsToEmit
;
1463 // Write the sub stmts in reverse order, last to first. When reading them back
1464 // we will read them in correct order by "pop"ing them from the Stmts stack.
1465 // This simplifies reading and allows to store a variable number of sub stmts
1466 // without knowing it in advance.
1467 while (!SubStmts
.empty())
1468 WriteSubStmt(SubStmts
.pop_back_val());
1470 Stream
.EmitRecord(Writer
.Code
, Record
);
1473 /// \brief Flush all of the statements that have been added to the
1474 /// queue via AddStmt().
1475 void ASTWriter::FlushStmts() {
1478 for (unsigned I
= 0, N
= StmtsToEmit
.size(); I
!= N
; ++I
) {
1479 WriteSubStmt(StmtsToEmit
[I
]);
1481 assert(N
== StmtsToEmit
.size() &&
1482 "Substatement written via AddStmt rather than WriteSubStmt!");
1484 // Note that we are at the end of a full expression. Any
1485 // expression records that follow this one are part of a different
1487 Stream
.EmitRecord(serialization::STMT_STOP
, Record
);
1490 StmtsToEmit
.clear();