 |
|
 |
|
| Files: |
1 |
|
Branches Taken: |
83.3% |
50 / 60 |
| Generated: |
2010-02-10 01:31 |
|
Branches Executed: |
96.7% |
58 / 60 |
| |
|
Line Coverage: |
85.6% |
555 / 648 |
| |
 |
|
 |
1 : //===--- PCHWriterStmt.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/Frontend/PCHWriter.h"
15 : #include "clang/AST/DeclCXX.h"
16 : #include "clang/AST/DeclObjC.h"
17 : #include "clang/AST/StmtVisitor.h"
18 : #include "llvm/Bitcode/BitstreamWriter.h"
19 : using namespace clang;
20 :
21 : //===----------------------------------------------------------------------===//
22 : // Statement/expression serialization
23 : //===----------------------------------------------------------------------===//
24 :
25 : namespace {
26 : class PCHStmtWriter : public StmtVisitor<PCHStmtWriter, void> {
27 : PCHWriter &Writer;
28 : PCHWriter::RecordData &Record;
29 :
30 : public:
31 : pch::StmtCode Code;
32 :
33 1474: PCHStmtWriter(PCHWriter &Writer, PCHWriter::RecordData &Record)
34 1474: : Writer(Writer), Record(Record) { }
35 :
36 : void VisitStmt(Stmt *S);
37 : void VisitNullStmt(NullStmt *S);
38 : void VisitCompoundStmt(CompoundStmt *S);
39 : void VisitSwitchCase(SwitchCase *S);
40 : void VisitCaseStmt(CaseStmt *S);
41 : void VisitDefaultStmt(DefaultStmt *S);
42 : void VisitLabelStmt(LabelStmt *S);
43 : void VisitIfStmt(IfStmt *S);
44 : void VisitSwitchStmt(SwitchStmt *S);
45 : void VisitWhileStmt(WhileStmt *S);
46 : void VisitDoStmt(DoStmt *S);
47 : void VisitForStmt(ForStmt *S);
48 : void VisitGotoStmt(GotoStmt *S);
49 : void VisitIndirectGotoStmt(IndirectGotoStmt *S);
50 : void VisitContinueStmt(ContinueStmt *S);
51 : void VisitBreakStmt(BreakStmt *S);
52 : void VisitReturnStmt(ReturnStmt *S);
53 : void VisitDeclStmt(DeclStmt *S);
54 : void VisitAsmStmt(AsmStmt *S);
55 : void VisitExpr(Expr *E);
56 : void VisitPredefinedExpr(PredefinedExpr *E);
57 : void VisitDeclRefExpr(DeclRefExpr *E);
58 : void VisitIntegerLiteral(IntegerLiteral *E);
59 : void VisitFloatingLiteral(FloatingLiteral *E);
60 : void VisitImaginaryLiteral(ImaginaryLiteral *E);
61 : void VisitStringLiteral(StringLiteral *E);
62 : void VisitCharacterLiteral(CharacterLiteral *E);
63 : void VisitParenExpr(ParenExpr *E);
64 : void VisitUnaryOperator(UnaryOperator *E);
65 : void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
66 : void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
67 : void VisitCallExpr(CallExpr *E);
68 : void VisitMemberExpr(MemberExpr *E);
69 : void VisitCastExpr(CastExpr *E);
70 : void VisitBinaryOperator(BinaryOperator *E);
71 : void VisitCompoundAssignOperator(CompoundAssignOperator *E);
72 : void VisitConditionalOperator(ConditionalOperator *E);
73 : void VisitImplicitCastExpr(ImplicitCastExpr *E);
74 : void VisitExplicitCastExpr(ExplicitCastExpr *E);
75 : void VisitCStyleCastExpr(CStyleCastExpr *E);
76 : void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
77 : void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
78 : void VisitInitListExpr(InitListExpr *E);
79 : void VisitDesignatedInitExpr(DesignatedInitExpr *E);
80 : void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
81 : void VisitVAArgExpr(VAArgExpr *E);
82 : void VisitAddrLabelExpr(AddrLabelExpr *E);
83 : void VisitStmtExpr(StmtExpr *E);
84 : void VisitTypesCompatibleExpr(TypesCompatibleExpr *E);
85 : void VisitChooseExpr(ChooseExpr *E);
86 : void VisitGNUNullExpr(GNUNullExpr *E);
87 : void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
88 : void VisitBlockExpr(BlockExpr *E);
89 : void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
90 :
91 : // Objective-C Expressions
92 : void VisitObjCStringLiteral(ObjCStringLiteral *E);
93 : void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
94 : void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
95 : void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
96 : void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
97 : void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
98 : void VisitObjCImplicitSetterGetterRefExpr(
99 : ObjCImplicitSetterGetterRefExpr *E);
100 : void VisitObjCMessageExpr(ObjCMessageExpr *E);
101 : void VisitObjCSuperExpr(ObjCSuperExpr *E);
102 : void VisitObjCIsaExpr(ObjCIsaExpr *E);
103 :
104 : // Objective-C Statements
105 : void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
106 : void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
107 : void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
108 : void VisitObjCAtTryStmt(ObjCAtTryStmt *);
109 : void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
110 : void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
111 :
112 : // C++ Statements
113 : void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
114 : void VisitCXXConstructExpr(CXXConstructExpr *E);
115 : void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
116 : void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
117 : void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
118 : void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
119 : void VisitCXXConstCastExpr(CXXConstCastExpr *E);
120 : void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
121 : void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
122 : void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
123 : };
124 : }
125 :
126 595: void PCHStmtWriter::VisitStmt(Stmt *S) {
127 595: }
128 :
129 2: void PCHStmtWriter::VisitNullStmt(NullStmt *S) {
130 2: VisitStmt(S);
131 2: Writer.AddSourceLocation(S->getSemiLoc(), Record);
132 2: Code = pch::STMT_NULL;
133 2: }
134 :
135 45: void PCHStmtWriter::VisitCompoundStmt(CompoundStmt *S) {
136 45: VisitStmt(S);
137 45: Record.push_back(S->size());
86: branch 2 taken
45: branch 3 taken
138 131: for (CompoundStmt::body_iterator CS = S->body_begin(), CSEnd = S->body_end();
139 : CS != CSEnd; ++CS)
140 86: Writer.WriteSubStmt(*CS);
141 45: Writer.AddSourceLocation(S->getLBracLoc(), Record);
142 45: Writer.AddSourceLocation(S->getRBracLoc(), Record);
143 45: Code = pch::STMT_COMPOUND;
144 45: }
145 :
146 8: void PCHStmtWriter::VisitSwitchCase(SwitchCase *S) {
147 8: VisitStmt(S);
148 8: Record.push_back(Writer.RecordSwitchCaseID(S));
149 8: }
150 :
151 6: void PCHStmtWriter::VisitCaseStmt(CaseStmt *S) {
152 6: VisitSwitchCase(S);
153 6: Writer.WriteSubStmt(S->getLHS());
154 6: Writer.WriteSubStmt(S->getRHS());
155 6: Writer.WriteSubStmt(S->getSubStmt());
156 6: Writer.AddSourceLocation(S->getCaseLoc(), Record);
157 6: Writer.AddSourceLocation(S->getEllipsisLoc(), Record);
158 6: Writer.AddSourceLocation(S->getColonLoc(), Record);
159 6: Code = pch::STMT_CASE;
160 6: }
161 :
162 2: void PCHStmtWriter::VisitDefaultStmt(DefaultStmt *S) {
163 2: VisitSwitchCase(S);
164 2: Writer.WriteSubStmt(S->getSubStmt());
165 2: Writer.AddSourceLocation(S->getDefaultLoc(), Record);
166 2: Writer.AddSourceLocation(S->getColonLoc(), Record);
167 2: Code = pch::STMT_DEFAULT;
168 2: }
169 :
170 4: void PCHStmtWriter::VisitLabelStmt(LabelStmt *S) {
171 4: VisitStmt(S);
172 4: Writer.AddIdentifierRef(S->getID(), Record);
173 4: Writer.WriteSubStmt(S->getSubStmt());
174 4: Writer.AddSourceLocation(S->getIdentLoc(), Record);
175 4: Record.push_back(Writer.GetLabelID(S));
176 4: Code = pch::STMT_LABEL;
177 4: }
178 :
179 8: void PCHStmtWriter::VisitIfStmt(IfStmt *S) {
180 8: VisitStmt(S);
181 8: Writer.AddDeclRef(S->getConditionVariable(), Record);
182 8: Writer.WriteSubStmt(S->getCond());
183 8: Writer.WriteSubStmt(S->getThen());
184 8: Writer.WriteSubStmt(S->getElse());
185 8: Writer.AddSourceLocation(S->getIfLoc(), Record);
186 8: Writer.AddSourceLocation(S->getElseLoc(), Record);
187 8: Code = pch::STMT_IF;
188 8: }
189 :
190 4: void PCHStmtWriter::VisitSwitchStmt(SwitchStmt *S) {
191 4: VisitStmt(S);
192 4: Writer.AddDeclRef(S->getConditionVariable(), Record);
193 4: Writer.WriteSubStmt(S->getCond());
194 4: Writer.WriteSubStmt(S->getBody());
195 4: Writer.AddSourceLocation(S->getSwitchLoc(), Record);
8: branch 2 taken
4: branch 3 taken
196 12: for (SwitchCase *SC = S->getSwitchCaseList(); SC;
197 : SC = SC->getNextSwitchCase())
198 8: Record.push_back(Writer.getSwitchCaseID(SC));
199 4: Code = pch::STMT_SWITCH;
200 4: }
201 :
202 3: void PCHStmtWriter::VisitWhileStmt(WhileStmt *S) {
203 3: VisitStmt(S);
204 3: Writer.AddDeclRef(S->getConditionVariable(), Record);
205 3: Writer.WriteSubStmt(S->getCond());
206 3: Writer.WriteSubStmt(S->getBody());
207 3: Writer.AddSourceLocation(S->getWhileLoc(), Record);
208 3: Code = pch::STMT_WHILE;
209 3: }
210 :
211 1: void PCHStmtWriter::VisitDoStmt(DoStmt *S) {
212 1: VisitStmt(S);
213 1: Writer.WriteSubStmt(S->getCond());
214 1: Writer.WriteSubStmt(S->getBody());
215 1: Writer.AddSourceLocation(S->getDoLoc(), Record);
216 1: Writer.AddSourceLocation(S->getWhileLoc(), Record);
217 1: Writer.AddSourceLocation(S->getRParenLoc(), Record);
218 1: Code = pch::STMT_DO;
219 1: }
220 :
221 1: void PCHStmtWriter::VisitForStmt(ForStmt *S) {
222 1: VisitStmt(S);
223 1: Writer.WriteSubStmt(S->getInit());
224 1: Writer.WriteSubStmt(S->getCond());
225 1: Writer.AddDeclRef(S->getConditionVariable(), Record);
226 1: Writer.WriteSubStmt(S->getInc());
227 1: Writer.WriteSubStmt(S->getBody());
228 1: Writer.AddSourceLocation(S->getForLoc(), Record);
229 1: Writer.AddSourceLocation(S->getLParenLoc(), Record);
230 1: Writer.AddSourceLocation(S->getRParenLoc(), Record);
231 1: Code = pch::STMT_FOR;
232 1: }
233 :
234 2: void PCHStmtWriter::VisitGotoStmt(GotoStmt *S) {
235 2: VisitStmt(S);
236 2: Record.push_back(Writer.GetLabelID(S->getLabel()));
237 2: Writer.AddSourceLocation(S->getGotoLoc(), Record);
238 2: Writer.AddSourceLocation(S->getLabelLoc(), Record);
239 2: Code = pch::STMT_GOTO;
240 2: }
241 :
242 1: void PCHStmtWriter::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
243 1: VisitStmt(S);
244 1: Writer.AddSourceLocation(S->getGotoLoc(), Record);
245 1: Writer.AddSourceLocation(S->getStarLoc(), Record);
246 1: Writer.WriteSubStmt(S->getTarget());
247 1: Code = pch::STMT_INDIRECT_GOTO;
248 1: }
249 :
250 1: void PCHStmtWriter::VisitContinueStmt(ContinueStmt *S) {
251 1: VisitStmt(S);
252 1: Writer.AddSourceLocation(S->getContinueLoc(), Record);
253 1: Code = pch::STMT_CONTINUE;
254 1: }
255 :
256 6: void PCHStmtWriter::VisitBreakStmt(BreakStmt *S) {
257 6: VisitStmt(S);
258 6: Writer.AddSourceLocation(S->getBreakLoc(), Record);
259 6: Code = pch::STMT_BREAK;
260 6: }
261 :
262 16: void PCHStmtWriter::VisitReturnStmt(ReturnStmt *S) {
263 16: VisitStmt(S);
264 16: Writer.WriteSubStmt(S->getRetValue());
265 16: Writer.AddSourceLocation(S->getReturnLoc(), Record);
266 16: Code = pch::STMT_RETURN;
267 16: }
268 :
269 24: void PCHStmtWriter::VisitDeclStmt(DeclStmt *S) {
270 24: VisitStmt(S);
271 24: Writer.AddSourceLocation(S->getStartLoc(), Record);
272 24: Writer.AddSourceLocation(S->getEndLoc(), Record);
273 24: DeclGroupRef DG = S->getDeclGroup();
29: branch 2 taken
24: branch 3 taken
274 53: for (DeclGroupRef::iterator D = DG.begin(), DEnd = DG.end(); D != DEnd; ++D)
275 29: Writer.AddDeclRef(*D, Record);
276 24: Code = pch::STMT_DECL;
277 24: }
278 :
279 5: void PCHStmtWriter::VisitAsmStmt(AsmStmt *S) {
280 5: VisitStmt(S);
281 5: Record.push_back(S->getNumOutputs());
282 5: Record.push_back(S->getNumInputs());
283 5: Record.push_back(S->getNumClobbers());
284 5: Writer.AddSourceLocation(S->getAsmLoc(), Record);
285 5: Writer.AddSourceLocation(S->getRParenLoc(), Record);
286 5: Record.push_back(S->isVolatile());
287 5: Record.push_back(S->isSimple());
288 5: Record.push_back(S->isMSAsm());
289 5: Writer.WriteSubStmt(S->getAsmString());
290 :
291 : // Outputs
1: branch 1 taken
5: branch 2 taken
292 6: for (unsigned I = 0, N = S->getNumOutputs(); I != N; ++I) {
293 1: Writer.AddIdentifierRef(S->getOutputIdentifier(I), Record);
294 1: Writer.WriteSubStmt(S->getOutputConstraintLiteral(I));
295 1: Writer.WriteSubStmt(S->getOutputExpr(I));
296 : }
297 :
298 : // Inputs
2: branch 1 taken
5: branch 2 taken
299 7: for (unsigned I = 0, N = S->getNumInputs(); I != N; ++I) {
300 2: Writer.AddIdentifierRef(S->getInputIdentifier(I), Record);
301 2: Writer.WriteSubStmt(S->getInputConstraintLiteral(I));
302 2: Writer.WriteSubStmt(S->getInputExpr(I));
303 : }
304 :
305 : // Clobbers
10: branch 1 taken
5: branch 2 taken
306 15: for (unsigned I = 0, N = S->getNumClobbers(); I != N; ++I)
307 10: Writer.WriteSubStmt(S->getClobber(I));
308 :
309 5: Code = pch::STMT_ASM;
310 5: }
311 :
312 464: void PCHStmtWriter::VisitExpr(Expr *E) {
313 464: VisitStmt(E);
314 464: Writer.AddTypeRef(E->getType(), Record);
315 464: Record.push_back(E->isTypeDependent());
316 464: Record.push_back(E->isValueDependent());
317 464: }
318 :
319 1: void PCHStmtWriter::VisitPredefinedExpr(PredefinedExpr *E) {
320 1: VisitExpr(E);
321 1: Writer.AddSourceLocation(E->getLocation(), Record);
322 1: Record.push_back(E->getIdentType()); // FIXME: stable encoding
323 1: Code = pch::EXPR_PREDEFINED;
324 1: }
325 :
326 114: void PCHStmtWriter::VisitDeclRefExpr(DeclRefExpr *E) {
327 114: VisitExpr(E);
328 114: Writer.AddDeclRef(E->getDecl(), Record);
329 114: Writer.AddSourceLocation(E->getLocation(), Record);
330 : // FIXME: write qualifier
331 : // FIXME: write explicit template arguments
332 114: Code = pch::EXPR_DECL_REF;
333 114: }
334 :
335 78: void PCHStmtWriter::VisitIntegerLiteral(IntegerLiteral *E) {
336 78: VisitExpr(E);
337 78: Writer.AddSourceLocation(E->getLocation(), Record);
338 78: Writer.AddAPInt(E->getValue(), Record);
339 78: Code = pch::EXPR_INTEGER_LITERAL;
340 78: }
341 :
342 12: void PCHStmtWriter::VisitFloatingLiteral(FloatingLiteral *E) {
343 12: VisitExpr(E);
344 12: Writer.AddAPFloat(E->getValue(), Record);
345 12: Record.push_back(E->isExact());
346 12: Writer.AddSourceLocation(E->getLocation(), Record);
347 12: Code = pch::EXPR_FLOATING_LITERAL;
348 12: }
349 :
350 1: void PCHStmtWriter::VisitImaginaryLiteral(ImaginaryLiteral *E) {
351 1: VisitExpr(E);
352 1: Writer.WriteSubStmt(E->getSubExpr());
353 1: Code = pch::EXPR_IMAGINARY_LITERAL;
354 1: }
355 :
356 26: void PCHStmtWriter::VisitStringLiteral(StringLiteral *E) {
357 26: VisitExpr(E);
358 26: Record.push_back(E->getByteLength());
359 26: Record.push_back(E->getNumConcatenated());
360 26: Record.push_back(E->isWide());
361 : // FIXME: String data should be stored as a blob at the end of the
362 : // StringLiteral. However, we can't do so now because we have no
363 : // provision for coping with abbreviations when we're jumping around
364 : // the PCH file during deserialization.
365 : Record.insert(Record.end(),
366 26: E->getStrData(), E->getStrData() + E->getByteLength());
29: branch 1 taken
26: branch 2 taken
367 55: for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
368 29: Writer.AddSourceLocation(E->getStrTokenLoc(I), Record);
369 26: Code = pch::EXPR_STRING_LITERAL;
370 26: }
371 :
372 1: void PCHStmtWriter::VisitCharacterLiteral(CharacterLiteral *E) {
373 1: VisitExpr(E);
374 1: Record.push_back(E->getValue());
375 1: Writer.AddSourceLocation(E->getLocation(), Record);
376 1: Record.push_back(E->isWide());
377 1: Code = pch::EXPR_CHARACTER_LITERAL;
378 1: }
379 :
380 47: void PCHStmtWriter::VisitParenExpr(ParenExpr *E) {
381 47: VisitExpr(E);
382 47: Writer.AddSourceLocation(E->getLParen(), Record);
383 47: Writer.AddSourceLocation(E->getRParen(), Record);
384 47: Writer.WriteSubStmt(E->getSubExpr());
385 47: Code = pch::EXPR_PAREN;
386 47: }
387 :
388 9: void PCHStmtWriter::VisitUnaryOperator(UnaryOperator *E) {
389 9: VisitExpr(E);
390 9: Writer.WriteSubStmt(E->getSubExpr());
391 9: Record.push_back(E->getOpcode()); // FIXME: stable encoding
392 9: Writer.AddSourceLocation(E->getOperatorLoc(), Record);
393 9: Code = pch::EXPR_UNARY_OPERATOR;
394 9: }
395 :
396 3: void PCHStmtWriter::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
397 3: VisitExpr(E);
398 3: Record.push_back(E->isSizeOf());
2: branch 1 taken
1: branch 2 taken
399 3: if (E->isArgumentType())
400 2: Writer.AddTypeSourceInfo(E->getArgumentTypeInfo(), Record);
401 : else {
402 1: Record.push_back(0);
403 1: Writer.WriteSubStmt(E->getArgumentExpr());
404 : }
405 3: Writer.AddSourceLocation(E->getOperatorLoc(), Record);
406 3: Writer.AddSourceLocation(E->getRParenLoc(), Record);
407 3: Code = pch::EXPR_SIZEOF_ALIGN_OF;
408 3: }
409 :
410 1: void PCHStmtWriter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
411 1: VisitExpr(E);
412 1: Writer.WriteSubStmt(E->getLHS());
413 1: Writer.WriteSubStmt(E->getRHS());
414 1: Writer.AddSourceLocation(E->getRBracketLoc(), Record);
415 1: Code = pch::EXPR_ARRAY_SUBSCRIPT;
416 1: }
417 :
418 13: void PCHStmtWriter::VisitCallExpr(CallExpr *E) {
419 13: VisitExpr(E);
420 13: Record.push_back(E->getNumArgs());
421 13: Writer.AddSourceLocation(E->getRParenLoc(), Record);
422 13: Writer.WriteSubStmt(E->getCallee());
28: branch 4 taken
13: branch 5 taken
423 41: for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
424 : Arg != ArgEnd; ++Arg)
425 28: Writer.WriteSubStmt(*Arg);
426 13: Code = pch::EXPR_CALL;
427 13: }
428 :
429 1: void PCHStmtWriter::VisitMemberExpr(MemberExpr *E) {
430 1: VisitExpr(E);
431 1: Writer.WriteSubStmt(E->getBase());
432 1: Writer.AddDeclRef(E->getMemberDecl(), Record);
433 1: Writer.AddSourceLocation(E->getMemberLoc(), Record);
434 1: Record.push_back(E->isArrow());
435 : // FIXME: C++ nested-name-specifier
436 : // FIXME: C++ template argument list
437 1: Code = pch::EXPR_MEMBER;
438 1: }
439 :
440 0: void PCHStmtWriter::VisitObjCIsaExpr(ObjCIsaExpr *E) {
441 0: VisitExpr(E);
442 0: Writer.WriteSubStmt(E->getBase());
443 0: Writer.AddSourceLocation(E->getIsaMemberLoc(), Record);
444 0: Record.push_back(E->isArrow());
445 0: Code = pch::EXPR_OBJC_ISA;
446 0: }
447 :
448 65: void PCHStmtWriter::VisitCastExpr(CastExpr *E) {
449 65: VisitExpr(E);
450 65: Writer.WriteSubStmt(E->getSubExpr());
451 65: Record.push_back(E->getCastKind()); // FIXME: stable encoding
452 65: }
453 :
454 39: void PCHStmtWriter::VisitBinaryOperator(BinaryOperator *E) {
455 39: VisitExpr(E);
456 39: Writer.WriteSubStmt(E->getLHS());
457 39: Writer.WriteSubStmt(E->getRHS());
458 39: Record.push_back(E->getOpcode()); // FIXME: stable encoding
459 39: Writer.AddSourceLocation(E->getOperatorLoc(), Record);
460 39: Code = pch::EXPR_BINARY_OPERATOR;
461 39: }
462 :
463 2: void PCHStmtWriter::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
464 2: VisitBinaryOperator(E);
465 2: Writer.AddTypeRef(E->getComputationLHSType(), Record);
466 2: Writer.AddTypeRef(E->getComputationResultType(), Record);
467 2: Code = pch::EXPR_COMPOUND_ASSIGN_OPERATOR;
468 2: }
469 :
470 2: void PCHStmtWriter::VisitConditionalOperator(ConditionalOperator *E) {
471 2: VisitExpr(E);
472 2: Writer.WriteSubStmt(E->getCond());
473 2: Writer.WriteSubStmt(E->getLHS());
474 2: Writer.WriteSubStmt(E->getRHS());
475 2: Writer.AddSourceLocation(E->getQuestionLoc(), Record);
476 2: Writer.AddSourceLocation(E->getColonLoc(), Record);
477 2: Code = pch::EXPR_CONDITIONAL_OPERATOR;
478 2: }
479 :
480 54: void PCHStmtWriter::VisitImplicitCastExpr(ImplicitCastExpr *E) {
481 54: VisitCastExpr(E);
482 54: Record.push_back(E->isLvalueCast());
483 54: Code = pch::EXPR_IMPLICIT_CAST;
484 54: }
485 :
486 11: void PCHStmtWriter::VisitExplicitCastExpr(ExplicitCastExpr *E) {
487 11: VisitCastExpr(E);
488 11: Writer.AddTypeSourceInfo(E->getTypeInfoAsWritten(), Record);
489 11: }
490 :
491 6: void PCHStmtWriter::VisitCStyleCastExpr(CStyleCastExpr *E) {
492 6: VisitExplicitCastExpr(E);
493 6: Writer.AddSourceLocation(E->getLParenLoc(), Record);
494 6: Writer.AddSourceLocation(E->getRParenLoc(), Record);
495 6: Code = pch::EXPR_CSTYLE_CAST;
496 6: }
497 :
498 1: void PCHStmtWriter::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
499 1: VisitExpr(E);
500 1: Writer.AddSourceLocation(E->getLParenLoc(), Record);
501 1: Writer.AddTypeSourceInfo(E->getTypeSourceInfo(), Record);
502 1: Writer.WriteSubStmt(E->getInitializer());
503 1: Record.push_back(E->isFileScope());
504 1: Code = pch::EXPR_COMPOUND_LITERAL;
505 1: }
506 :
507 1: void PCHStmtWriter::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
508 1: VisitExpr(E);
509 1: Writer.WriteSubStmt(E->getBase());
510 1: Writer.AddIdentifierRef(&E->getAccessor(), Record);
511 1: Writer.AddSourceLocation(E->getAccessorLoc(), Record);
512 1: Code = pch::EXPR_EXT_VECTOR_ELEMENT;
513 1: }
514 :
515 10: void PCHStmtWriter::VisitInitListExpr(InitListExpr *E) {
516 10: VisitExpr(E);
517 10: Record.push_back(E->getNumInits());
16: branch 1 taken
10: branch 2 taken
518 26: for (unsigned I = 0, N = E->getNumInits(); I != N; ++I)
519 16: Writer.WriteSubStmt(E->getInit(I));
520 10: Writer.WriteSubStmt(E->getSyntacticForm());
521 10: Writer.AddSourceLocation(E->getLBraceLoc(), Record);
522 10: Writer.AddSourceLocation(E->getRBraceLoc(), Record);
523 10: Writer.AddDeclRef(E->getInitializedFieldInUnion(), Record);
524 10: Record.push_back(E->hadArrayRangeDesignator());
525 10: Code = pch::EXPR_INIT_LIST;
526 10: }
527 :
528 3: void PCHStmtWriter::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
529 3: VisitExpr(E);
530 3: Record.push_back(E->getNumSubExprs());
5: branch 1 taken
3: branch 2 taken
531 8: for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
532 5: Writer.WriteSubStmt(E->getSubExpr(I));
533 3: Writer.AddSourceLocation(E->getEqualOrColonLoc(), Record);
534 3: Record.push_back(E->usesGNUSyntax());
5: branch 1 taken
3: branch 2 taken
535 11: for (DesignatedInitExpr::designators_iterator D = E->designators_begin(),
536 3: DEnd = E->designators_end();
537 : D != DEnd; ++D) {
3: branch 1 taken
2: branch 2 taken
538 5: if (D->isFieldDesignator()) {
3: branch 1 taken
0: branch 2 not taken
539 3: if (FieldDecl *Field = D->getField()) {
540 3: Record.push_back(pch::DESIG_FIELD_DECL);
541 3: Writer.AddDeclRef(Field, Record);
542 : } else {
543 0: Record.push_back(pch::DESIG_FIELD_NAME);
544 0: Writer.AddIdentifierRef(D->getFieldName(), Record);
545 : }
546 3: Writer.AddSourceLocation(D->getDotLoc(), Record);
547 3: Writer.AddSourceLocation(D->getFieldLoc(), Record);
2: branch 1 taken
0: branch 2 not taken
548 2: } else if (D->isArrayDesignator()) {
549 2: Record.push_back(pch::DESIG_ARRAY);
550 2: Record.push_back(D->getFirstExprIndex());
551 2: Writer.AddSourceLocation(D->getLBracketLoc(), Record);
552 2: Writer.AddSourceLocation(D->getRBracketLoc(), Record);
553 : } else {
0: branch 1 not taken
0: branch 2 not taken
554 0: assert(D->isArrayRangeDesignator() && "Unknown designator");
555 0: Record.push_back(pch::DESIG_ARRAY_RANGE);
556 0: Record.push_back(D->getFirstExprIndex());
557 0: Writer.AddSourceLocation(D->getLBracketLoc(), Record);
558 0: Writer.AddSourceLocation(D->getEllipsisLoc(), Record);
559 0: Writer.AddSourceLocation(D->getRBracketLoc(), Record);
560 : }
561 : }
562 3: Code = pch::EXPR_DESIGNATED_INIT;
563 3: }
564 :
565 2: void PCHStmtWriter::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
566 2: VisitExpr(E);
567 2: Code = pch::EXPR_IMPLICIT_VALUE_INIT;
568 2: }
569 :
570 1: void PCHStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
571 1: VisitExpr(E);
572 1: Writer.WriteSubStmt(E->getSubExpr());
573 1: Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
574 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
575 1: Code = pch::EXPR_VA_ARG;
576 1: }
577 :
578 2: void PCHStmtWriter::VisitAddrLabelExpr(AddrLabelExpr *E) {
579 2: VisitExpr(E);
580 2: Writer.AddSourceLocation(E->getAmpAmpLoc(), Record);
581 2: Writer.AddSourceLocation(E->getLabelLoc(), Record);
582 2: Record.push_back(Writer.GetLabelID(E->getLabel()));
583 2: Code = pch::EXPR_ADDR_LABEL;
584 2: }
585 :
586 1: void PCHStmtWriter::VisitStmtExpr(StmtExpr *E) {
587 1: VisitExpr(E);
588 1: Writer.WriteSubStmt(E->getSubStmt());
589 1: Writer.AddSourceLocation(E->getLParenLoc(), Record);
590 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
591 1: Code = pch::EXPR_STMT;
592 1: }
593 :
594 1: void PCHStmtWriter::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
595 1: VisitExpr(E);
596 1: Writer.AddTypeRef(E->getArgType1(), Record);
597 1: Writer.AddTypeRef(E->getArgType2(), Record);
598 1: Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
599 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
600 1: Code = pch::EXPR_TYPES_COMPATIBLE;
601 1: }
602 :
603 1: void PCHStmtWriter::VisitChooseExpr(ChooseExpr *E) {
604 1: VisitExpr(E);
605 1: Writer.WriteSubStmt(E->getCond());
606 1: Writer.WriteSubStmt(E->getLHS());
607 1: Writer.WriteSubStmt(E->getRHS());
608 1: Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
609 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
610 1: Code = pch::EXPR_CHOOSE;
611 1: }
612 :
613 0: void PCHStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
614 0: VisitExpr(E);
615 0: Writer.AddSourceLocation(E->getTokenLocation(), Record);
616 0: Code = pch::EXPR_GNU_NULL;
617 0: }
618 :
619 1: void PCHStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
620 1: VisitExpr(E);
621 1: Record.push_back(E->getNumSubExprs());
4: branch 1 taken
1: branch 2 taken
622 5: for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
623 4: Writer.WriteSubStmt(E->getExpr(I));
624 1: Writer.AddSourceLocation(E->getBuiltinLoc(), Record);
625 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
626 1: Code = pch::EXPR_SHUFFLE_VECTOR;
627 1: }
628 :
629 2: void PCHStmtWriter::VisitBlockExpr(BlockExpr *E) {
630 2: VisitExpr(E);
631 2: Writer.AddDeclRef(E->getBlockDecl(), Record);
632 2: Record.push_back(E->hasBlockDeclRefExprs());
633 2: Code = pch::EXPR_BLOCK;
634 2: }
635 :
636 1: void PCHStmtWriter::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
637 1: VisitExpr(E);
638 1: Writer.AddDeclRef(E->getDecl(), Record);
639 1: Writer.AddSourceLocation(E->getLocation(), Record);
640 1: Record.push_back(E->isByRef());
641 1: Record.push_back(E->isConstQualAdded());
642 1: Code = pch::EXPR_BLOCK_DECL_REF;
643 1: }
644 :
645 : //===----------------------------------------------------------------------===//
646 : // Objective-C Expressions and Statements.
647 : //===----------------------------------------------------------------------===//
648 :
649 1: void PCHStmtWriter::VisitObjCStringLiteral(ObjCStringLiteral *E) {
650 1: VisitExpr(E);
651 1: Writer.WriteSubStmt(E->getString());
652 1: Writer.AddSourceLocation(E->getAtLoc(), Record);
653 1: Code = pch::EXPR_OBJC_STRING_LITERAL;
654 1: }
655 :
656 1: void PCHStmtWriter::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
657 1: VisitExpr(E);
658 1: Writer.AddTypeRef(E->getEncodedType(), Record);
659 1: Writer.AddSourceLocation(E->getAtLoc(), Record);
660 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
661 1: Code = pch::EXPR_OBJC_ENCODE;
662 1: }
663 :
664 3: void PCHStmtWriter::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
665 3: VisitExpr(E);
666 3: Writer.AddSelectorRef(E->getSelector(), Record);
667 3: Writer.AddSourceLocation(E->getAtLoc(), Record);
668 3: Writer.AddSourceLocation(E->getRParenLoc(), Record);
669 3: Code = pch::EXPR_OBJC_SELECTOR_EXPR;
670 3: }
671 :
672 1: void PCHStmtWriter::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
673 1: VisitExpr(E);
674 1: Writer.AddDeclRef(E->getProtocol(), Record);
675 1: Writer.AddSourceLocation(E->getAtLoc(), Record);
676 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
677 1: Code = pch::EXPR_OBJC_PROTOCOL_EXPR;
678 1: }
679 :
680 0: void PCHStmtWriter::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
681 0: VisitExpr(E);
682 0: Writer.AddDeclRef(E->getDecl(), Record);
683 0: Writer.AddSourceLocation(E->getLocation(), Record);
684 0: Writer.WriteSubStmt(E->getBase());
685 0: Record.push_back(E->isArrow());
686 0: Record.push_back(E->isFreeIvar());
687 0: Code = pch::EXPR_OBJC_IVAR_REF_EXPR;
688 0: }
689 :
690 0: void PCHStmtWriter::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
691 0: VisitExpr(E);
692 0: Writer.AddDeclRef(E->getProperty(), Record);
693 0: Writer.AddSourceLocation(E->getLocation(), Record);
694 0: Writer.WriteSubStmt(E->getBase());
695 0: Code = pch::EXPR_OBJC_PROPERTY_REF_EXPR;
696 0: }
697 :
698 : void PCHStmtWriter::VisitObjCImplicitSetterGetterRefExpr(
699 0: ObjCImplicitSetterGetterRefExpr *E) {
700 0: VisitExpr(E);
701 0: Writer.AddDeclRef(E->getGetterMethod(), Record);
702 0: Writer.AddDeclRef(E->getSetterMethod(), Record);
703 :
704 : // NOTE: InterfaceDecl and Base are mutually exclusive.
705 0: Writer.AddDeclRef(E->getInterfaceDecl(), Record);
706 0: Writer.WriteSubStmt(E->getBase());
707 0: Writer.AddSourceLocation(E->getLocation(), Record);
708 0: Writer.AddSourceLocation(E->getClassLoc(), Record);
709 0: Code = pch::EXPR_OBJC_KVC_REF_EXPR;
710 0: }
711 :
712 10: void PCHStmtWriter::VisitObjCMessageExpr(ObjCMessageExpr *E) {
713 10: VisitExpr(E);
714 10: Record.push_back(E->getNumArgs());
715 10: Writer.AddSourceLocation(E->getLeftLoc(), Record);
716 10: Writer.AddSourceLocation(E->getRightLoc(), Record);
717 10: Writer.AddSelectorRef(E->getSelector(), Record);
718 10: Writer.AddDeclRef(E->getMethodDecl(), Record); // optional
719 10: Writer.WriteSubStmt(E->getReceiver());
720 :
2: branch 1 taken
8: branch 2 taken
721 10: if (!E->getReceiver()) {
722 2: ObjCMessageExpr::ClassInfo CI = E->getClassInfo();
723 2: Writer.AddDeclRef(CI.first, Record);
724 2: Writer.AddIdentifierRef(CI.second, Record);
725 : }
726 :
2: branch 4 taken
10: branch 5 taken
727 12: for (CallExpr::arg_iterator Arg = E->arg_begin(), ArgEnd = E->arg_end();
728 : Arg != ArgEnd; ++Arg)
729 2: Writer.WriteSubStmt(*Arg);
730 10: Code = pch::EXPR_OBJC_MESSAGE_EXPR;
731 10: }
732 :
733 0: void PCHStmtWriter::VisitObjCSuperExpr(ObjCSuperExpr *E) {
734 0: VisitExpr(E);
735 0: Writer.AddSourceLocation(E->getLoc(), Record);
736 0: Code = pch::EXPR_OBJC_SUPER_EXPR;
737 0: }
738 :
739 0: void PCHStmtWriter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
740 0: VisitStmt(S);
741 0: Writer.WriteSubStmt(S->getElement());
742 0: Writer.WriteSubStmt(S->getCollection());
743 0: Writer.WriteSubStmt(S->getBody());
744 0: Writer.AddSourceLocation(S->getForLoc(), Record);
745 0: Writer.AddSourceLocation(S->getRParenLoc(), Record);
746 0: Code = pch::STMT_OBJC_FOR_COLLECTION;
747 0: }
748 :
749 0: void PCHStmtWriter::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
750 0: Writer.WriteSubStmt(S->getCatchBody());
751 0: Writer.WriteSubStmt(S->getNextCatchStmt());
752 0: Writer.AddDeclRef(S->getCatchParamDecl(), Record);
753 0: Writer.AddSourceLocation(S->getAtCatchLoc(), Record);
754 0: Writer.AddSourceLocation(S->getRParenLoc(), Record);
755 0: Code = pch::STMT_OBJC_CATCH;
756 0: }
757 :
758 0: void PCHStmtWriter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
759 0: Writer.WriteSubStmt(S->getFinallyBody());
760 0: Writer.AddSourceLocation(S->getAtFinallyLoc(), Record);
761 0: Code = pch::STMT_OBJC_FINALLY;
762 0: }
763 :
764 0: void PCHStmtWriter::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
765 0: Writer.WriteSubStmt(S->getTryBody());
766 0: Writer.WriteSubStmt(S->getCatchStmts());
767 0: Writer.WriteSubStmt(S->getFinallyStmt());
768 0: Writer.AddSourceLocation(S->getAtTryLoc(), Record);
769 0: Code = pch::STMT_OBJC_AT_TRY;
770 0: }
771 :
772 0: void PCHStmtWriter::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
773 0: Writer.WriteSubStmt(S->getSynchExpr());
774 0: Writer.WriteSubStmt(S->getSynchBody());
775 0: Writer.AddSourceLocation(S->getAtSynchronizedLoc(), Record);
776 0: Code = pch::STMT_OBJC_AT_SYNCHRONIZED;
777 0: }
778 :
779 0: void PCHStmtWriter::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
780 0: Writer.WriteSubStmt(S->getThrowExpr());
781 0: Writer.AddSourceLocation(S->getThrowLoc(), Record);
782 0: Code = pch::STMT_OBJC_AT_THROW;
783 0: }
784 :
785 : //===----------------------------------------------------------------------===//
786 : // C++ Expressions and Statements.
787 : //===----------------------------------------------------------------------===//
788 :
789 2: void PCHStmtWriter::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
790 2: VisitCallExpr(E);
791 2: Record.push_back(E->getOperator());
792 2: Code = pch::EXPR_CXX_OPERATOR_CALL;
793 2: }
794 :
795 4: void PCHStmtWriter::VisitCXXConstructExpr(CXXConstructExpr *E) {
796 4: VisitExpr(E);
797 4: Writer.AddDeclRef(E->getConstructor(), Record);
798 4: Writer.AddSourceLocation(E->getLocation(), Record);
799 4: Record.push_back(E->isElidable());
800 4: Record.push_back(E->requiresZeroInitialization());
801 4: Record.push_back(E->getNumArgs());
1: branch 1 taken
4: branch 2 taken
802 5: for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
803 1: Writer.WriteSubStmt(E->getArg(I));
804 4: Code = pch::EXPR_CXX_CONSTRUCT;
805 4: }
806 :
807 4: void PCHStmtWriter::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
808 4: VisitExplicitCastExpr(E);
809 4: Writer.AddSourceLocation(E->getOperatorLoc(), Record);
810 4: }
811 :
812 1: void PCHStmtWriter::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
813 1: VisitCXXNamedCastExpr(E);
814 1: Code = pch::EXPR_CXX_STATIC_CAST;
815 1: }
816 :
817 1: void PCHStmtWriter::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
818 1: VisitCXXNamedCastExpr(E);
819 1: Code = pch::EXPR_CXX_DYNAMIC_CAST;
820 1: }
821 :
822 1: void PCHStmtWriter::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
823 1: VisitCXXNamedCastExpr(E);
824 1: Code = pch::EXPR_CXX_REINTERPRET_CAST;
825 1: }
826 :
827 1: void PCHStmtWriter::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
828 1: VisitCXXNamedCastExpr(E);
829 1: Code = pch::EXPR_CXX_CONST_CAST;
830 1: }
831 :
832 1: void PCHStmtWriter::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
833 1: VisitExplicitCastExpr(E);
834 1: Writer.AddSourceLocation(E->getTypeBeginLoc(), Record);
835 1: Writer.AddSourceLocation(E->getRParenLoc(), Record);
836 1: Code = pch::EXPR_CXX_FUNCTIONAL_CAST;
837 1: }
838 :
839 3: void PCHStmtWriter::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
840 3: VisitExpr(E);
841 3: Record.push_back(E->getValue());
842 3: Writer.AddSourceLocation(E->getLocation(), Record);
843 3: Code = pch::EXPR_CXX_BOOL_LITERAL;
844 3: }
845 :
846 1: void PCHStmtWriter::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
847 1: VisitExpr(E);
848 1: Writer.AddSourceLocation(E->getLocation(), Record);
849 1: Code = pch::EXPR_CXX_NULL_PTR_LITERAL;
850 1: }
851 :
852 : //===----------------------------------------------------------------------===//
853 : // PCHWriter Implementation
854 : //===----------------------------------------------------------------------===//
855 :
856 8: unsigned PCHWriter::RecordSwitchCaseID(SwitchCase *S) {
857 : assert(SwitchCaseIDs.find(S) == SwitchCaseIDs.end() &&
8: branch 3 taken
0: branch 4 not taken
858 8: "SwitchCase recorded twice");
859 8: unsigned NextID = SwitchCaseIDs.size();
860 8: SwitchCaseIDs[S] = NextID;
861 8: return NextID;
862 : }
863 :
864 8: unsigned PCHWriter::getSwitchCaseID(SwitchCase *S) {
865 : assert(SwitchCaseIDs.find(S) != SwitchCaseIDs.end() &&
8: branch 3 taken
0: branch 4 not taken
866 8: "SwitchCase hasn't been seen yet");
867 8: return SwitchCaseIDs[S];
868 : }
869 :
870 : /// \brief Retrieve the ID for the given label statement, which may
871 : /// or may not have been emitted yet.
872 8: unsigned PCHWriter::GetLabelID(LabelStmt *S) {
873 8: std::map<LabelStmt *, unsigned>::iterator Pos = LabelIDs.find(S);
4: branch 2 taken
4: branch 3 taken
874 8: if (Pos != LabelIDs.end())
875 4: return Pos->second;
876 :
877 4: unsigned NextID = LabelIDs.size();
878 4: LabelIDs[S] = NextID;
879 4: return NextID;
880 : }
881 :
882 : /// \brief Write the given substatement or subexpression to the
883 : /// bitstream.
884 499: void PCHWriter::WriteSubStmt(Stmt *S) {
885 499: RecordData Record;
886 499: PCHStmtWriter Writer(*this, Record);
887 499: ++NumStatements;
888 :
20: branch 0 taken
479: branch 1 taken
889 499: if (!S) {
890 20: Stream.EmitRecord(pch::STMT_NULL_PTR, Record);
891 20: return;
892 : }
893 :
894 479: Writer.Code = pch::STMT_NULL_PTR;
895 479: Writer.Visit(S);
896 : assert(Writer.Code != pch::STMT_NULL_PTR &&
0: branch 0 not taken
479: branch 1 taken
897 479: "Unhandled expression writing PCH file");
479: branch 2 taken
20: branch 3 taken
898 479: Stream.EmitRecord(Writer.Code, Record);
899 : }
900 :
901 : /// \brief Flush all of the statements that have been added to the
902 : /// queue via AddStmt().
903 975: void PCHWriter::FlushStmts() {
904 975: RecordData Record;
905 975: PCHStmtWriter Writer(*this, Record);
906 :
116: branch 1 taken
975: branch 2 taken
907 1091: for (unsigned I = 0, N = StmtsToEmit.size(); I != N; ++I) {
908 116: ++NumStatements;
909 116: Stmt *S = StmtsToEmit[I];
910 :
0: branch 0 not taken
116: branch 1 taken
911 116: if (!S) {
912 0: Stream.EmitRecord(pch::STMT_NULL_PTR, Record);
913 0: continue;
914 : }
915 :
916 116: Writer.Code = pch::STMT_NULL_PTR;
917 116: Writer.Visit(S);
918 : assert(Writer.Code != pch::STMT_NULL_PTR &&
0: branch 0 not taken
116: branch 1 taken
919 116: "Unhandled expression writing PCH file");
920 116: Stream.EmitRecord(Writer.Code, Record);
921 :
922 : assert(N == StmtsToEmit.size() &&
116: branch 1 taken
0: branch 2 not taken
923 116: "Substatement writen via AddStmt rather than WriteSubStmt!");
924 :
925 : // Note that we are at the end of a full expression. Any
926 : // expression records that follow this one are part of a different
927 : // expression.
928 116: Record.clear();
929 116: Stream.EmitRecord(pch::STMT_STOP, Record);
930 : }
931 :
932 975: StmtsToEmit.clear();
933 975: }
Generated: 2010-02-10 01:31 by zcov