1 //===--- ASTWriterStmt.cpp - Statement and Expression Serialization -------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements serialization for Statements and Expressions.
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Serialization/ASTWriter.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/DeclCXX.h"
17 #include "clang/AST/DeclObjC.h"
18 #include "clang/AST/DeclTemplate.h"
19 #include "clang/AST/StmtVisitor.h"
20 #include "llvm/Bitcode/BitstreamWriter.h"
21 using namespace clang;
22
23 //===----------------------------------------------------------------------===//
24 // Statement/expression serialization
25 //===----------------------------------------------------------------------===//
26
27 namespace clang {
28 class ASTStmtWriter : public StmtVisitor<ASTStmtWriter, void> {
29 ASTWriter &Writer;
30 ASTWriter::RecordData &Record;
31
32 public:
33 serialization::StmtCode Code;
34 unsigned AbbrevToUse;
35
ASTStmtWriter(ASTWriter & Writer,ASTWriter::RecordData & Record)36 ASTStmtWriter(ASTWriter &Writer, ASTWriter::RecordData &Record)
37 : Writer(Writer), Record(Record) { }
38
39 void AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args);
40
41 void VisitStmt(Stmt *S);
42 #define STMT(Type, Base) \
43 void Visit##Type(Type *);
44 #include "clang/AST/StmtNodes.inc"
45 };
46 }
47
48 void ASTStmtWriter::
AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo & Args)49 AddTemplateKWAndArgsInfo(const ASTTemplateKWAndArgsInfo &Args) {
50 Writer.AddSourceLocation(Args.getTemplateKeywordLoc(), Record);
51 Writer.AddSourceLocation(Args.LAngleLoc, Record);
52 Writer.AddSourceLocation(Args.RAngleLoc, Record);
53 for (unsigned i=0; i != Args.NumTemplateArgs; ++i)
54 Writer.AddTemplateArgumentLoc(Args.getTemplateArgs()[i], Record);
55 }
56
VisitStmt(Stmt * S)57 void ASTStmtWriter::VisitStmt(Stmt *S) {
58 }
59
VisitNullStmt(NullStmt * S)60 void ASTStmtWriter::VisitNullStmt(NullStmt *S) {
61 VisitStmt(S);
62 Writer.AddSourceLocation(S->getSemiLoc(), Record);
63 Record.push_back(S->HasLeadingEmptyMacro);
64 Code = serialization::STMT_NULL;
65 }
66
VisitCompoundStmt(CompoundStmt * S)67 void ASTStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
68 VisitStmt(S);
69 Record.push_back(S->size());
70 for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
71 CS != CSEnd; ++CS)
72 Writer.AddStmt(*CS);
73 Writer.AddSourceLocation(S->getLBracLoc(), Record);
74 Writer.AddSourceLocation(S->getRBracLoc(), Record);
75 Code = serialization::STMT_COMPOUND;
76 }
77
VisitSwitchCase(SwitchCase * S)78 void ASTStmtWriter::VisitSwitchCase(SwitchCase *S) {
79 VisitStmt(S);
80 Record.push_back(Writer.getSwitchCaseID(S));
81 }
82
VisitCaseStmt(CaseStmt * S)83 void ASTStmtWriter::VisitCaseStmt(CaseStmt *S) {
84 VisitSwitchCase(S);
85 Writer.AddStmt(S->getLHS());
86 Writer.AddStmt(S->getRHS());
87 Writer.AddStmt(S->getSubStmt());
88 Writer.AddSourceLocation(S->getCaseLoc(), Record);
89 Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
90 Writer.AddSourceLocation(S->getColonLoc(), Record);
91 Code = serialization::STMT_CASE;
92 }
93
VisitDefaultStmt(DefaultStmt * S)94 void ASTStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
95 VisitSwitchCase(S);
96 Writer.AddStmt(S->getSubStmt());
97 Writer.AddSourceLocation(S->getDefaultLoc(), Record);
98 Writer.AddSourceLocation(S->getColonLoc(), Record);
99 Code = serialization::STMT_DEFAULT;
100 }
101
VisitLabelStmt(LabelStmt * S)102 void ASTStmtWriter::VisitLabelStmt(LabelStmt *S) {
103 VisitStmt(S);
104 Writer.AddDeclRef(S->getDecl(), Record);
105 Writer.AddStmt(S->getSubStmt());
106 Writer.AddSourceLocation(S->getIdentLoc(), Record);
107 Code = serialization::STMT_LABEL;
108 }
109
VisitAttributedStmt(AttributedStmt * S)110 void ASTStmtWriter::VisitAttributedStmt(AttributedStmt *S) {
111 VisitStmt(S);
112 Record.push_back(S->getAttrs().size());
113 Writer.WriteAttributes(S->getAttrs(), Record);
114 Writer.AddStmt(S->getSubStmt());
115 Writer.AddSourceLocation(S->getAttrLoc(), Record);
116 Code = serialization::STMT_ATTRIBUTED;
117 }
118
VisitIfStmt(IfStmt * S)119 void ASTStmtWriter::VisitIfStmt(IfStmt *S) {
120 VisitStmt(S);
121 Writer.AddDeclRef(S->getConditionVariable(), Record);
122 Writer.AddStmt(S->getCond());
123 Writer.AddStmt(S->getThen());
124 Writer.AddStmt(S->getElse());
125 Writer.AddSourceLocation(S->getIfLoc(), Record);
126 Writer.AddSourceLocation(S->getElseLoc(), Record);
127 Code = serialization::STMT_IF;
128 }
129
VisitSwitchStmt(SwitchStmt * S)130 void ASTStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
131 VisitStmt(S);
132 Writer.AddDeclRef(S->getConditionVariable(), Record);
133 Writer.AddStmt(S->getCond());
134 Writer.AddStmt(S->getBody());
135 Writer.AddSourceLocation(S->getSwitchLoc(), Record);
136 Record.push_back(S->isAllEnumCasesCovered());
137 for (SwitchCase *SC = S->getSwitchCaseList(); SC;
138 SC = SC->getNextSwitchCase())
139 Record.push_back(Writer.RecordSwitchCaseID(SC));
140 Code = serialization::STMT_SWITCH;
141 }
142
VisitWhileStmt(WhileStmt * S)143 void ASTStmtWriter::VisitWhileStmt(WhileStmt *S) {
144 VisitStmt(S);
145 Writer.AddDeclRef(S->getConditionVariable(), Record);
146 Writer.AddStmt(S->getCond());
147 Writer.AddStmt(S->getBody());
148 Writer.AddSourceLocation(S->getWhileLoc(), Record);
149 Code = serialization::STMT_WHILE;
150 }
151
VisitDoStmt(DoStmt * S)152 void ASTStmtWriter::VisitDoStmt(DoStmt *S) {
153 VisitStmt(S);
154 Writer.AddStmt(S->getCond());
155 Writer.AddStmt(S->getBody());
156 Writer.AddSourceLocation(S->getDoLoc(), Record);
157 Writer.AddSourceLocation(S->getWhileLoc(), Record);
158 Writer.AddSourceLocation(S->getRParenLoc(), Record);
159 Code = serialization::STMT_DO;
160 }
161
VisitForStmt(ForStmt * S)162 void ASTStmtWriter::VisitForStmt(ForStmt *S) {
163 VisitStmt(S);
164 Writer.AddStmt(S->getInit());
165 Writer.AddStmt(S->getCond());
166 Writer.AddDeclRef(S->getConditionVariable(), Record);
167 Writer.AddStmt(S->getInc());
168 Writer.AddStmt(S->getBody());
169 Writer.AddSourceLocation(S->getForLoc(), Record);
170 Writer.AddSourceLocation(S->getLParenLoc(), Record);
171 Writer.AddSourceLocation(S->getRParenLoc(), Record);
172 Code = serialization::STMT_FOR;
173 }
174
VisitGotoStmt(GotoStmt * S)175 void ASTStmtWriter::VisitGotoStmt(GotoStmt *S) {
176 VisitStmt(S);
177 Writer.AddDeclRef(S->getLabel(), Record);
178 Writer.AddSourceLocation(S->getGotoLoc(), Record);
179 Writer.AddSourceLocation(S->getLabelLoc(), Record);
180 Code = serialization::STMT_GOTO;
181 }
182
VisitIndirectGotoStmt(IndirectGotoStmt * S)183 void ASTStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
184 VisitStmt(S);
185 Writer.AddSourceLocation(S->getGotoLoc(), Record);
186 Writer.AddSourceLocation(S->getStarLoc(), Record);
187 Writer.AddStmt(S->getTarget());
188 Code = serialization::STMT_INDIRECT_GOTO;
189 }
190
VisitContinueStmt(ContinueStmt * S)191 void ASTStmtWriter::VisitContinueStmt(ContinueStmt *S) {
192 VisitStmt(S);
193 Writer.AddSourceLocation(S->getContinueLoc(), Record);
194 Code = serialization::STMT_CONTINUE;
195 }
196
VisitBreakStmt(BreakStmt * S)197 void ASTStmtWriter::VisitBreakStmt(BreakStmt *S) {
198 VisitStmt(S);
199 Writer.AddSourceLocation(S->getBreakLoc(), Record);
200 Code = serialization::STMT_BREAK;
201 }
202
VisitReturnStmt(ReturnStmt * S)203 void ASTStmtWriter::VisitReturnStmt(ReturnStmt *S) {
204 VisitStmt(S);
205 Writer.AddStmt(S->getRetValue());
206 Writer.AddSourceLocation(S->getReturnLoc(), Record);
207 Writer.AddDeclRef(S->getNRVOCandidate(), Record);
208 Code = serialization::STMT_RETURN;
209 }
210
VisitDeclStmt(DeclStmt * S)211 void ASTStmtWriter::VisitDeclStmt(DeclStmt *S) {
212 VisitStmt(S);
213 Writer.AddSourceLocation(S->getStartLoc(), Record);
214 Writer.AddSourceLocation(S->getEndLoc(), Record);
215 DeclGroupRef DG = S->getDeclGroup();
216 for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
217 Writer.AddDeclRef(*D, Record);
218 Code = serialization::STMT_DECL;
219 }
220
VisitGCCAsmStmt(GCCAsmStmt * S)221 void ASTStmtWriter::VisitGCCAsmStmt(GCCAsmStmt *S) {
222 VisitStmt(S);
223 Record.push_back(S->getNumOutputs());
224 Record.push_back(S->getNumInputs());
225 Record.push_back(S->getNumClobbers());
226 Writer.AddSourceLocation(S->getAsmLoc(), Record);
227 Writer.AddSourceLocation(S->getRParenLoc(), Record);
228 Record.push_back(S->isVolatile());
229 Record.push_back(S->isSimple());
230 Writer.AddStmt(S->getAsmString());
231
232 // Outputs
233 for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
234 Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
235 Writer.AddStmt(S->getOutputConstraintLiteral(I));
236 Writer.AddStmt(S->getOutputExpr(I));
237 }
238
239 // Inputs
240 for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
241 Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
242 Writer.AddStmt(S->getInputConstraintLiteral(I));
243 Writer.AddStmt(S->getInputExpr(I));
244 }
245
246 // Clobbers
247 for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
248 Writer.AddStmt(S->getClobberStringLiteral(I));
249
250 Code = serialization::STMT_GCCASM;
251 }
252
VisitMSAsmStmt(MSAsmStmt * S)253 void ASTStmtWriter::VisitMSAsmStmt(MSAsmStmt *S) {
254 // FIXME: Statement writer not yet implemented for MS style inline asm.
255 VisitStmt(S);
256
257 Code = serialization::STMT_MSASM;
258 }
259
VisitExpr(Expr * E)260 void ASTStmtWriter::VisitExpr(Expr *E) {
261 VisitStmt(E);
262 Writer.AddTypeRef(E->getType(), Record);
263 Record.push_back(E->isTypeDependent());
264 Record.push_back(E->isValueDependent());
265 Record.push_back(E->isInstantiationDependent());
266 Record.push_back(E->containsUnexpandedParameterPack());
267 Record.push_back(E->getValueKind());
268 Record.push_back(E->getObjectKind());
269 }
270
VisitPredefinedExpr(PredefinedExpr * E)271 void ASTStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
272 VisitExpr(E);
273 Writer.AddSourceLocation(E->getLocation(), Record);
274 Record.push_back(E->getIdentType()); // FIXME: stable encoding
275 Code = serialization::EXPR_PREDEFINED;
276 }
277
VisitDeclRefExpr(DeclRefExpr * E)278 void ASTStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
279 VisitExpr(E);
280
281 Record.push_back(E->hasQualifier());
282 Record.push_back(E->getDecl() != E->getFoundDecl());
283 Record.push_back(E->hasTemplateKWAndArgsInfo());
284 Record.push_back(E->hadMultipleCandidates());
285 Record.push_back(E->refersToEnclosingLocal());
286
287 if (E->hasTemplateKWAndArgsInfo()) {
288 unsigned NumTemplateArgs = E->getNumTemplateArgs();
289 Record.push_back(NumTemplateArgs);
290 }
291
292 DeclarationName::NameKind nk = (E->getDecl()->getDeclName().getNameKind());
293
294 if ((!E->hasTemplateKWAndArgsInfo()) && (!E->hasQualifier()) &&
295 (E->getDecl() == E->getFoundDecl()) &&
296 nk == DeclarationName::Identifier) {
297 AbbrevToUse = Writer.getDeclRefExprAbbrev();
298 }
299
300 if (E->hasQualifier())
301 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
302
303 if (E->getDecl() != E->getFoundDecl())
304 Writer.AddDeclRef(E->getFoundDecl(), Record);
305
306 if (E->hasTemplateKWAndArgsInfo())
307 AddTemplateKWAndArgsInfo(*E->getTemplateKWAndArgsInfo());
308
309 Writer.AddDeclRef(E->getDecl(), Record);
310 Writer.AddSourceLocation(E->getLocation(), Record);
311 Writer.AddDeclarationNameLoc(E->DNLoc, E->getDecl()->getDeclName(), Record);
312 Code = serialization::EXPR_DECL_REF;
313 }
314
VisitIntegerLiteral(IntegerLiteral * E)315 void ASTStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
316 VisitExpr(E);
317 Writer.AddSourceLocation(E->getLocation(), Record);
318 Writer.AddAPInt(E->getValue(), Record);
319
320 if (E->getValue().getBitWidth() == 32) {
321 AbbrevToUse = Writer.getIntegerLiteralAbbrev();
322 }
323
324 Code = serialization::EXPR_INTEGER_LITERAL;
325 }
326
VisitFloatingLiteral(FloatingLiteral * E)327 void ASTStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
328 VisitExpr(E);
329 Writer.AddAPFloat(E->getValue(), Record);
330 Record.push_back(E->isExact());
331 Writer.AddSourceLocation(E->getLocation(), Record);
332 Code = serialization::EXPR_FLOATING_LITERAL;
333 }
334
VisitImaginaryLiteral(ImaginaryLiteral * E)335 void ASTStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
336 VisitExpr(E);
337 Writer.AddStmt(E->getSubExpr());
338 Code = serialization::EXPR_IMAGINARY_LITERAL;
339 }
340
VisitStringLiteral(StringLiteral * E)341 void ASTStmtWriter::VisitStringLiteral(StringLiteral *E) {
342 VisitExpr(E);
343 Record.push_back(E->getByteLength());
344 Record.push_back(E->getNumConcatenated());
345 Record.push_back(E->getKind());
346 Record.push_back(E->isPascal());
347 // FIXME: String data should be stored as a blob at the end of the
348 // StringLiteral. However, we can't do so now because we have no
349 // provision for coping with abbreviations when we're jumping around
350 // the AST file during deserialization.
351 Record.append(E->getBytes().begin(), E->getBytes().end());
352 for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
353 Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
354 Code = serialization::EXPR_STRING_LITERAL;
355 }
356
VisitCharacterLiteral(CharacterLiteral * E)357 void ASTStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
358 VisitExpr(E);
359 Record.push_back(E->getValue());
360 Writer.AddSourceLocation(E->getLocation(), Record);
361 Record.push_back(E->getKind());
362
363 AbbrevToUse = Writer.getCharacterLiteralAbbrev();
364
365 Code = serialization::EXPR_CHARACTER_LITERAL;
366 }
367
VisitParenExpr(ParenExpr * E)368 void ASTStmtWriter::VisitParenExpr(ParenExpr *E) {
369 VisitExpr(E);
370 Writer.AddSourceLocation(E->getLParen(), Record);
371 Writer.AddSourceLocation(E->getRParen(), Record);
372 Writer.AddStmt(E->getSubExpr());
373 Code = serialization::EXPR_PAREN;
374 }
375
VisitParenListExpr(ParenListExpr * E)376 void ASTStmtWriter::VisitParenListExpr(ParenListExpr *E) {
377 VisitExpr(E);
378 Record.push_back(E->NumExprs);
379 for (unsigned i=0; i != E->NumExprs; ++i)
380 Writer.AddStmt(E->Exprs[i]);
381 Writer.AddSourceLocation(E->LParenLoc, Record);
382 Writer.AddSourceLocation(E->RParenLoc, Record);
383 Code = serialization::EXPR_PAREN_LIST;
384 }
385
VisitUnaryOperator(UnaryOperator * E)386 void ASTStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
387 VisitExpr(E);
388 Writer.AddStmt(E->getSubExpr());
389 Record.push_back(E->getOpcode()); // FIXME: stable encoding
390 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
391 Code = serialization::EXPR_UNARY_OPERATOR;
392 }
393
VisitOffsetOfExpr(OffsetOfExpr * E)394 void ASTStmtWriter::VisitOffsetOfExpr(OffsetOfExpr *E) {
395 VisitExpr(E);
396 Record.push_back(E->getNumComponents());
397 Record.push_back(E->getNumExpressions());
398 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
399 Writer.AddSourceLocation(E->getRParenLoc(), Record);
400 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
401 for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
402 const OffsetOfExpr::OffsetOfNode &ON = E->getComponent(I);
403 Record.push_back(ON.getKind()); // FIXME: Stable encoding
404 Writer.AddSourceLocation(ON.getSourceRange().getBegin(), Record);
405 Writer.AddSourceLocation(ON.getSourceRange().getEnd(), Record);
406 switch (ON.getKind()) {
407 case OffsetOfExpr::OffsetOfNode::Array:
408 Record.push_back(ON.getArrayExprIndex());
409 break;
410
411 case OffsetOfExpr::OffsetOfNode::Field:
412 Writer.AddDeclRef(ON.getField(), Record);
413 break;
414
415 case OffsetOfExpr::OffsetOfNode::Identifier:
416 Writer.AddIdentifierRef(ON.getFieldName(), Record);
417 break;
418
419 case OffsetOfExpr::OffsetOfNode::Base:
420 Writer.AddCXXBaseSpecifier(*ON.getBase(), Record);
421 break;
422 }
423 }
424 for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
425 Writer.AddStmt(E->getIndexExpr(I));
426 Code = serialization::EXPR_OFFSETOF;
427 }
428
VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr * E)429 void ASTStmtWriter::VisitUnaryExprOrTypeTraitExpr(UnaryExprOrTypeTraitExpr *E) {
430 VisitExpr(E);
431 Record.push_back(E->getKind());
432 if (E->isArgumentType())
433 Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
434 else {
435 Record.push_back(0);
436 Writer.AddStmt(E->getArgumentExpr());
437 }
438 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
439 Writer.AddSourceLocation(E->getRParenLoc(), Record);
440 Code = serialization::EXPR_SIZEOF_ALIGN_OF;
441 }
442
VisitArraySubscriptExpr(ArraySubscriptExpr * E)443 void ASTStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
444 VisitExpr(E);
445 Writer.AddStmt(E->getLHS());
446 Writer.AddStmt(E->getRHS());
447 Writer.AddSourceLocation(E->getRBracketLoc(), Record);
448 Code = serialization::EXPR_ARRAY_SUBSCRIPT;
449 }
450
VisitCallExpr(CallExpr * E)451 void ASTStmtWriter::VisitCallExpr(CallExpr *E) {
452 VisitExpr(E);
453 Record.push_back(E->getNumArgs());
454 Writer.AddSourceLocation(E->getRParenLoc(), Record);
455 Writer.AddStmt(E->getCallee());
456 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
457 Arg != ArgEnd; ++Arg)
458 Writer.AddStmt(*Arg);
459 Code = serialization::EXPR_CALL;
460 }
461
VisitMemberExpr(MemberExpr * E)462 void ASTStmtWriter::VisitMemberExpr(MemberExpr *E) {
463 // Don't call VisitExpr, we'll write everything here.
464
465 Record.push_back(E->hasQualifier());
466 if (E->hasQualifier())
467 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
468
469 Record.push_back(E->HasTemplateKWAndArgsInfo);
470 if (E->HasTemplateKWAndArgsInfo) {
471 Writer.AddSourceLocation(E->getTemplateKeywordLoc(), Record);
472 unsigned NumTemplateArgs = E->getNumTemplateArgs();
473 Record.push_back(NumTemplateArgs);
474 Writer.AddSourceLocation(E->getLAngleLoc(), Record);
475 Writer.AddSourceLocation(E->getRAngleLoc(), Record);
476 for (unsigned i=0; i != NumTemplateArgs; ++i)
477 Writer.AddTemplateArgumentLoc(E->getTemplateArgs()[i], Record);
478 }
479
480 Record.push_back(E->hadMultipleCandidates());
481
482 DeclAccessPair FoundDecl = E->getFoundDecl();
483 Writer.AddDeclRef(FoundDecl.getDecl(), Record);
484 Record.push_back(FoundDecl.getAccess());
485
486 Writer.AddTypeRef(E->getType(), Record);
487 Record.push_back(E->getValueKind());
488 Record.push_back(E->getObjectKind());
489 Writer.AddStmt(E->getBase());
490 Writer.AddDeclRef(E->getMemberDecl(), Record);
491 Writer.AddSourceLocation(E->getMemberLoc(), Record);
492 Record.push_back(E->isArrow());
493 Writer.AddDeclarationNameLoc(E->MemberDNLoc,
494 E->getMemberDecl()->getDeclName(), Record);
495 Code = serialization::EXPR_MEMBER;
496 }
497
VisitObjCIsaExpr(ObjCIsaExpr * E)498 void ASTStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
499 VisitExpr(E);
500 Writer.AddStmt(E->getBase());
501 Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
502 Record.push_back(E->isArrow());
503 Code = serialization::EXPR_OBJC_ISA;
504 }
505
506 void ASTStmtWriter::
VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr * E)507 VisitObjCIndirectCopyRestoreExpr(ObjCIndirectCopyRestoreExpr *E) {
508 VisitExpr(E);
509 Writer.AddStmt(E->getSubExpr());
510 Record.push_back(E->shouldCopy());
511 Code = serialization::EXPR_OBJC_INDIRECT_COPY_RESTORE;
512 }
513
VisitObjCBridgedCastExpr(ObjCBridgedCastExpr * E)514 void ASTStmtWriter::VisitObjCBridgedCastExpr(ObjCBridgedCastExpr *E) {
515 VisitExplicitCastExpr(E);
516 Writer.AddSourceLocation(E->getLParenLoc(), Record);
517 Writer.AddSourceLocation(E->getBridgeKeywordLoc(), Record);
518 Record.push_back(E->getBridgeKind()); // FIXME: Stable encoding
519 Code = serialization::EXPR_OBJC_BRIDGED_CAST;
520 }
521
VisitCastExpr(CastExpr * E)522 void ASTStmtWriter::VisitCastExpr(CastExpr *E) {
523 VisitExpr(E);
524 Record.push_back(E->path_size());
525 Writer.AddStmt(E->getSubExpr());
526 Record.push_back(E->getCastKind()); // FIXME: stable encoding
527
528 for (CastExpr::path_iterator
529 PI = E->path_begin(), PE = E->path_end(); PI != PE; ++PI)
530 Writer.AddCXXBaseSpecifier(**PI, Record);
531 }
532
VisitBinaryOperator(BinaryOperator * E)533 void ASTStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
534 VisitExpr(E);
535 Writer.AddStmt(E->getLHS());
536 Writer.AddStmt(E->getRHS());
537 Record.push_back(E->getOpcode()); // FIXME: stable encoding
538 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
539 Code = serialization::EXPR_BINARY_OPERATOR;
540 }
541
VisitCompoundAssignOperator(CompoundAssignOperator * E)542 void ASTStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
543 VisitBinaryOperator(E);
544 Writer.AddTypeRef(E->getComputationLHSType(), Record);
545 Writer.AddTypeRef(E->getComputationResultType(), Record);
546 Code = serialization::EXPR_COMPOUND_ASSIGN_OPERATOR;
547 }
548
VisitConditionalOperator(ConditionalOperator * E)549 void ASTStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
550 VisitExpr(E);
551 Writer.AddStmt(E->getCond());
552 Writer.AddStmt(E->getLHS());
553 Writer.AddStmt(E->getRHS());
554 Writer.AddSourceLocation(E->getQuestionLoc(), Record);
555 Writer.AddSourceLocation(E->getColonLoc(), Record);
556 Code = serialization::EXPR_CONDITIONAL_OPERATOR;
557 }
558
559 void
VisitBinaryConditionalOperator(BinaryConditionalOperator * E)560 ASTStmtWriter::VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
561 VisitExpr(E);
562 Writer.AddStmt(E->getOpaqueValue());
563 Writer.AddStmt(E->getCommon());
564 Writer.AddStmt(E->getCond());
565 Writer.AddStmt(E->getTrueExpr());
566 Writer.AddStmt(E->getFalseExpr());
567 Writer.AddSourceLocation(E->getQuestionLoc(), Record);
568 Writer.AddSourceLocation(E->getColonLoc(), Record);
569 Code = serialization::EXPR_BINARY_CONDITIONAL_OPERATOR;
570 }
571
VisitImplicitCastExpr(ImplicitCastExpr * E)572 void ASTStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
573 VisitCastExpr(E);
574 Code = serialization::EXPR_IMPLICIT_CAST;
575 }
576
VisitExplicitCastExpr(ExplicitCastExpr * E)577 void ASTStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
578 VisitCastExpr(E);
579 Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
580 }
581
VisitCStyleCastExpr(CStyleCastExpr * E)582 void ASTStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
583 VisitExplicitCastExpr(E);
584 Writer.AddSourceLocation(E->getLParenLoc(), Record);
585 Writer.AddSourceLocation(E->getRParenLoc(), Record);
586 Code = serialization::EXPR_CSTYLE_CAST;
587 }
588
VisitCompoundLiteralExpr(CompoundLiteralExpr * E)589 void ASTStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
590 VisitExpr(E);
591 Writer.AddSourceLocation(E->getLParenLoc(), Record);
592 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
593 Writer.AddStmt(E->getInitializer());
594 Record.push_back(E->isFileScope());
595 Code = serialization::EXPR_COMPOUND_LITERAL;
596 }
597
VisitExtVectorElementExpr(ExtVectorElementExpr * E)598 void ASTStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
599 VisitExpr(E);
600 Writer.AddStmt(E->getBase());
601 Writer.AddIdentifierRef(&E->getAccessor(), Record);
602 Writer.AddSourceLocation(E->getAccessorLoc(), Record);
603 Code = serialization::EXPR_EXT_VECTOR_ELEMENT;
604 }
605
VisitInitListExpr(InitListExpr * E)606 void ASTStmtWriter::VisitInitListExpr(InitListExpr *E) {
607 VisitExpr(E);
608 Writer.AddStmt(E->getSyntacticForm());
609 Writer.AddSourceLocation(E->getLBraceLoc(), Record);
610 Writer.AddSourceLocation(E->getRBraceLoc(), Record);
611 bool isArrayFiller = E->ArrayFillerOrUnionFieldInit.is<Expr*>();
612 Record.push_back(isArrayFiller);
613 if (isArrayFiller)
614 Writer.AddStmt(E->getArrayFiller());
615 else
616 Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
617 Record.push_back(E->hadArrayRangeDesignator());
618 Record.push_back(E->initializesStdInitializerList());
619 Record.push_back(E->getNumInits());
620 if (isArrayFiller) {
621 // ArrayFiller may have filled "holes" due to designated initializer.
622 // Replace them by 0 to indicate that the filler goes in that place.
623 Expr *filler = E->getArrayFiller();
624 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
625 Writer.AddStmt(E->getInit(I) != filler ? E->getInit(I) : 0);
626 } else {
627 for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
628 Writer.AddStmt(E->getInit(I));
629 }
630 Code = serialization::EXPR_INIT_LIST;
631 }
632
VisitDesignatedInitExpr(DesignatedInitExpr * E)633 void ASTStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
634 VisitExpr(E);
635 Record.push_back(E->getNumSubExprs());
636 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
637 Writer.AddStmt(E->getSubExpr(I));
638 Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
639 Record.push_back(E->usesGNUSyntax());
640 for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
641 DEnd = E->designators_end();
642 D != DEnd; ++D) {
643 if (D->isFieldDesignator()) {
644 if (FieldDecl *Field = D->getField()) {
645 Record.push_back(serialization::DESIG_FIELD_DECL);
646 Writer.AddDeclRef(Field, Record);
647 } else {
648 Record.push_back(serialization::DESIG_FIELD_NAME);
649 Writer.AddIdentifierRef(D->getFieldName(), Record);
650 }
651 Writer.AddSourceLocation(D->getDotLoc(), Record);
652 Writer.AddSourceLocation(D->getFieldLoc(), Record);
653 } else if (D->isArrayDesignator()) {
654 Record.push_back(serialization::DESIG_ARRAY);
655 Record.push_back(D->getFirstExprIndex());
656 Writer.AddSourceLocation(D->getLBracketLoc(), Record);
657 Writer.AddSourceLocation(D->getRBracketLoc(), Record);
658 } else {
659 assert(D->isArrayRangeDesignator() && "Unknown designator");
660 Record.push_back(serialization::DESIG_ARRAY_RANGE);
661 Record.push_back(D->getFirstExprIndex());
662 Writer.AddSourceLocation(D->getLBracketLoc(), Record);
663 Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
664 Writer.AddSourceLocation(D->getRBracketLoc(), Record);
665 }
666 }
667 Code = serialization::EXPR_DESIGNATED_INIT;
668 }
669
VisitImplicitValueInitExpr(ImplicitValueInitExpr * E)670 void ASTStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
671 VisitExpr(E);
672 Code = serialization::EXPR_IMPLICIT_VALUE_INIT;
673 }
674
VisitVAArgExpr(VAArgExpr * E)675 void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
676 VisitExpr(E);
677 Writer.AddStmt(E->getSubExpr());
678 Writer.AddTypeSourceInfo(E->getWrittenTypeInfo(), Record);
679 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
680 Writer.AddSourceLocation(E->getRParenLoc(), Record);
681 Code = serialization::EXPR_VA_ARG;
682 }
683
VisitAddrLabelExpr(AddrLabelExpr * E)684 void ASTStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
685 VisitExpr(E);
686 Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
687 Writer.AddSourceLocation(E->getLabelLoc(), Record);
688 Writer.AddDeclRef(E->getLabel(), Record);
689 Code = serialization::EXPR_ADDR_LABEL;
690 }
691
VisitStmtExpr(StmtExpr * E)692 void ASTStmtWriter::VisitStmtExpr(StmtExpr *E) {
693 VisitExpr(E);
694 Writer.AddStmt(E->getSubStmt());
695 Writer.AddSourceLocation(E->getLParenLoc(), Record);
696 Writer.AddSourceLocation(E->getRParenLoc(), Record);
697 Code = serialization::EXPR_STMT;
698 }
699
VisitChooseExpr(ChooseExpr * E)700 void ASTStmtWriter::VisitChooseExpr(ChooseExpr *E) {
701 VisitExpr(E);
702 Writer.AddStmt(E->getCond());
703 Writer.AddStmt(E->getLHS());
704 Writer.AddStmt(E->getRHS());
705 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
706 Writer.AddSourceLocation(E->getRParenLoc(), Record);
707 Code = serialization::EXPR_CHOOSE;
708 }
709
VisitGNUNullExpr(GNUNullExpr * E)710 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
711 VisitExpr(E);
712 Writer.AddSourceLocation(E->getTokenLocation(), Record);
713 Code = serialization::EXPR_GNU_NULL;
714 }
715
VisitShuffleVectorExpr(ShuffleVectorExpr * E)716 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
717 VisitExpr(E);
718 Record.push_back(E->getNumSubExprs());
719 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
720 Writer.AddStmt(E->getExpr(I));
721 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
722 Writer.AddSourceLocation(E->getRParenLoc(), Record);
723 Code = serialization::EXPR_SHUFFLE_VECTOR;
724 }
725
VisitBlockExpr(BlockExpr * E)726 void ASTStmtWriter::VisitBlockExpr(BlockExpr *E) {
727 VisitExpr(E);
728 Writer.AddDeclRef(E->getBlockDecl(), Record);
729 Code = serialization::EXPR_BLOCK;
730 }
731
VisitGenericSelectionExpr(GenericSelectionExpr * E)732 void ASTStmtWriter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
733 VisitExpr(E);
734 Record.push_back(E->getNumAssocs());
735
736 Writer.AddStmt(E->getControllingExpr());
737 for (unsigned I = 0, N = E->getNumAssocs(); I != N; ++I) {
738 Writer.AddTypeSourceInfo(E->getAssocTypeSourceInfo(I), Record);
739 Writer.AddStmt(E->getAssocExpr(I));
740 }
741 Record.push_back(E->isResultDependent() ? -1U : E->getResultIndex());
742
743 Writer.AddSourceLocation(E->getGenericLoc(), Record);
744 Writer.AddSourceLocation(E->getDefaultLoc(), Record);
745 Writer.AddSourceLocation(E->getRParenLoc(), Record);
746 Code = serialization::EXPR_GENERIC_SELECTION;
747 }
748
VisitPseudoObjectExpr(PseudoObjectExpr * E)749 void ASTStmtWriter::VisitPseudoObjectExpr(PseudoObjectExpr *E) {
750 VisitExpr(E);
751 Record.push_back(E->getNumSemanticExprs());
752
753 // Push the result index. Currently, this needs to exactly match
754 // the encoding used internally for ResultIndex.
755 unsigned result = E->getResultExprIndex();
756 result = (result == PseudoObjectExpr::NoResult ? 0 : result + 1);
757 Record.push_back(result);
758
759 Writer.AddStmt(E->getSyntacticForm());
760 for (PseudoObjectExpr::semantics_iterator
761 i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
762 Writer.AddStmt(*i);
763 }
764 Code = serialization::EXPR_PSEUDO_OBJECT;
765 }
766
VisitAtomicExpr(AtomicExpr * E)767 void ASTStmtWriter::VisitAtomicExpr(AtomicExpr *E) {
768 VisitExpr(E);
769 Record.push_back(E->getOp());
770 for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
771 Writer.AddStmt(E->getSubExprs()[I]);
772 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
773 Writer.AddSourceLocation(E->getRParenLoc(), Record);
774 Code = serialization::EXPR_ATOMIC;
775 }
776
777 //===----------------------------------------------------------------------===//
778 // Objective-C Expressions and Statements.
779 //===----------------------------------------------------------------------===//
780
VisitObjCStringLiteral(ObjCStringLiteral * E)781 void ASTStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
782 VisitExpr(E);
783 Writer.AddStmt(E->getString());
784 Writer.AddSourceLocation(E->getAtLoc(), Record);
785 Code = serialization::EXPR_OBJC_STRING_LITERAL;
786 }
787
VisitObjCBoxedExpr(ObjCBoxedExpr * E)788 void ASTStmtWriter::VisitObjCBoxedExpr(ObjCBoxedExpr *E) {
789 VisitExpr(E);
790 Writer.AddStmt(E->getSubExpr());
791 Writer.AddDeclRef(E->getBoxingMethod(), Record);
792 Writer.AddSourceRange(E->getSourceRange(), Record);
793 Code = serialization::EXPR_OBJC_BOXED_EXPRESSION;
794 }
795
VisitObjCArrayLiteral(ObjCArrayLiteral * E)796 void ASTStmtWriter::VisitObjCArrayLiteral(ObjCArrayLiteral *E) {
797 VisitExpr(E);
798 Record.push_back(E->getNumElements());
799 for (unsigned i = 0; i < E->getNumElements(); i++)
800 Writer.AddStmt(E->getElement(i));
801 Writer.AddDeclRef(E->getArrayWithObjectsMethod(), Record);
802 Writer.AddSourceRange(E->getSourceRange(), Record);
803 Code = serialization::EXPR_OBJC_ARRAY_LITERAL;
804 }
805
VisitObjCDictionaryLiteral(ObjCDictionaryLiteral * E)806 void ASTStmtWriter::VisitObjCDictionaryLiteral(ObjCDictionaryLiteral *E) {
807 VisitExpr(E);
808 Record.push_back(E->getNumElements());
809 Record.push_back(E->HasPackExpansions);
810 for (unsigned i = 0; i < E->getNumElements(); i++) {
811 ObjCDictionaryElement Element = E->getKeyValueElement(i);
812 Writer.AddStmt(Element.Key);
813 Writer.AddStmt(Element.Value);
814 if (E->HasPackExpansions) {
815 Writer.AddSourceLocation(Element.EllipsisLoc, Record);
816 unsigned NumExpansions = 0;
817 if (Element.NumExpansions)
818 NumExpansions = *Element.NumExpansions + 1;
819 Record.push_back(NumExpansions);
820 }
821 }
822
823 Writer.AddDeclRef(E->getDictWithObjectsMethod(), Record);
824 Writer.AddSourceRange(E->getSourceRange(), Record);
825 Code = serialization::EXPR_OBJC_DICTIONARY_LITERAL;
826 }
827
VisitObjCEncodeExpr(ObjCEncodeExpr * E)828 void ASTStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
829 VisitExpr(E);
830 Writer.AddTypeSourceInfo(E->getEncodedTypeSourceInfo(), Record);
831 Writer.AddSourceLocation(E->getAtLoc(), Record);
832 Writer.AddSourceLocation(E->getRParenLoc(), Record);
833 Code = serialization::EXPR_OBJC_ENCODE;
834 }
835
VisitObjCSelectorExpr(ObjCSelectorExpr * E)836 void ASTStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
837 VisitExpr(E);
838 Writer.AddSelectorRef(E->getSelector(), Record);
839 Writer.AddSourceLocation(E->getAtLoc(), Record);
840 Writer.AddSourceLocation(E->getRParenLoc(), Record);
841 Code = serialization::EXPR_OBJC_SELECTOR_EXPR;
842 }
843
VisitObjCProtocolExpr(ObjCProtocolExpr * E)844 void ASTStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
845 VisitExpr(E);
846 Writer.AddDeclRef(E->getProtocol(), Record);
847 Writer.AddSourceLocation(E->getAtLoc(), Record);
848 Writer.AddSourceLocation(E->ProtoLoc, Record);
849 Writer.AddSourceLocation(E->getRParenLoc(), Record);
850 Code = serialization::EXPR_OBJC_PROTOCOL_EXPR;
851 }
852
VisitObjCIvarRefExpr(ObjCIvarRefExpr * E)853 void ASTStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
854 VisitExpr(E);
855 Writer.AddDeclRef(E->getDecl(), Record);
856 Writer.AddSourceLocation(E->getLocation(), Record);
857 Writer.AddStmt(E->getBase());
858 Record.push_back(E->isArrow());
859 Record.push_back(E->isFreeIvar());
860 Code = serialization::EXPR_OBJC_IVAR_REF_EXPR;
861 }
862
VisitObjCPropertyRefExpr(ObjCPropertyRefExpr * E)863 void ASTStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
864 VisitExpr(E);
865 Record.push_back(E->SetterAndMethodRefFlags.getInt());
866 Record.push_back(E->isImplicitProperty());
867 if (E->isImplicitProperty()) {
868 Writer.AddDeclRef(E->getImplicitPropertyGetter(), Record);
869 Writer.AddDeclRef(E->getImplicitPropertySetter(), Record);
870 } else {
871 Writer.AddDeclRef(E->getExplicitProperty(), Record);
872 }
873 Writer.AddSourceLocation(E->getLocation(), Record);
874 Writer.AddSourceLocation(E->getReceiverLocation(), Record);
875 if (E->isObjectReceiver()) {
876 Record.push_back(0);
877 Writer.AddStmt(E->getBase());
878 } else if (E->isSuperReceiver()) {
879 Record.push_back(1);
880 Writer.AddTypeRef(E->getSuperReceiverType(), Record);
881 } else {
882 Record.push_back(2);
883 Writer.AddDeclRef(E->getClassReceiver(), Record);
884 }
885
886 Code = serialization::EXPR_OBJC_PROPERTY_REF_EXPR;
887 }
888
VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr * E)889 void ASTStmtWriter::VisitObjCSubscriptRefExpr(ObjCSubscriptRefExpr *E) {
890 VisitExpr(E);
891 Writer.AddSourceLocation(E->getRBracket(), Record);
892 Writer.AddStmt(E->getBaseExpr());
893 Writer.AddStmt(E->getKeyExpr());
894 Writer.AddDeclRef(E->getAtIndexMethodDecl(), Record);
895 Writer.AddDeclRef(E->setAtIndexMethodDecl(), Record);
896
897 Code = serialization::EXPR_OBJC_SUBSCRIPT_REF_EXPR;
898 }
899
VisitObjCMessageExpr(ObjCMessageExpr * E)900 void ASTStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
901 VisitExpr(E);
902 Record.push_back(E->getNumArgs());
903 Record.push_back(E->getNumStoredSelLocs());
904 Record.push_back(E->SelLocsKind);
905 Record.push_back(E->isDelegateInitCall());
906 Record.push_back(E->IsImplicit);
907 Record.push_back((unsigned)E->getReceiverKind()); // FIXME: stable encoding
908 switch (E->getReceiverKind()) {
909 case ObjCMessageExpr::Instance:
910 Writer.AddStmt(E->getInstanceReceiver());
911 break;
912
913 case ObjCMessageExpr::Class:
914 Writer.AddTypeSourceInfo(E->getClassReceiverTypeInfo(), Record);
915 break;
916
917 case ObjCMessageExpr::SuperClass:
918 case ObjCMessageExpr::SuperInstance:
919 Writer.AddTypeRef(E->getSuperType(), Record);
920 Writer.AddSourceLocation(E->getSuperLoc(), Record);
921 break;
922 }
923
924 if (E->getMethodDecl()) {
925 Record.push_back(1);
926 Writer.AddDeclRef(E->getMethodDecl(), Record);
927 } else {
928 Record.push_back(0);
929 Writer.AddSelectorRef(E->getSelector(), Record);
930 }
931
932 Writer.AddSourceLocation(E->getLeftLoc(), Record);
933 Writer.AddSourceLocation(E->getRightLoc(), Record);
934
935 for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
936 Arg != ArgEnd; ++Arg)
937 Writer.AddStmt(*Arg);
938
939 SourceLocation *Locs = E->getStoredSelLocs();
940 for (unsigned i = 0, e = E->getNumStoredSelLocs(); i != e; ++i)
941 Writer.AddSourceLocation(Locs[i], Record);
942
943 Code = serialization::EXPR_OBJC_MESSAGE_EXPR;
944 }
945
VisitObjCForCollectionStmt(ObjCForCollectionStmt * S)946 void ASTStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
947 VisitStmt(S);
948 Writer.AddStmt(S->getElement());
949 Writer.AddStmt(S->getCollection());
950 Writer.AddStmt(S->getBody());
951 Writer.AddSourceLocation(S->getForLoc(), Record);
952 Writer.AddSourceLocation(S->getRParenLoc(), Record);
953 Code = serialization::STMT_OBJC_FOR_COLLECTION;
954 }
955
VisitObjCAtCatchStmt(ObjCAtCatchStmt * S)956 void ASTStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
957 Writer.AddStmt(S->getCatchBody());
958 Writer.AddDeclRef(S->getCatchParamDecl(), Record);
959 Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
960 Writer.AddSourceLocation(S->getRParenLoc(), Record);
961 Code = serialization::STMT_OBJC_CATCH;
962 }
963
VisitObjCAtFinallyStmt(ObjCAtFinallyStmt * S)964 void ASTStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
965 Writer.AddStmt(S->getFinallyBody());
966 Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
967 Code = serialization::STMT_OBJC_FINALLY;
968 }
969
VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt * S)970 void ASTStmtWriter::VisitObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) {
971 Writer.AddStmt(S->getSubStmt());
972 Writer.AddSourceLocation(S->getAtLoc(), Record);
973 Code = serialization::STMT_OBJC_AUTORELEASE_POOL;
974 }
975
VisitObjCAtTryStmt(ObjCAtTryStmt * S)976 void ASTStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
977 Record.push_back(S->getNumCatchStmts());
978 Record.push_back(S->getFinallyStmt() != 0);
979 Writer.AddStmt(S->getTryBody());
980 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
981 Writer.AddStmt(S->getCatchStmt(I));
982 if (S->getFinallyStmt())
983 Writer.AddStmt(S->getFinallyStmt());
984 Writer.AddSourceLocation(S->getAtTryLoc(), Record);
985 Code = serialization::STMT_OBJC_AT_TRY;
986 }
987
VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt * S)988 void ASTStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
989 Writer.AddStmt(S->getSynchExpr());
990 Writer.AddStmt(S->getSynchBody());
991 Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
992 Code = serialization::STMT_OBJC_AT_SYNCHRONIZED;
993 }
994
VisitObjCAtThrowStmt(ObjCAtThrowStmt * S)995 void ASTStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
996 Writer.AddStmt(S->getThrowExpr());
997 Writer.AddSourceLocation(S->getThrowLoc(), Record);
998 Code = serialization::STMT_OBJC_AT_THROW;
999 }
1000
VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr * E)1001 void ASTStmtWriter::VisitObjCBoolLiteralExpr(ObjCBoolLiteralExpr *E) {
1002 VisitExpr(E);
1003 Record.push_back(E->getValue());
1004 Writer.AddSourceLocation(E->getLocation(), Record);
1005 Code = serialization::EXPR_OBJC_BOOL_LITERAL;
1006 }
1007
1008 //===----------------------------------------------------------------------===//
1009 // C++ Expressions and Statements.
1010 //===----------------------------------------------------------------------===//
1011
VisitCXXCatchStmt(CXXCatchStmt * S)1012 void ASTStmtWriter::VisitCXXCatchStmt(CXXCatchStmt *S) {
1013 VisitStmt(S);
1014 Writer.AddSourceLocation(S->getCatchLoc(), Record);
1015 Writer.AddDeclRef(S->getExceptionDecl(), Record);
1016 Writer.AddStmt(S->getHandlerBlock());
1017 Code = serialization::STMT_CXX_CATCH;
1018 }
1019
VisitCXXTryStmt(CXXTryStmt * S)1020 void ASTStmtWriter::VisitCXXTryStmt(CXXTryStmt *S) {
1021 VisitStmt(S);
1022 Record.push_back(S->getNumHandlers());
1023 Writer.AddSourceLocation(S->getTryLoc(), Record);
1024 Writer.AddStmt(S->getTryBlock());
1025 for (unsigned i = 0, e = S->getNumHandlers(); i != e; ++i)
1026 Writer.AddStmt(S->getHandler(i));
1027 Code = serialization::STMT_CXX_TRY;
1028 }
1029
VisitCXXForRangeStmt(CXXForRangeStmt * S)1030 void ASTStmtWriter::VisitCXXForRangeStmt(CXXForRangeStmt *S) {
1031 VisitStmt(S);
1032 Writer.AddSourceLocation(S->getForLoc(), Record);
1033 Writer.AddSourceLocation(S->getColonLoc(), Record);
1034 Writer.AddSourceLocation(S->getRParenLoc(), Record);
1035 Writer.AddStmt(S->getRangeStmt());
1036 Writer.AddStmt(S->getBeginEndStmt());
1037 Writer.AddStmt(S->getCond());
1038 Writer.AddStmt(S->getInc());
1039 Writer.AddStmt(S->getLoopVarStmt());
1040 Writer.AddStmt(S->getBody());
1041 Code = serialization::STMT_CXX_FOR_RANGE;
1042 }
1043
VisitMSDependentExistsStmt(MSDependentExistsStmt * S)1044 void ASTStmtWriter::VisitMSDependentExistsStmt(MSDependentExistsStmt *S) {
1045 VisitStmt(S);
1046 Writer.AddSourceLocation(S->getKeywordLoc(), Record);
1047 Record.push_back(S->isIfExists());
1048 Writer.AddNestedNameSpecifierLoc(S->getQualifierLoc(), Record);
1049 Writer.AddDeclarationNameInfo(S->getNameInfo(), Record);
1050 Writer.AddStmt(S->getSubStmt());
1051 Code = serialization::STMT_MS_DEPENDENT_EXISTS;
1052 }
1053
VisitCXXOperatorCallExpr(CXXOperatorCallExpr * E)1054 void ASTStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
1055 VisitCallExpr(E);
1056 Record.push_back(E->getOperator());
1057 Writer.AddSourceRange(E->Range, Record);
1058 Code = serialization::EXPR_CXX_OPERATOR_CALL;
1059 }
1060
VisitCXXMemberCallExpr(CXXMemberCallExpr * E)1061 void ASTStmtWriter::VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
1062 VisitCallExpr(E);
1063 Code = serialization::EXPR_CXX_MEMBER_CALL;
1064 }
1065
VisitCXXConstructExpr(CXXConstructExpr * E)1066 void ASTStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
1067 VisitExpr(E);
1068 Record.push_back(E->getNumArgs());
1069 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1070 Writer.AddStmt(E->getArg(I));
1071 Writer.AddDeclRef(E->getConstructor(), Record);
1072 Writer.AddSourceLocation(E->getLocation(), Record);
1073 Record.push_back(E->isElidable());
1074 Record.push_back(E->hadMultipleCandidates());
1075 Record.push_back(E->requiresZeroInitialization());
1076 Record.push_back(E->getConstructionKind()); // FIXME: stable encoding
1077 Writer.AddSourceRange(E->getParenRange(), Record);
1078 Code = serialization::EXPR_CXX_CONSTRUCT;
1079 }
1080
VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr * E)1081 void ASTStmtWriter::VisitCXXTemporaryObjectExpr(CXXTemporaryObjectExpr *E) {
1082 VisitCXXConstructExpr(E);
1083 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1084 Code = serialization::EXPR_CXX_TEMPORARY_OBJECT;
1085 }
1086
VisitLambdaExpr(LambdaExpr * E)1087 void ASTStmtWriter::VisitLambdaExpr(LambdaExpr *E) {
1088 VisitExpr(E);
1089 Record.push_back(E->NumCaptures);
1090 unsigned NumArrayIndexVars = 0;
1091 if (E->HasArrayIndexVars)
1092 NumArrayIndexVars = E->getArrayIndexStarts()[E->NumCaptures];
1093 Record.push_back(NumArrayIndexVars);
1094 Writer.AddSourceRange(E->IntroducerRange, Record);
1095 Record.push_back(E->CaptureDefault); // FIXME: stable encoding
1096 Record.push_back(E->ExplicitParams);
1097 Record.push_back(E->ExplicitResultType);
1098 Writer.AddSourceLocation(E->ClosingBrace, Record);
1099
1100 // Add capture initializers.
1101 for (LambdaExpr::capture_init_iterator C = E->capture_init_begin(),
1102 CEnd = E->capture_init_end();
1103 C != CEnd; ++C) {
1104 Writer.AddStmt(*C);
1105 }
1106
1107 // Add array index variables, if any.
1108 if (NumArrayIndexVars) {
1109 Record.append(E->getArrayIndexStarts(),
1110 E->getArrayIndexStarts() + E->NumCaptures + 1);
1111 VarDecl **ArrayIndexVars = E->getArrayIndexVars();
1112 for (unsigned I = 0; I != NumArrayIndexVars; ++I)
1113 Writer.AddDeclRef(ArrayIndexVars[I], Record);
1114 }
1115
1116 Code = serialization::EXPR_LAMBDA;
1117 }
1118
VisitCXXNamedCastExpr(CXXNamedCastExpr * E)1119 void ASTStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
1120 VisitExplicitCastExpr(E);
1121 Writer.AddSourceRange(SourceRange(E->getOperatorLoc(), E->getRParenLoc()),
1122 Record);
1123 }
1124
VisitCXXStaticCastExpr(CXXStaticCastExpr * E)1125 void ASTStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
1126 VisitCXXNamedCastExpr(E);
1127 Code = serialization::EXPR_CXX_STATIC_CAST;
1128 }
1129
VisitCXXDynamicCastExpr(CXXDynamicCastExpr * E)1130 void ASTStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
1131 VisitCXXNamedCastExpr(E);
1132 Code = serialization::EXPR_CXX_DYNAMIC_CAST;
1133 }
1134
VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr * E)1135 void ASTStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
1136 VisitCXXNamedCastExpr(E);
1137 Code = serialization::EXPR_CXX_REINTERPRET_CAST;
1138 }
1139
VisitCXXConstCastExpr(CXXConstCastExpr * E)1140 void ASTStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
1141 VisitCXXNamedCastExpr(E);
1142 Code = serialization::EXPR_CXX_CONST_CAST;
1143 }
1144
VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr * E)1145 void ASTStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
1146 VisitExplicitCastExpr(E);
1147 Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
1148 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1149 Code = serialization::EXPR_CXX_FUNCTIONAL_CAST;
1150 }
1151
VisitUserDefinedLiteral(UserDefinedLiteral * E)1152 void ASTStmtWriter::VisitUserDefinedLiteral(UserDefinedLiteral *E) {
1153 VisitCallExpr(E);
1154 Writer.AddSourceLocation(E->UDSuffixLoc, Record);
1155 Code = serialization::EXPR_USER_DEFINED_LITERAL;
1156 }
1157
VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr * E)1158 void ASTStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
1159 VisitExpr(E);
1160 Record.push_back(E->getValue());
1161 Writer.AddSourceLocation(E->getLocation(), Record);
1162 Code = serialization::EXPR_CXX_BOOL_LITERAL;
1163 }
1164
VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr * E)1165 void ASTStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
1166 VisitExpr(E);
1167 Writer.AddSourceLocation(E->getLocation(), Record);
1168 Code = serialization::EXPR_CXX_NULL_PTR_LITERAL;
1169 }
1170
VisitCXXTypeidExpr(CXXTypeidExpr * E)1171 void ASTStmtWriter::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
1172 VisitExpr(E);
1173 Writer.AddSourceRange(E->getSourceRange(), Record);
1174 if (E->isTypeOperand()) {
1175 Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1176 Code = serialization::EXPR_CXX_TYPEID_TYPE;
1177 } else {
1178 Writer.AddStmt(E->getExprOperand());
1179 Code = serialization::EXPR_CXX_TYPEID_EXPR;
1180 }
1181 }
1182
VisitCXXThisExpr(CXXThisExpr * E)1183 void ASTStmtWriter::VisitCXXThisExpr(CXXThisExpr *E) {
1184 VisitExpr(E);
1185 Writer.AddSourceLocation(E->getLocation(), Record);
1186 Record.push_back(E->isImplicit());
1187 Code = serialization::EXPR_CXX_THIS;
1188 }
1189
VisitCXXThrowExpr(CXXThrowExpr * E)1190 void ASTStmtWriter::VisitCXXThrowExpr(CXXThrowExpr *E) {
1191 VisitExpr(E);
1192 Writer.AddSourceLocation(E->getThrowLoc(), Record);
1193 Writer.AddStmt(E->getSubExpr());
1194 Record.push_back(E->isThrownVariableInScope());
1195 Code = serialization::EXPR_CXX_THROW;
1196 }
1197
VisitCXXDefaultArgExpr(CXXDefaultArgExpr * E)1198 void ASTStmtWriter::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
1199 VisitExpr(E);
1200
1201 bool HasOtherExprStored = E->Param.getInt();
1202 // Store these first, the reader reads them before creation.
1203 Record.push_back(HasOtherExprStored);
1204 if (HasOtherExprStored)
1205 Writer.AddStmt(E->getExpr());
1206 Writer.AddDeclRef(E->getParam(), Record);
1207 Writer.AddSourceLocation(E->getUsedLocation(), Record);
1208
1209 Code = serialization::EXPR_CXX_DEFAULT_ARG;
1210 }
1211
VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr * E)1212 void ASTStmtWriter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
1213 VisitExpr(E);
1214 Writer.AddCXXTemporary(E->getTemporary(), Record);
1215 Writer.AddStmt(E->getSubExpr());
1216 Code = serialization::EXPR_CXX_BIND_TEMPORARY;
1217 }
1218
VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr * E)1219 void ASTStmtWriter::VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) {
1220 VisitExpr(E);
1221 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1222 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1223 Code = serialization::EXPR_CXX_SCALAR_VALUE_INIT;
1224 }
1225
VisitCXXNewExpr(CXXNewExpr * E)1226 void ASTStmtWriter::VisitCXXNewExpr(CXXNewExpr *E) {
1227 VisitExpr(E);
1228 Record.push_back(E->isGlobalNew());
1229 Record.push_back(E->isArray());
1230 Record.push_back(E->doesUsualArrayDeleteWantSize());
1231 Record.push_back(E->getNumPlacementArgs());
1232 Record.push_back(E->StoredInitializationStyle);
1233 Writer.AddDeclRef(E->getOperatorNew(), Record);
1234 Writer.AddDeclRef(E->getOperatorDelete(), Record);
1235 Writer.AddTypeSourceInfo(E->getAllocatedTypeSourceInfo(), Record);
1236 Writer.AddSourceRange(E->getTypeIdParens(), Record);
1237 Writer.AddSourceLocation(E->getStartLoc(), Record);
1238 Writer.AddSourceRange(E->getDirectInitRange(), Record);
1239 for (CXXNewExpr::arg_iterator I = E->raw_arg_begin(), e = E->raw_arg_end();
1240 I != e; ++I)
1241 Writer.AddStmt(*I);
1242
1243 Code = serialization::EXPR_CXX_NEW;
1244 }
1245
VisitCXXDeleteExpr(CXXDeleteExpr * E)1246 void ASTStmtWriter::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
1247 VisitExpr(E);
1248 Record.push_back(E->isGlobalDelete());
1249 Record.push_back(E->isArrayForm());
1250 Record.push_back(E->isArrayFormAsWritten());
1251 Record.push_back(E->doesUsualArrayDeleteWantSize());
1252 Writer.AddDeclRef(E->getOperatorDelete(), Record);
1253 Writer.AddStmt(E->getArgument());
1254 Writer.AddSourceLocation(E->getSourceRange().getBegin(), Record);
1255
1256 Code = serialization::EXPR_CXX_DELETE;
1257 }
1258
VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr * E)1259 void ASTStmtWriter::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
1260 VisitExpr(E);
1261
1262 Writer.AddStmt(E->getBase());
1263 Record.push_back(E->isArrow());
1264 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1265 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1266 Writer.AddTypeSourceInfo(E->getScopeTypeInfo(), Record);
1267 Writer.AddSourceLocation(E->getColonColonLoc(), Record);
1268 Writer.AddSourceLocation(E->getTildeLoc(), Record);
1269
1270 // PseudoDestructorTypeStorage.
1271 Writer.AddIdentifierRef(E->getDestroyedTypeIdentifier(), Record);
1272 if (E->getDestroyedTypeIdentifier())
1273 Writer.AddSourceLocation(E->getDestroyedTypeLoc(), Record);
1274 else
1275 Writer.AddTypeSourceInfo(E->getDestroyedTypeInfo(), Record);
1276
1277 Code = serialization::EXPR_CXX_PSEUDO_DESTRUCTOR;
1278 }
1279
VisitExprWithCleanups(ExprWithCleanups * E)1280 void ASTStmtWriter::VisitExprWithCleanups(ExprWithCleanups *E) {
1281 VisitExpr(E);
1282 Record.push_back(E->getNumObjects());
1283 for (unsigned i = 0, e = E->getNumObjects(); i != e; ++i)
1284 Writer.AddDeclRef(E->getObject(i), Record);
1285
1286 Writer.AddStmt(E->getSubExpr());
1287 Code = serialization::EXPR_EXPR_WITH_CLEANUPS;
1288 }
1289
1290 void
VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr * E)1291 ASTStmtWriter::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
1292 VisitExpr(E);
1293
1294 // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1295 // emitted first.
1296
1297 Record.push_back(E->HasTemplateKWAndArgsInfo);
1298 if (E->HasTemplateKWAndArgsInfo) {
1299 const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo();
1300 Record.push_back(Args.NumTemplateArgs);
1301 AddTemplateKWAndArgsInfo(Args);
1302 }
1303
1304 if (!E->isImplicitAccess())
1305 Writer.AddStmt(E->getBase());
1306 else
1307 Writer.AddStmt(0);
1308 Writer.AddTypeRef(E->getBaseType(), Record);
1309 Record.push_back(E->isArrow());
1310 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1311 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1312 Writer.AddDeclRef(E->getFirstQualifierFoundInScope(), Record);
1313 Writer.AddDeclarationNameInfo(E->MemberNameInfo, Record);
1314 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_MEMBER;
1315 }
1316
1317 void
VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr * E)1318 ASTStmtWriter::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
1319 VisitExpr(E);
1320
1321 // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1322 // emitted first.
1323
1324 Record.push_back(E->HasTemplateKWAndArgsInfo);
1325 if (E->HasTemplateKWAndArgsInfo) {
1326 const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo();
1327 Record.push_back(Args.NumTemplateArgs);
1328 AddTemplateKWAndArgsInfo(Args);
1329 }
1330
1331 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1332 Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1333 Code = serialization::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF;
1334 }
1335
1336 void
VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr * E)1337 ASTStmtWriter::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
1338 VisitExpr(E);
1339 Record.push_back(E->arg_size());
1340 for (CXXUnresolvedConstructExpr::arg_iterator
1341 ArgI = E->arg_begin(), ArgE = E->arg_end(); ArgI != ArgE; ++ArgI)
1342 Writer.AddStmt(*ArgI);
1343 Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
1344 Writer.AddSourceLocation(E->getLParenLoc(), Record);
1345 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1346 Code = serialization::EXPR_CXX_UNRESOLVED_CONSTRUCT;
1347 }
1348
VisitOverloadExpr(OverloadExpr * E)1349 void ASTStmtWriter::VisitOverloadExpr(OverloadExpr *E) {
1350 VisitExpr(E);
1351
1352 // Don't emit anything here, HasTemplateKWAndArgsInfo must be
1353 // emitted first.
1354
1355 Record.push_back(E->HasTemplateKWAndArgsInfo);
1356 if (E->HasTemplateKWAndArgsInfo) {
1357 const ASTTemplateKWAndArgsInfo &Args = *E->getTemplateKWAndArgsInfo();
1358 Record.push_back(Args.NumTemplateArgs);
1359 AddTemplateKWAndArgsInfo(Args);
1360 }
1361
1362 Record.push_back(E->getNumDecls());
1363 for (OverloadExpr::decls_iterator
1364 OvI = E->decls_begin(), OvE = E->decls_end(); OvI != OvE; ++OvI) {
1365 Writer.AddDeclRef(OvI.getDecl(), Record);
1366 Record.push_back(OvI.getAccess());
1367 }
1368
1369 Writer.AddDeclarationNameInfo(E->NameInfo, Record);
1370 Writer.AddNestedNameSpecifierLoc(E->getQualifierLoc(), Record);
1371 }
1372
VisitUnresolvedMemberExpr(UnresolvedMemberExpr * E)1373 void ASTStmtWriter::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
1374 VisitOverloadExpr(E);
1375 Record.push_back(E->isArrow());
1376 Record.push_back(E->hasUnresolvedUsing());
1377 Writer.AddStmt(!E->isImplicitAccess() ? E->getBase() : 0);
1378 Writer.AddTypeRef(E->getBaseType(), Record);
1379 Writer.AddSourceLocation(E->getOperatorLoc(), Record);
1380 Code = serialization::EXPR_CXX_UNRESOLVED_MEMBER;
1381 }
1382
VisitUnresolvedLookupExpr(UnresolvedLookupExpr * E)1383 void ASTStmtWriter::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
1384 VisitOverloadExpr(E);
1385 Record.push_back(E->requiresADL());
1386 if (E->requiresADL())
1387 Record.push_back(E->isStdAssociatedNamespace());
1388 Record.push_back(E->isOverloaded());
1389 Writer.AddDeclRef(E->getNamingClass(), Record);
1390 Code = serialization::EXPR_CXX_UNRESOLVED_LOOKUP;
1391 }
1392
VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr * E)1393 void ASTStmtWriter::VisitUnaryTypeTraitExpr(UnaryTypeTraitExpr *E) {
1394 VisitExpr(E);
1395 Record.push_back(E->getTrait());
1396 Record.push_back(E->getValue());
1397 Writer.AddSourceRange(E->getSourceRange(), Record);
1398 Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1399 Code = serialization::EXPR_CXX_UNARY_TYPE_TRAIT;
1400 }
1401
VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr * E)1402 void ASTStmtWriter::VisitBinaryTypeTraitExpr(BinaryTypeTraitExpr *E) {
1403 VisitExpr(E);
1404 Record.push_back(E->getTrait());
1405 Record.push_back(E->getValue());
1406 Writer.AddSourceRange(E->getSourceRange(), Record);
1407 Writer.AddTypeSourceInfo(E->getLhsTypeSourceInfo(), Record);
1408 Writer.AddTypeSourceInfo(E->getRhsTypeSourceInfo(), Record);
1409 Code = serialization::EXPR_BINARY_TYPE_TRAIT;
1410 }
1411
VisitTypeTraitExpr(TypeTraitExpr * E)1412 void ASTStmtWriter::VisitTypeTraitExpr(TypeTraitExpr *E) {
1413 VisitExpr(E);
1414 Record.push_back(E->TypeTraitExprBits.NumArgs);
1415 Record.push_back(E->TypeTraitExprBits.Kind); // FIXME: Stable encoding
1416 Record.push_back(E->TypeTraitExprBits.Value);
1417 for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
1418 Writer.AddTypeSourceInfo(E->getArg(I), Record);
1419 Code = serialization::EXPR_TYPE_TRAIT;
1420 }
1421
VisitArrayTypeTraitExpr(ArrayTypeTraitExpr * E)1422 void ASTStmtWriter::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
1423 VisitExpr(E);
1424 Record.push_back(E->getTrait());
1425 Record.push_back(E->getValue());
1426 Writer.AddSourceRange(E->getSourceRange(), Record);
1427 Writer.AddTypeSourceInfo(E->getQueriedTypeSourceInfo(), Record);
1428 Code = serialization::EXPR_ARRAY_TYPE_TRAIT;
1429 }
1430
VisitExpressionTraitExpr(ExpressionTraitExpr * E)1431 void ASTStmtWriter::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
1432 VisitExpr(E);
1433 Record.push_back(E->getTrait());
1434 Record.push_back(E->getValue());
1435 Writer.AddSourceRange(E->getSourceRange(), Record);
1436 Writer.AddStmt(E->getQueriedExpression());
1437 Code = serialization::EXPR_CXX_EXPRESSION_TRAIT;
1438 }
1439
VisitCXXNoexceptExpr(CXXNoexceptExpr * E)1440 void ASTStmtWriter::VisitCXXNoexceptExpr(CXXNoexceptExpr *E) {
1441 VisitExpr(E);
1442 Record.push_back(E->getValue());
1443 Writer.AddSourceRange(E->getSourceRange(), Record);
1444 Writer.AddStmt(E->getOperand());
1445 Code = serialization::EXPR_CXX_NOEXCEPT;
1446 }
1447
VisitPackExpansionExpr(PackExpansionExpr * E)1448 void ASTStmtWriter::VisitPackExpansionExpr(PackExpansionExpr *E) {
1449 VisitExpr(E);
1450 Writer.AddSourceLocation(E->getEllipsisLoc(), Record);
1451 Record.push_back(E->NumExpansions);
1452 Writer.AddStmt(E->getPattern());
1453 Code = serialization::EXPR_PACK_EXPANSION;
1454 }
1455
VisitSizeOfPackExpr(SizeOfPackExpr * E)1456 void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr *E) {
1457 VisitExpr(E);
1458 Writer.AddSourceLocation(E->OperatorLoc, Record);
1459 Writer.AddSourceLocation(E->PackLoc, Record);
1460 Writer.AddSourceLocation(E->RParenLoc, Record);
1461 Record.push_back(E->Length);
1462 Writer.AddDeclRef(E->Pack, Record);
1463 Code = serialization::EXPR_SIZEOF_PACK;
1464 }
1465
VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr * E)1466 void ASTStmtWriter::VisitSubstNonTypeTemplateParmExpr(
1467 SubstNonTypeTemplateParmExpr *E) {
1468 VisitExpr(E);
1469 Writer.AddDeclRef(E->getParameter(), Record);
1470 Writer.AddSourceLocation(E->getNameLoc(), Record);
1471 Writer.AddStmt(E->getReplacement());
1472 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM;
1473 }
1474
VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr * E)1475 void ASTStmtWriter::VisitSubstNonTypeTemplateParmPackExpr(
1476 SubstNonTypeTemplateParmPackExpr *E) {
1477 VisitExpr(E);
1478 Writer.AddDeclRef(E->getParameterPack(), Record);
1479 Writer.AddTemplateArgument(E->getArgumentPack(), Record);
1480 Writer.AddSourceLocation(E->getParameterPackLocation(), Record);
1481 Code = serialization::EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK;
1482 }
1483
VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr * E)1484 void ASTStmtWriter::VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
1485 VisitExpr(E);
1486 Writer.AddStmt(E->Temporary);
1487 Code = serialization::EXPR_MATERIALIZE_TEMPORARY;
1488 }
1489
VisitOpaqueValueExpr(OpaqueValueExpr * E)1490 void ASTStmtWriter::VisitOpaqueValueExpr(OpaqueValueExpr *E) {
1491 VisitExpr(E);
1492 Writer.AddStmt(E->getSourceExpr());
1493 Writer.AddSourceLocation(E->getLocation(), Record);
1494 Code = serialization::EXPR_OPAQUE_VALUE;
1495 }
1496
1497 //===----------------------------------------------------------------------===//
1498 // CUDA Expressions and Statements.
1499 //===----------------------------------------------------------------------===//
1500
VisitCUDAKernelCallExpr(CUDAKernelCallExpr * E)1501 void ASTStmtWriter::VisitCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
1502 VisitCallExpr(E);
1503 Writer.AddStmt(E->getConfig());
1504 Code = serialization::EXPR_CUDA_KERNEL_CALL;
1505 }
1506
1507 //===----------------------------------------------------------------------===//
1508 // OpenCL Expressions and Statements.
1509 //===----------------------------------------------------------------------===//
VisitAsTypeExpr(AsTypeExpr * E)1510 void ASTStmtWriter::VisitAsTypeExpr(AsTypeExpr *E) {
1511 VisitExpr(E);
1512 Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
1513 Writer.AddSourceLocation(E->getRParenLoc(), Record);
1514 Writer.AddStmt(E->getSrcExpr());
1515 Code = serialization::EXPR_ASTYPE;
1516 }
1517
1518 //===----------------------------------------------------------------------===//
1519 // Microsoft Expressions and Statements.
1520 //===----------------------------------------------------------------------===//
VisitCXXUuidofExpr(CXXUuidofExpr * E)1521 void ASTStmtWriter::VisitCXXUuidofExpr(CXXUuidofExpr *E) {
1522 VisitExpr(E);
1523 Writer.AddSourceRange(E->getSourceRange(), Record);
1524 if (E->isTypeOperand()) {
1525 Writer.AddTypeSourceInfo(E->getTypeOperandSourceInfo(), Record);
1526 Code = serialization::EXPR_CXX_UUIDOF_TYPE;
1527 } else {
1528 Writer.AddStmt(E->getExprOperand());
1529 Code = serialization::EXPR_CXX_UUIDOF_EXPR;
1530 }
1531 }
1532
VisitSEHExceptStmt(SEHExceptStmt * S)1533 void ASTStmtWriter::VisitSEHExceptStmt(SEHExceptStmt *S) {
1534 VisitStmt(S);
1535 Writer.AddSourceLocation(S->getExceptLoc(), Record);
1536 Writer.AddStmt(S->getFilterExpr());
1537 Writer.AddStmt(S->getBlock());
1538 Code = serialization::STMT_SEH_EXCEPT;
1539 }
1540
VisitSEHFinallyStmt(SEHFinallyStmt * S)1541 void ASTStmtWriter::VisitSEHFinallyStmt(SEHFinallyStmt *S) {
1542 VisitStmt(S);
1543 Writer.AddSourceLocation(S->getFinallyLoc(), Record);
1544 Writer.AddStmt(S->getBlock());
1545 Code = serialization::STMT_SEH_FINALLY;
1546 }
1547
VisitSEHTryStmt(SEHTryStmt * S)1548 void ASTStmtWriter::VisitSEHTryStmt(SEHTryStmt *S) {
1549 VisitStmt(S);
1550 Record.push_back(S->getIsCXXTry());
1551 Writer.AddSourceLocation(S->getTryLoc(), Record);
1552 Writer.AddStmt(S->getTryBlock());
1553 Writer.AddStmt(S->getHandler());
1554 Code = serialization::STMT_SEH_TRY;
1555 }
1556
1557 //===----------------------------------------------------------------------===//
1558 // ASTWriter Implementation
1559 //===----------------------------------------------------------------------===//
1560
RecordSwitchCaseID(SwitchCase * S)1561 unsigned ASTWriter::RecordSwitchCaseID(SwitchCase *S) {
1562 assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
1563 "SwitchCase recorded twice");
1564 unsigned NextID = SwitchCaseIDs.size();
1565 SwitchCaseIDs[S] = NextID;
1566 return NextID;
1567 }
1568
getSwitchCaseID(SwitchCase * S)1569 unsigned ASTWriter::getSwitchCaseID(SwitchCase *S) {
1570 assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
1571 "SwitchCase hasn't been seen yet");
1572 return SwitchCaseIDs[S];
1573 }
1574
ClearSwitchCaseIDs()1575 void ASTWriter::ClearSwitchCaseIDs() {
1576 SwitchCaseIDs.clear();
1577 }
1578
1579 /// \brief Write the given substatement or subexpression to the
1580 /// bitstream.
WriteSubStmt(Stmt * S,llvm::DenseMap<Stmt *,uint64_t> & SubStmtEntries,llvm::DenseSet<Stmt * > & ParentStmts)1581 void ASTWriter::WriteSubStmt(Stmt *S,
1582 llvm::DenseMap<Stmt *, uint64_t> &SubStmtEntries,
1583 llvm::DenseSet<Stmt *> &ParentStmts) {
1584 RecordData Record;
1585 ASTStmtWriter Writer(*this, Record);
1586 ++NumStatements;
1587
1588 if (!S) {
1589 Stream.EmitRecord(serialization::STMT_NULL_PTR, Record);
1590 return;
1591 }
1592
1593 llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
1594 if (I != SubStmtEntries.end()) {
1595 Record.push_back(I->second);
1596 Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
1597 return;
1598 }
1599
1600 #ifndef NDEBUG
1601 assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
1602
1603 struct ParentStmtInserterRAII {
1604 Stmt *S;
1605 llvm::DenseSet<Stmt *> &ParentStmts;
1606
1607 ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
1608 : S(S), ParentStmts(ParentStmts) {
1609 ParentStmts.insert(S);
1610 }
1611 ~ParentStmtInserterRAII() {
1612 ParentStmts.erase(S);
1613 }
1614 };
1615
1616 ParentStmtInserterRAII ParentStmtInserter(S, ParentStmts);
1617 #endif
1618
1619 // Redirect ASTWriter::AddStmt to collect sub stmts.
1620 SmallVector<Stmt *, 16> SubStmts;
1621 CollectedStmts = &SubStmts;
1622
1623 Writer.Code = serialization::STMT_NULL_PTR;
1624 Writer.AbbrevToUse = 0;
1625 Writer.Visit(S);
1626
1627 #ifndef NDEBUG
1628 if (Writer.Code == serialization::STMT_NULL_PTR) {
1629 SourceManager &SrcMgr
1630 = DeclIDs.begin()->first->getASTContext().getSourceManager();
1631 S->dump(SrcMgr);
1632 llvm_unreachable("Unhandled sub statement writing AST file");
1633 }
1634 #endif
1635
1636 // Revert ASTWriter::AddStmt.
1637 CollectedStmts = &StmtsToEmit;
1638
1639 // Write the sub stmts in reverse order, last to first. When reading them back
1640 // we will read them in correct order by "pop"ing them from the Stmts stack.
1641 // This simplifies reading and allows to store a variable number of sub stmts
1642 // without knowing it in advance.
1643 while (!SubStmts.empty())
1644 WriteSubStmt(SubStmts.pop_back_val(), SubStmtEntries, ParentStmts);
1645
1646 Stream.EmitRecord(Writer.Code, Record, Writer.AbbrevToUse);
1647
1648 SubStmtEntries[S] = Stream.GetCurrentBitNo();
1649 }
1650
1651 /// \brief Flush all of the statements that have been added to the
1652 /// queue via AddStmt().
FlushStmts()1653 void ASTWriter::FlushStmts() {
1654 RecordData Record;
1655
1656 // We expect to be the only consumer of the two temporary statement maps,
1657 // assert that they are empty.
1658 assert(SubStmtEntries.empty() && "unexpected entries in sub stmt map");
1659 assert(ParentStmts.empty() && "unexpected entries in parent stmt map");
1660
1661 for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
1662 WriteSubStmt(StmtsToEmit[I], SubStmtEntries, ParentStmts);
1663
1664 assert(N == StmtsToEmit.size() &&
1665 "Substatement written via AddStmt rather than WriteSubStmt!");
1666
1667 // Note that we are at the end of a full expression. Any
1668 // expression records that follow this one are part of a different
1669 // expression.
1670 Stream.EmitRecord(serialization::STMT_STOP, Record);
1671
1672 SubStmtEntries.clear();
1673 ParentStmts.clear();
1674 }
1675
1676 StmtsToEmit.clear();
1677 }
1678