maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Frontend/PCHReaderStmt.cpp

1609 lines
54 KiB
C++
Raw Normal View History

split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
//===--- PCHReaderStmt.cpp - Stmt/Expr Deserialization ----------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// Statement/expression deserialization. This implements the
// PCHReader::ReadStmt method.
//
//===----------------------------------------------------------------------===//
#include "clang/Frontend/PCHReader.h"
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
#include "clang/AST/DeclCXX.h"
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
#include "clang/AST/StmtVisitor.h"
using namespace clang;
namespace {
Fix PCH emitting/reading for template arguments that contain expressions. llvm-svn: 106996
2010-06-28 17:31:42 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
class PCHStmtReader : public StmtVisitor<PCHStmtReader> {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
PCHReader &Reader;
const PCHReader::RecordData &Record;
unsigned &Idx;
public:
PCHStmtReader(PCHReader &Reader, const PCHReader::RecordData &Record,
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
unsigned &Idx)
: Reader(Reader), Record(Record), Idx(Idx) { }
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
/// \brief The number of record fields required for the Stmt class
/// itself.
static const unsigned NumStmtFields = 0;
/// \brief The number of record fields required for the Expr class
/// itself.
static const unsigned NumExprFields = NumStmtFields + 3;
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 17:31:48 +08:00
/// \brief Read and initialize a ExplicitTemplateArgumentList structure.
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
unsigned NumTemplateArgs);
void VisitStmt(Stmt *S);
void VisitNullStmt(NullStmt *S);
void VisitCompoundStmt(CompoundStmt *S);
void VisitSwitchCase(SwitchCase *S);
void VisitCaseStmt(CaseStmt *S);
void VisitDefaultStmt(DefaultStmt *S);
void VisitLabelStmt(LabelStmt *S);
void VisitIfStmt(IfStmt *S);
void VisitSwitchStmt(SwitchStmt *S);
void VisitWhileStmt(WhileStmt *S);
void VisitDoStmt(DoStmt *S);
void VisitForStmt(ForStmt *S);
void VisitGotoStmt(GotoStmt *S);
void VisitIndirectGotoStmt(IndirectGotoStmt *S);
void VisitContinueStmt(ContinueStmt *S);
void VisitBreakStmt(BreakStmt *S);
void VisitReturnStmt(ReturnStmt *S);
void VisitDeclStmt(DeclStmt *S);
void VisitAsmStmt(AsmStmt *S);
void VisitExpr(Expr *E);
void VisitPredefinedExpr(PredefinedExpr *E);
void VisitDeclRefExpr(DeclRefExpr *E);
void VisitIntegerLiteral(IntegerLiteral *E);
void VisitFloatingLiteral(FloatingLiteral *E);
void VisitImaginaryLiteral(ImaginaryLiteral *E);
void VisitStringLiteral(StringLiteral *E);
void VisitCharacterLiteral(CharacterLiteral *E);
void VisitParenExpr(ParenExpr *E);
void VisitUnaryOperator(UnaryOperator *E);
void VisitOffsetOfExpr(OffsetOfExpr *E);
void VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E);
void VisitArraySubscriptExpr(ArraySubscriptExpr *E);
void VisitCallExpr(CallExpr *E);
void VisitMemberExpr(MemberExpr *E);
void VisitCastExpr(CastExpr *E);
void VisitBinaryOperator(BinaryOperator *E);
void VisitCompoundAssignOperator(CompoundAssignOperator *E);
void VisitConditionalOperator(ConditionalOperator *E);
void VisitImplicitCastExpr(ImplicitCastExpr *E);
void VisitExplicitCastExpr(ExplicitCastExpr *E);
void VisitCStyleCastExpr(CStyleCastExpr *E);
void VisitCompoundLiteralExpr(CompoundLiteralExpr *E);
void VisitExtVectorElementExpr(ExtVectorElementExpr *E);
void VisitInitListExpr(InitListExpr *E);
void VisitDesignatedInitExpr(DesignatedInitExpr *E);
void VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
void VisitVAArgExpr(VAArgExpr *E);
void VisitAddrLabelExpr(AddrLabelExpr *E);
void VisitStmtExpr(StmtExpr *E);
void VisitTypesCompatibleExpr(TypesCompatibleExpr *E);
void VisitChooseExpr(ChooseExpr *E);
void VisitGNUNullExpr(GNUNullExpr *E);
void VisitShuffleVectorExpr(ShuffleVectorExpr *E);
void VisitBlockExpr(BlockExpr *E);
void VisitBlockDeclRefExpr(BlockDeclRefExpr *E);
void VisitObjCStringLiteral(ObjCStringLiteral *E);
void VisitObjCEncodeExpr(ObjCEncodeExpr *E);
void VisitObjCSelectorExpr(ObjCSelectorExpr *E);
void VisitObjCProtocolExpr(ObjCProtocolExpr *E);
void VisitObjCIvarRefExpr(ObjCIvarRefExpr *E);
void VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E);
void VisitObjCImplicitSetterGetterRefExpr(
Using "ObjCImplicitSetterGetterRefExpr" instead of "ObjCImplctSetterGetterRefExpr". A field rename and more comments. llvm-svn: 79537
2009-08-21 01:02:02 +08:00
ObjCImplicitSetterGetterRefExpr *E);
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void VisitObjCMessageExpr(ObjCMessageExpr *E);
void VisitObjCSuperExpr(ObjCSuperExpr *E);
void VisitObjCIsaExpr(ObjCIsaExpr *E);
void VisitObjCForCollectionStmt(ObjCForCollectionStmt *);
void VisitObjCAtCatchStmt(ObjCAtCatchStmt *);
void VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *);
void VisitObjCAtTryStmt(ObjCAtTryStmt *);
void VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *);
void VisitObjCAtThrowStmt(ObjCAtThrowStmt *);
void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E);
void VisitCXXConstructExpr(CXXConstructExpr *E);
void VisitCXXNamedCastExpr(CXXNamedCastExpr *E);
void VisitCXXStaticCastExpr(CXXStaticCastExpr *E);
void VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E);
void VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E);
void VisitCXXConstCastExpr(CXXConstCastExpr *E);
void VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E);
void VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E);
void VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
void VisitCXXTypeidExpr(CXXTypeidExpr *E);
void VisitCXXThisExpr(CXXThisExpr *E);
void VisitCXXThrowExpr(CXXThrowExpr *E);
void VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E);
void VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E);
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E);
void VisitCXXNewExpr(CXXNewExpr *E);
void VisitCXXDeleteExpr(CXXDeleteExpr *E);
void VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E);
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E);
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E);
void VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E);
void VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E);
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void VisitOverloadExpr(OverloadExpr *E);
void VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E);
void VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
};
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 17:31:48 +08:00
ReadExplicitTemplateArgumentList(ExplicitTemplateArgumentList &ArgList,
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
unsigned NumTemplateArgs) {
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 17:31:48 +08:00
TemplateArgumentListInfo ArgInfo;
ArgInfo.setLAngleLoc(Reader.ReadSourceLocation(Record, Idx));
ArgInfo.setRAngleLoc(Reader.ReadSourceLocation(Record, Idx));
for (unsigned i = 0; i != NumTemplateArgs; ++i)
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
ArgInfo.addArgument(Reader.ReadTemplateArgumentLoc(Record, Idx));
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 17:31:48 +08:00
ArgList.initializeFrom(ArgInfo);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitStmt(Stmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
assert(Idx == NumStmtFields && "Incorrect statement field count");
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitNullStmt(NullStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
S->setSemiLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCompoundStmt(CompoundStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
llvm::SmallVector<Stmt *, 16> Stmts;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
unsigned NumStmts = Record[Idx++];
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
while (NumStmts--)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
Stmts.push_back(Reader.ReadSubStmt());
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
S->setStmts(*Reader.getContext(), Stmts.data(), Stmts.size());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setLBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setRBracLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitSwitchCase(SwitchCase *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Reader.RecordSwitchCaseID(S, Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCaseStmt(CaseStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitSwitchCase(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setLHS(Reader.ReadSubExpr());
S->setRHS(Reader.ReadSubExpr());
S->setSubStmt(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setCaseLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Template instantiation for switch statements llvm-svn: 71916
2009-05-16 07:57:33 +08:00
S->setEllipsisLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitDefaultStmt(DefaultStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitSwitchCase(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setSubStmt(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setDefaultLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Template instantiation for switch statements llvm-svn: 71916
2009-05-16 07:57:33 +08:00
S->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitLabelStmt(LabelStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
S->setID(Reader.GetIdentifierInfo(Record, Idx));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setSubStmt(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setIdentLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Reader.RecordLabelStmt(S, Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitIfStmt(IfStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Alter the internal representation of the condition variable in if/while/switch/for statements to ensure that walking the children of these statements actually works. Previously, we stored the condition variable as a VarDecl. However, StmtIterator isn't able to walk from a VarDecl to a set of statements, and would (in some circumstances) walk beyond the end of the list of statements, cause Bad Behavior. In this change, we've gone back to representing the condition variables as DeclStmts. While not as memory-efficient as VarDecls, it greatly simplifies iteration over the children. Fixes the remainder of <rdar://problem/8104754>. llvm-svn: 106504
2010-06-22 07:44:13 +08:00
S->setConditionVariable(*Reader.getContext(),
cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setCond(Reader.ReadSubExpr());
S->setThen(Reader.ReadSubStmt());
S->setElse(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setIfLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Template instantiation for "if" statements. Also: - Skip semantic analysis of the "if" condition if it is type-dependent. - Added the location of the "else" keyword into IfStmt, so that we can provide it for type-checking after template instantiation. llvm-svn: 71875
2009-05-16 02:53:42 +08:00
S->setElseLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitSwitchStmt(SwitchStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Alter the internal representation of the condition variable in if/while/switch/for statements to ensure that walking the children of these statements actually works. Previously, we stored the condition variable as a VarDecl. However, StmtIterator isn't able to walk from a VarDecl to a set of statements, and would (in some circumstances) walk beyond the end of the list of statements, cause Bad Behavior. In this change, we've gone back to representing the condition variables as DeclStmts. While not as memory-efficient as VarDecls, it greatly simplifies iteration over the children. Fixes the remainder of <rdar://problem/8104754>. llvm-svn: 106504
2010-06-22 07:44:13 +08:00
S->setConditionVariable(*Reader.getContext(),
cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setCond(Reader.ReadSubExpr());
S->setBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setSwitchLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
SwitchCase *PrevSC = 0;
for (unsigned N = Record.size(); Idx != N; ++Idx) {
SwitchCase *SC = Reader.getSwitchCaseWithID(Record[Idx]);
if (PrevSC)
PrevSC->setNextSwitchCase(SC);
else
S->setSwitchCaseList(SC);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce reference counting for statements and expressions, using it to allow sharing of nodes. Simplifies some aspects of template instantiation, and fixes both PR3444 and <rdar://problem/6757457>. llvm-svn: 78450
2009-08-08 09:41:12 +08:00
// Retain this SwitchCase, since SwitchStmt::addSwitchCase() would
// normally retain it (but we aren't calling addSwitchCase).
SC->Retain();
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
PrevSC = SC;
}
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitWhileStmt(WhileStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Alter the internal representation of the condition variable in if/while/switch/for statements to ensure that walking the children of these statements actually works. Previously, we stored the condition variable as a VarDecl. However, StmtIterator isn't able to walk from a VarDecl to a set of statements, and would (in some circumstances) walk beyond the end of the list of statements, cause Bad Behavior. In this change, we've gone back to representing the condition variables as DeclStmts. While not as memory-efficient as VarDecls, it greatly simplifies iteration over the children. Fixes the remainder of <rdar://problem/8104754>. llvm-svn: 106504
2010-06-22 07:44:13 +08:00
S->setConditionVariable(*Reader.getContext(),
cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setCond(Reader.ReadSubExpr());
S->setBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitDoStmt(DoStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setCond(Reader.ReadSubExpr());
S->setBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setDoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Template instantiation for do-while statements. llvm-svn: 71899
2009-05-16 05:56:04 +08:00
S->setWhileLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
add the location of the ')' in a do/while statement to DoStmt. This fixes a source range problem reported by Olaf Krzikalla. llvm-svn: 73266
2009-06-13 07:04:47 +08:00
S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitForStmt(ForStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setInit(Reader.ReadSubStmt());
S->setCond(Reader.ReadSubExpr());
Alter the internal representation of the condition variable in if/while/switch/for statements to ensure that walking the children of these statements actually works. Previously, we stored the condition variable as a VarDecl. However, StmtIterator isn't able to walk from a VarDecl to a set of statements, and would (in some circumstances) walk beyond the end of the list of statements, cause Bad Behavior. In this change, we've gone back to representing the condition variables as DeclStmts. While not as memory-efficient as VarDecls, it greatly simplifies iteration over the children. Fixes the remainder of <rdar://problem/8104754>. llvm-svn: 106504
2010-06-22 07:44:13 +08:00
S->setConditionVariable(*Reader.getContext(),
cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setInc(Reader.ReadSubExpr());
S->setBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Template instantiation for "for" loops llvm-svn: 71901
2009-05-16 06:12:32 +08:00
S->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitGotoStmt(GotoStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Reader.SetLabelOf(S, Record[Idx++]);
S->setGotoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setLabelLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitIndirectGotoStmt(IndirectGotoStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
S->setGotoLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Template instantiation for IndirectGotoStmt. Now my life is complete. llvm-svn: 71917
2009-05-16 08:20:29 +08:00
S->setStarLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setTarget(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitContinueStmt(ContinueStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
S->setContinueLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitBreakStmt(BreakStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
S->setBreakLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitReturnStmt(ReturnStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setRetValue(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setReturnLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Implement semantic analysis and an AST representation for the named return value optimization. Sema marks return statements with their NRVO candidates (which may or may not end up using the NRVO), then, at the end of a function body, computes and marks those variables that can be allocated into the return slot. I've checked this locally with some debugging statements (not committed), but there won't be any tests until CodeGen comes along. llvm-svn: 103865
2010-05-15 14:01:05 +08:00
S->setNRVOCandidate(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitDeclStmt(DeclStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
S->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
if (Idx + 1 == Record.size()) {
// Single declaration
S->setDeclGroup(DeclGroupRef(Reader.GetDecl(Record[Idx++])));
} else {
llvm::SmallVector<Decl *, 16> Decls;
Decls.reserve(Record.size() - Idx);
for (unsigned N = Record.size(); Idx != N; ++Idx)
Decls.push_back(Reader.GetDecl(Record[Idx]));
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
S->setDeclGroup(DeclGroupRef(DeclGroup::Create(*Reader.getContext(),
Fix lots of PCH crashes caused by the new assertions in llvm::SmallVector, using data() instead of &[0]. The PCH testsuite now runs cleanly (again). llvm-svn: 72292
2009-05-23 06:45:36 +08:00
Decls.data(),
Decls.size())));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitAsmStmt(AsmStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
unsigned NumOutputs = Record[Idx++];
unsigned NumInputs = Record[Idx++];
unsigned NumClobbers = Record[Idx++];
S->setAsmLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setVolatile(Record[Idx++]);
S->setSimple(Record[Idx++]);
Remember if the AsmStmt came from Microsoft-style inline assembly code. llvm-svn: 92526
2010-01-05 06:37:17 +08:00
S->setMSAsm(Record[Idx++]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setAsmString(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
// Outputs and inputs
Use IdentifierInfo * instead of std::string for the AsmStmt names. llvm-svn: 94925
2010-01-31 06:25:16 +08:00
llvm::SmallVector<IdentifierInfo *, 16> Names;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
llvm::SmallVector<StringLiteral*, 16> Constraints;
llvm::SmallVector<Stmt*, 16> Exprs;
for (unsigned I = 0, N = NumOutputs + NumInputs; I != N; ++I) {
Use IdentifierInfo * instead of std::string for the AsmStmt names. llvm-svn: 94925
2010-01-31 06:25:16 +08:00
Names.push_back(Reader.GetIdentifierInfo(Record, Idx));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
Constraints.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
Exprs.push_back(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
// Constraints
llvm::SmallVector<StringLiteral*, 16> Clobbers;
for (unsigned I = 0; I != NumClobbers; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
Clobbers.push_back(cast_or_null<StringLiteral>(Reader.ReadSubStmt()));
Combine AsmStmt::setOutputsAndInputs and AsmStmt::setClobbers. llvm-svn: 94918
2010-01-31 03:34:25 +08:00
Even more AsmStmt cleanup. llvm-svn: 94921
2010-01-31 04:38:10 +08:00
S->setOutputsAndInputsAndClobbers(*Reader.getContext(),
Names.data(), Constraints.data(),
Combine AsmStmt::setOutputsAndInputs and AsmStmt::setClobbers. llvm-svn: 94918
2010-01-31 03:34:25 +08:00
Exprs.data(), NumOutputs, NumInputs,
Clobbers.data(), NumClobbers);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitExpr(Expr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(E);
E->setType(Reader.GetType(Record[Idx++]));
E->setTypeDependent(Record[Idx++]);
E->setValueDependent(Record[Idx++]);
assert(Idx == NumExprFields && "Incorrect expression field count");
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitPredefinedExpr(PredefinedExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setIdentType((PredefinedExpr::IdentType)Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitDeclRefExpr(DeclRefExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
DeclRefExpr stores a ValueDecl internally. Template instantiation can re-use DeclRefExprs. llvm-svn: 90848
2009-12-08 17:08:17 +08:00
E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
Eliminate QualifiedDeclRefExpr, which captured the notion of a qualified reference to a declaration that is not a non-static data member or non-static member function, e.g., namespace N { int i; } int j = N::i; Instead, extend DeclRefExpr to optionally store the qualifier. Most clients won't see or care about the difference (since QualifierDeclRefExpr inherited DeclRefExpr). However, this reduces the number of top-level expression types that clients need to cope with, brings the implementation of DeclRefExpr into line with MemberExpr, and simplifies and unifies our handling of declaration references. Extended DeclRefExpr to (optionally) store explicitly-specified template arguments. This occurs when naming a declaration via a template-id (which will be stored in a TemplateIdRefExpr) that, following template argument deduction and (possibly) overload resolution, is replaced with a DeclRefExpr that refers to a template specialization but maintains the template arguments as written. llvm-svn: 84962
2009-10-24 02:54:35 +08:00
// FIXME: read qualifier
// FIXME: read explicit template arguments
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitIntegerLiteral(IntegerLiteral *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setValue(Reader.ReadAPInt(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitFloatingLiteral(FloatingLiteral *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setValue(Reader.ReadAPFloat(Record, Idx));
E->setExact(Record[Idx++]);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitImaginaryLiteral(ImaginaryLiteral *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitStringLiteral(StringLiteral *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
unsigned Len = Record[Idx++];
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
assert(Record[Idx] == E->getNumConcatenated() &&
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
"Wrong number of concatenated tokens!");
++Idx;
E->setWide(Record[Idx++]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
// Read string data
Add StringLiteral::getString -> StringRef. llvm-svn: 82514
2009-09-22 11:27:33 +08:00
llvm::SmallString<16> Str(&Record[Idx], &Record[Idx] + Len);
E->setString(*Reader.getContext(), Str.str());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
Idx += Len;
// Read source locations
for (unsigned I = 0, N = E->getNumConcatenated(); I != N; ++I)
E->setStrTokenLoc(I, SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCharacterLiteral(CharacterLiteral *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setValue(Record[Idx++]);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setWide(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitParenExpr(ParenExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setLParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParen(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitUnaryOperator(UnaryOperator *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setOpcode((UnaryOperator::Opcode)Record[Idx++]);
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitOffsetOfExpr(OffsetOfExpr *E) {
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
typedef OffsetOfExpr::OffsetOfNode Node;
VisitExpr(E);
assert(E->getNumComponents() == Record[Idx]);
++Idx;
assert(E->getNumExpressions() == Record[Idx]);
++Idx;
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setTypeSourceInfo(Reader.GetTypeSourceInfo(Record, Idx));
for (unsigned I = 0, N = E->getNumComponents(); I != N; ++I) {
Node::Kind Kind = static_cast<Node::Kind>(Record[Idx++]);
SourceLocation Start = SourceLocation::getFromRawEncoding(Record[Idx++]);
SourceLocation End = SourceLocation::getFromRawEncoding(Record[Idx++]);
switch (Kind) {
case Node::Array:
E->setComponent(I, Node(Start, Record[Idx++], End));
break;
case Node::Field:
E->setComponent(I,
Node(Start,
dyn_cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])),
End));
break;
case Node::Identifier:
E->setComponent(I, Node(Start, Reader.GetIdentifier(Record[Idx++]), End));
break;
Teach __builtin_offsetof to compute the offsets of members of base classes, since we only warn (not error) on offsetof() for non-POD types. We store the base path within the OffsetOfExpr itself, then evaluate the offsets within the constant evaluator. llvm-svn: 102571
2010-04-29 08:18:15 +08:00
case Node::Base:
// FIXME: Implement this!
llvm_unreachable("PCH for offsetof(base-specifier) not implemented");
break;
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
}
}
for (unsigned I = 0, N = E->getNumExpressions(); I != N; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setIndexExpr(I, Reader.ReadSubExpr());
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitSizeOfAlignOfExpr(SizeOfAlignOfExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setSizeof(Record[Idx++]);
if (Record[Idx] == 0) {
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setArgument(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
++Idx;
} else {
DeclaratorInfo -> TypeSourceInfo. Makes an effort to rename associated variables, but the results are imperfect. For posterity, I did: cat <<EOF > $cmdfile s/DeclaratorInfo/TypeSourceInfo/g s/DInfo/TInfo/g s/TypeTypeSourceInfo/TypeSourceInfo/g s/SourceTypeSourceInfo/TypeSourceInfo/g EOF find lib -name '*.cpp' -not -path 'lib/Parse/*' -exec sed -i '' -f $cmdfile '{}' \; find lib -name '*.h' -exec sed -i '' -f $cmdfile '{}' \; find include -name '*.h' -not -path 'include/clang/Parse/*' -not -path 'include/clang/Basic/*' -exec sed -i '' -f $cmdfile '{}' \; llvm-svn: 90743
2009-12-07 10:54:59 +08:00
E->setArgument(Reader.GetTypeSourceInfo(Record, Idx));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setLHS(Reader.ReadSubExpr());
E->setRHS(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setRBracketLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCallExpr(CallExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
E->setNumArgs(*Reader.getContext(), Record[Idx++]);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setCallee(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setArg(I, Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitMemberExpr(MemberExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
Missed change from last commit. llvm-svn: 90550
2009-12-04 14:46:54 +08:00
E->setMemberDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setArrow(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCIsaExpr(ObjCIsaExpr *E) {
Allow front-end 'isa' access on object's of type 'id'. Enhance test case to cover 'isa' access on interface types (clang produces an error, GCC produces a warning). Still need back-end CodeGen for ObjCIsaExpr. llvm-svn: 76979
2009-07-25 01:54:45 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
Allow front-end 'isa' access on object's of type 'id'. Enhance test case to cover 'isa' access on interface types (clang produces an error, GCC produces a warning). Still need back-end CodeGen for ObjCIsaExpr. llvm-svn: 76979
2009-07-25 01:54:45 +08:00
E->setIsaMemberLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setArrow(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCastExpr(CastExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
Add a CastKind enum to CastExpr. Right now it's not used for much but it will be :) llvm-svn: 77650
2009-07-31 08:48:10 +08:00
E->setCastKind((CastExpr::CastKind)Record[Idx++]);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitBinaryOperator(BinaryOperator *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setLHS(Reader.ReadSubExpr());
E->setRHS(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setOpcode((BinaryOperator::Opcode)Record[Idx++]);
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCompoundAssignOperator(CompoundAssignOperator *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitBinaryOperator(E);
E->setComputationLHSType(Reader.GetType(Record[Idx++]));
E->setComputationResultType(Reader.GetType(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitConditionalOperator(ConditionalOperator *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setCond(Reader.ReadSubExpr());
E->setLHS(Reader.ReadSubExpr());
E->setRHS(Reader.ReadSubExpr());
Source location information for ? and : in a ConditionalOperator, from Enea Zaffanella llvm-svn: 80097
2009-08-26 22:37:04 +08:00
E->setQuestionLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitImplicitCastExpr(ImplicitCastExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitCastExpr(E);
E->setLvalueCast(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitExplicitCastExpr(ExplicitCastExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitCastExpr(E);
Preserve type source information in explicit cast expressions. Patch by Enea Zaffanella. llvm-svn: 93522
2010-01-16 02:39:57 +08:00
E->setTypeInfoAsWritten(Reader.GetTypeSourceInfo(Record, Idx));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCStyleCastExpr(CStyleCastExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExplicitCastExpr(E);
E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Preserve type source information in compound literal expressions. Patch by Enea Zaffanella! llvm-svn: 93752
2010-01-19 03:35:47 +08:00
E->setTypeSourceInfo(Reader.GetTypeSourceInfo(Record, Idx));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setInitializer(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setFileScope(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitExtVectorElementExpr(ExtVectorElementExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setAccessor(Reader.GetIdentifierInfo(Record, Idx));
E->setAccessorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitInitListExpr(InitListExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
unsigned NumInits = Record[Idx++];
Use ASTVector instead of std::vector for the Exprs in InitListExpr. Performance measurements of '-fsyntax-only' on combine.c (403.gcc) shows no real performance change, but now the vector isn't leaked. llvm-svn: 101195
2010-04-14 07:39:13 +08:00
E->reserveInits(*Reader.getContext(), NumInits);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
for (unsigned I = 0; I != NumInits; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->updateInit(*Reader.getContext(), I, Reader.ReadSubExpr());
E->setSyntacticForm(cast_or_null<InitListExpr>(Reader.ReadSubStmt()));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setLBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRBraceLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setInitializedFieldInUnion(
cast_or_null<FieldDecl>(Reader.GetDecl(Record[Idx++])));
E->sawArrayRangeDesignator(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitDesignatedInitExpr(DesignatedInitExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
typedef DesignatedInitExpr::Designator Designator;
VisitExpr(E);
unsigned NumSubExprs = Record[Idx++];
assert(NumSubExprs == E->getNumSubExprs() && "Wrong number of subexprs");
for (unsigned I = 0; I != NumSubExprs; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(I, Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setEqualOrColonLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setGNUSyntax(Record[Idx++]);
llvm::SmallVector<Designator, 4> Designators;
while (Idx < Record.size()) {
switch ((pch::DesignatorTypes)Record[Idx++]) {
case pch::DESIG_FIELD_DECL: {
FieldDecl *Field = cast<FieldDecl>(Reader.GetDecl(Record[Idx++]));
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SourceLocation DotLoc
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
= SourceLocation::getFromRawEncoding(Record[Idx++]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SourceLocation FieldLoc
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
= SourceLocation::getFromRawEncoding(Record[Idx++]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Designators.push_back(Designator(Field->getIdentifier(), DotLoc,
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
FieldLoc));
Designators.back().setField(Field);
break;
}
case pch::DESIG_FIELD_NAME: {
const IdentifierInfo *Name = Reader.GetIdentifierInfo(Record, Idx);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SourceLocation DotLoc
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
= SourceLocation::getFromRawEncoding(Record[Idx++]);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
SourceLocation FieldLoc
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
= SourceLocation::getFromRawEncoding(Record[Idx++]);
Designators.push_back(Designator(Name, DotLoc, FieldLoc));
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::DESIG_ARRAY: {
unsigned Index = Record[Idx++];
SourceLocation LBracketLoc
= SourceLocation::getFromRawEncoding(Record[Idx++]);
SourceLocation RBracketLoc
= SourceLocation::getFromRawEncoding(Record[Idx++]);
Designators.push_back(Designator(Index, LBracketLoc, RBracketLoc));
break;
}
case pch::DESIG_ARRAY_RANGE: {
unsigned Index = Record[Idx++];
SourceLocation LBracketLoc
= SourceLocation::getFromRawEncoding(Record[Idx++]);
SourceLocation EllipsisLoc
= SourceLocation::getFromRawEncoding(Record[Idx++]);
SourceLocation RBracketLoc
= SourceLocation::getFromRawEncoding(Record[Idx++]);
Designators.push_back(Designator(Index, LBracketLoc, EllipsisLoc,
RBracketLoc));
break;
}
}
}
Move the allocation of designators in DesignatedInitExpr to the ASTContext. Fixes <rdar://problem/7495428>. llvm-svn: 92867
2010-01-07 07:17:19 +08:00
E->setDesignators(*Reader.getContext(),
Designators.data(), Designators.size());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitVAArgExpr(VAArgExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitAddrLabelExpr(AddrLabelExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setAmpAmpLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setLabelLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
Reader.SetLabelOf(E, Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitStmtExpr(StmtExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setLParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubStmt(cast_or_null<CompoundStmt>(Reader.ReadSubStmt()));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitTypesCompatibleExpr(TypesCompatibleExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setArgType1(Reader.GetType(Record[Idx++]));
E->setArgType2(Reader.GetType(Record[Idx++]));
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitChooseExpr(ChooseExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setCond(Reader.ReadSubExpr());
E->setLHS(Reader.ReadSubExpr());
E->setRHS(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setTokenLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
llvm::SmallVector<Expr *, 16> Exprs;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
unsigned NumExprs = Record[Idx++];
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
while (NumExprs--)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
Exprs.push_back(Reader.ReadSubExpr());
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
E->setExprs(*Reader.getContext(), Exprs.data(), Exprs.size());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setBuiltinLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitBlockExpr(BlockExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setBlockDecl(cast_or_null<BlockDecl>(Reader.GetDecl(Record[Idx++])));
E->setHasBlockDeclRefExprs(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitBlockDeclRefExpr(BlockDeclRefExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setDecl(cast<ValueDecl>(Reader.GetDecl(Record[Idx++])));
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setByRef(Record[Idx++]);
Added writing and reading of the ConstQualAdded flag of BlockDeclRefExpr to PCH. llvm-svn: 73800
2009-06-20 08:02:26 +08:00
E->setConstQualAdded(Record[Idx++]);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setCopyConstructorExpr(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
//===----------------------------------------------------------------------===//
// Objective-C Expressions and Statements
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCStringLiteral(ObjCStringLiteral *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setString(cast<StringLiteral>(Reader.ReadSubStmt()));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
Keep proper source location information for the type in an Objective-C @encode expression. llvm-svn: 101907
2010-04-20 23:39:42 +08:00
E->setEncodedTypeSourceInfo(Reader.GetTypeSourceInfo(Record, Idx));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCSelectorExpr(ObjCSelectorExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setSelector(Reader.GetSelector(Record, Idx));
E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCProtocolExpr(ObjCProtocolExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setProtocol(cast<ObjCProtocolDecl>(Reader.GetDecl(Record[Idx++])));
E->setAtLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setDecl(cast<ObjCIvarDecl>(Reader.GetDecl(Record[Idx++])));
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setIsArrow(Record[Idx++]);
E->setIsFreeIvar(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setProperty(cast<ObjCPropertyDecl>(Reader.GetDecl(Record[Idx++])));
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCImplicitSetterGetterRefExpr(
Using "ObjCImplicitSetterGetterRefExpr" instead of "ObjCImplctSetterGetterRefExpr". A field rename and more comments. llvm-svn: 79537
2009-08-21 01:02:02 +08:00
ObjCImplicitSetterGetterRefExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setGetterMethod(
cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
E->setSetterMethod(
cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
Renamed ClassProp data member of ObjCImplctSetterGetterRefExpr to InterfaceDecl, as it is unrelated to any property and holds the InterfaceDecl needed for accessing class getter/setter methods using the dot-syntax. llvm-svn: 79371
2009-08-19 05:37:33 +08:00
E->setInterfaceDecl(
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
cast_or_null<ObjCInterfaceDecl>(Reader.GetDecl(Record[Idx++])));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setClassLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCMessageExpr(ObjCMessageExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
assert(Record[Idx] == E->getNumArgs());
++Idx;
ObjCMessageExpr::ReceiverKind Kind
= static_cast<ObjCMessageExpr::ReceiverKind>(Record[Idx++]);
switch (Kind) {
case ObjCMessageExpr::Instance:
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setInstanceReceiver(Reader.ReadSubExpr());
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
break;
case ObjCMessageExpr::Class:
E->setClassReceiver(Reader.GetTypeSourceInfo(Record, Idx));
break;
case ObjCMessageExpr::SuperClass:
case ObjCMessageExpr::SuperInstance: {
QualType T = Reader.GetType(Record[Idx++]);
SourceLocation SuperLoc = SourceLocation::getFromRawEncoding(Record[Idx++]);
E->setSuper(SuperLoc, T, Kind == ObjCMessageExpr::SuperInstance);
break;
}
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
assert(Kind == E->getReceiverKind());
if (Record[Idx++])
E->setMethodDecl(cast_or_null<ObjCMethodDecl>(Reader.GetDecl(Record[Idx++])));
else
E->setSelector(Reader.GetSelector(Record, Idx));
E->setLeftLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRightLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setArg(I, Reader.ReadSubExpr());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCSuperExpr(ObjCSuperExpr *E) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitExpr(E);
E->setLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCForCollectionStmt(ObjCForCollectionStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setElement(Reader.ReadSubStmt());
S->setCollection(Reader.ReadSubExpr());
S->setBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setForLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCAtCatchStmt(ObjCAtCatchStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setCatchBody(Reader.ReadSubStmt());
Make the static type of the exception variable in an Objective-C @catch a VarDecl. The dynamic type is still a ParmVarDecl, but that will change soon. No effective functionality change. llvm-svn: 102341
2010-04-27 00:46:50 +08:00
S->setCatchParamDecl(cast_or_null<VarDecl>(Reader.GetDecl(Record[Idx++])));
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setAtCatchLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
S->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setFinallyBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setAtFinallyLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCAtTryStmt(ObjCAtTryStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
Improve the AST representation of Objective-C @try/@catch/@finally statements. Instead of the @try having a single @catch, where all of the @catch's were chained (using an O(n^2) algorithm nonetheless), @try just holds an array of its @catch blocks. The resulting AST is slightly more compact (not important) and better represents the actual language semantics (good). llvm-svn: 102221
2010-04-24 06:50:49 +08:00
assert(Record[Idx] == S->getNumCatchStmts());
++Idx;
bool HasFinally = Record[Idx++];
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setTryBody(Reader.ReadSubStmt());
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setCatchStmt(I, cast_or_null<ObjCAtCatchStmt>(Reader.ReadSubStmt()));
Improve the AST representation of Objective-C @try/@catch/@finally statements. Instead of the @try having a single @catch, where all of the @catch's were chained (using an O(n^2) algorithm nonetheless), @try just holds an array of its @catch blocks. The resulting AST is slightly more compact (not important) and better represents the actual language semantics (good). llvm-svn: 102221
2010-04-24 06:50:49 +08:00
if (HasFinally)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setFinallyStmt(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setAtTryLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCAtSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setSynchExpr(Reader.ReadSubStmt());
S->setSynchBody(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setAtSynchronizedLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitObjCAtThrowStmt(ObjCAtThrowStmt *S) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
VisitStmt(S);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
S->setThrowExpr(Reader.ReadSubStmt());
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S->setThrowLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
//===----------------------------------------------------------------------===//
// C++ Expressions and Statements
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
VisitCallExpr(E);
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
E->setOperator((OverloadedOperatorKind)Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXConstructExpr(CXXConstructExpr *E) {
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
VisitExpr(E);
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
assert(Record[Idx] == E->getNumArgs() &&"Read wrong record during creation?");
Fix broken de/serialization for a couple of C++ Exprs. llvm-svn: 106726
2010-06-24 16:57:09 +08:00
++Idx; // NumArgs;
for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setArg(I, Reader.ReadSubExpr());
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
E->setConstructor(cast<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
Switch the C++ new expression over to InitializationSequence, rather than using its own partial implementation of initialization. Switched CheckInitializerTypes over to InitializedEntity/InitializationKind, to help move us closer to InitializationSequence. Added InitializedEntity::getName() to retrieve the name of the entity, for diagnostics that care about such things. Implemented support for default initialization in InitializationSequence. Clean up the determination of the "source expressions" for an initialization sequence in InitializationSequence::Perform. Taught CXXConstructExpr to store more location information. llvm-svn: 91492
2009-12-16 09:38:02 +08:00
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
E->setElidable(Record[Idx++]);
When value-initializing a class with no user-defined constructors but with a non-trivial default constructor, zero-initialize the storage and then call the default constructor. Fixes PR5800. llvm-svn: 91548
2009-12-17 02:50:27 +08:00
E->setRequiresZeroInitialization(Record[Idx++]);
Recognize when the named return value optimization applies in a "return" statement and mark the corresponding CXXConstructExpr as elidable. Teach CodeGen that eliding a temporary is different from eliding an object construction. This is just a baby step toward NRVO. llvm-svn: 103849
2010-05-15 08:13:29 +08:00
E->setConstructionKind((CXXConstructExpr::ConstructionKind)Record[Idx++]);
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
}
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXNamedCastExpr(CXXNamedCastExpr *E) {
VisitExplicitCastExpr(E);
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
E->setOperatorLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXStaticCastExpr(CXXStaticCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
return VisitCXXNamedCastExpr(E);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXDynamicCastExpr(CXXDynamicCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
return VisitCXXNamedCastExpr(E);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXReinterpretCastExpr(CXXReinterpretCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
return VisitCXXNamedCastExpr(E);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXConstCastExpr(CXXConstCastExpr *E) {
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
return VisitCXXNamedCastExpr(E);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXFunctionalCastExpr(CXXFunctionalCastExpr *E) {
VisitExplicitCastExpr(E);
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
E->setTypeBeginLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXBoolLiteralExpr(CXXBoolLiteralExpr *E) {
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
VisitExpr(E);
E->setValue(Record[Idx++]);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E) {
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
VisitExpr(E);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXTypeidExpr(CXXTypeidExpr *E) {
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
VisitExpr(E);
E->setSourceRange(Reader.ReadSourceRange(Record, Idx));
if (E->isTypeOperand()) { // typeid(int)
E->setTypeOperandSourceInfo(Reader.GetTypeSourceInfo(Record, Idx));
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
return;
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
}
// typeid(42+2)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setExprOperand(Reader.ReadSubExpr());
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXThisExpr(CXXThisExpr *E) {
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
VisitExpr(E);
E->setLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setImplicit(Record[Idx++]);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXThrowExpr(CXXThrowExpr *E) {
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
VisitExpr(E);
E->setThrowLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
}
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXDefaultArgExpr(CXXDefaultArgExpr *E) {
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
VisitExpr(E);
E->setUsedLocation(SourceLocation::getFromRawEncoding(Record[Idx++]));
bool HasStoredExpr = Record[Idx++];
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
if (!HasStoredExpr) return;
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setExpr(Reader.ReadSubExpr());
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
VisitExpr(E);
E->setTemporary(Reader.ReadCXXTemporary(Record, Idx));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) {
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
VisitExpr(E);
E->setTypeBeginLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setRParenLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXNewExpr(CXXNewExpr *E) {
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
VisitExpr(E);
E->setGlobalNew(Record[Idx++]);
E->setParenTypeId(Record[Idx++]);
E->setHasInitializer(Record[Idx++]);
bool isArray = Record[Idx++];
unsigned NumPlacementArgs = Record[Idx++];
unsigned NumCtorArgs = Record[Idx++];
E->setOperatorNew(cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
E->setOperatorDelete(
cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
E->setConstructor(
cast_or_null<CXXConstructorDecl>(Reader.GetDecl(Record[Idx++])));
E->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->setEndLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
E->AllocateArgsArray(*Reader.getContext(), isArray, NumPlacementArgs,
NumCtorArgs);
// Install all the subexpressions.
for (CXXNewExpr::raw_arg_iterator I = E->raw_arg_begin(),e = E->raw_arg_end();
I != e; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
*I = Reader.ReadSubStmt();
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXDeleteExpr(CXXDeleteExpr *E) {
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-23 01:07:59 +08:00
VisitExpr(E);
E->setGlobalDelete(Record[Idx++]);
E->setArrayForm(Record[Idx++]);
E->setOperatorDelete(
cast_or_null<FunctionDecl>(Reader.GetDecl(Record[Idx++])));
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setArgument(Reader.ReadSubExpr());
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-23 01:07:59 +08:00
E->setStartLoc(SourceLocation::getFromRawEncoding(Record[Idx++]));
}
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXPseudoDestructorExpr(CXXPseudoDestructorExpr *E) {
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
VisitExpr(E);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
E->setArrow(Record[Idx++]);
E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx));
E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
E->setScopeTypeInfo(Reader.GetTypeSourceInfo(Record, Idx));
E->setColonColonLoc(Reader.ReadSourceLocation(Record, Idx));
E->setTildeLoc(Reader.ReadSourceLocation(Record, Idx));
IdentifierInfo *II = Reader.GetIdentifierInfo(Record, Idx);
if (II)
E->setDestroyedType(II, Reader.ReadSourceLocation(Record, Idx));
else
E->setDestroyedType(Reader.GetTypeSourceInfo(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) {
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
VisitExpr(E);
unsigned NumTemps = Record[Idx++];
if (NumTemps) {
Convert CXXTempory[] in CXXExprWithTemporaries to be allocated using ASTContext's allocator. Fixes <rdar://problem/7961605>. llvm-svn: 103421
2010-05-11 04:06:30 +08:00
E->setNumTemporaries(*Reader.getContext(), NumTemps);
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
for (unsigned i = 0; i != NumTemps; ++i)
E->setTemporary(i, Reader.ReadCXXTemporary(Record, Idx));
}
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setSubExpr(Reader.ReadSubExpr());
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
PCHStmtReader::VisitCXXDependentScopeMemberExpr(CXXDependentScopeMemberExpr *E){
VisitExpr(E);
unsigned NumTemplateArgs = Record[Idx++];
assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
"Read wrong record during creation ?");
Refactor PCH reading/writing of template arguments passed to expressions. llvm-svn: 106997
2010-06-28 17:31:48 +08:00
if (E->hasExplicitTemplateArgs())
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
ReadExplicitTemplateArgumentList(*E->getExplicitTemplateArgumentList(),
NumTemplateArgs);
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
E->setBaseType(Reader.GetType(Record[Idx++]));
E->setArrow(Record[Idx++]);
E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx));
E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
E->setFirstQualifierFoundInScope(
cast_or_null<NamedDecl>(Reader.GetDecl(Record[Idx++])));
E->setMember(Reader.ReadDeclarationName(Record, Idx));
E->setMemberLoc(Reader.ReadSourceLocation(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
PCHStmtReader::VisitDependentScopeDeclRefExpr(DependentScopeDeclRefExpr *E) {
VisitExpr(E);
unsigned NumTemplateArgs = Record[Idx++];
assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
"Read wrong record during creation ?");
if (E->hasExplicitTemplateArgs())
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
NumTemplateArgs);
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
E->setDeclName(Reader.ReadDeclarationName(Record, Idx));
E->setLocation(Reader.ReadSourceLocation(Record, Idx));
E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
PCHStmtReader::VisitCXXUnresolvedConstructExpr(CXXUnresolvedConstructExpr *E) {
VisitExpr(E);
assert(Record[Idx] == E->arg_size() && "Read wrong record during creation ?");
++Idx; // NumArgs;
for (unsigned I = 0, N = E->arg_size(); I != N; ++I)
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setArg(I, Reader.ReadSubExpr());
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
E->setTypeBeginLoc(Reader.ReadSourceLocation(Record, Idx));
E->setTypeAsWritten(Reader.GetType(Record[Idx++]));
E->setLParenLoc(Reader.ReadSourceLocation(Record, Idx));
E->setRParenLoc(Reader.ReadSourceLocation(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitOverloadExpr(OverloadExpr *E) {
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
VisitExpr(E);
unsigned NumTemplateArgs = Record[Idx++];
assert((NumTemplateArgs != 0) == E->hasExplicitTemplateArgs() &&
"Read wrong record during creation ?");
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
if (E->hasExplicitTemplateArgs())
ReadExplicitTemplateArgumentList(E->getExplicitTemplateArgs(),
NumTemplateArgs);
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
unsigned NumDecls = Record[Idx++];
UnresolvedSet<8> Decls;
for (unsigned i = 0; i != NumDecls; ++i) {
NamedDecl *D = cast<NamedDecl>(Reader.GetDecl(Record[Idx++]));
AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
Decls.addDecl(D, AS);
}
E->initializeResults(*Reader.getContext(), Decls.begin(), Decls.end());
E->setName(Reader.ReadDeclarationName(Record, Idx));
E->setQualifier(Reader.ReadNestedNameSpecifier(Record, Idx));
E->setQualifierRange(Reader.ReadSourceRange(Record, Idx));
E->setNameLoc(Reader.ReadSourceLocation(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitUnresolvedMemberExpr(UnresolvedMemberExpr *E) {
VisitOverloadExpr(E);
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
E->setArrow(Record[Idx++]);
E->setHasUnresolvedUsing(Record[Idx++]);
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
E->setBase(Reader.ReadSubExpr());
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
E->setBaseType(Reader.GetType(Record[Idx++]));
E->setOperatorLoc(Reader.ReadSourceLocation(Record, Idx));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
void PCHStmtReader::VisitUnresolvedLookupExpr(UnresolvedLookupExpr *E) {
VisitOverloadExpr(E);
Support UnresolvedLookupExpr for PCH. llvm-svn: 106832
2010-06-25 17:03:34 +08:00
E->setRequiresADL(Record[Idx++]);
E->setOverloaded(Record[Idx++]);
E->setNamingClass(cast_or_null<CXXRecordDecl>(Reader.GetDecl(Record[Idx++])));
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
Stmt *PCHReader::ReadStmt() {
switch (ReadingKind) {
case Read_Decl:
case Read_Type:
// Read a statement from the current DeclCursor.
return ReadStmtFromStream(DeclsCursor);
case Read_Stmt:
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
return ReadSubStmt();
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
}
llvm_unreachable("ReadingKind not set ?");
return 0;
}
Expr *PCHReader::ReadExpr() {
return cast_or_null<Expr>(ReadStmt());
}
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
When we know that we are at sub-statement reading (which is all of PCHStmtReader) use the "faster" ReadSubStmt. No functionality change. llvm-svn: 107218
2010-06-30 06:46:25 +08:00
Expr *PCHReader::ReadSubExpr() {
return cast_or_null<Expr>(ReadSubStmt());
}
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
// Within the bitstream, expressions are stored in Reverse Polish
// Notation, with each of the subexpressions preceding the
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
// expression they are stored in. Subexpressions are stored from last to first.
// To evaluate expressions, we continue reading expressions and placing them on
// the stack, with expressions having operands removing those operands from the
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
// stack. Evaluation terminates when we see a STMT_STOP record, and
// the single remaining expression on the stack is our result.
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
Stmt *PCHReader::ReadStmtFromStream(llvm::BitstreamCursor &Cursor) {
ReadingKindTracker ReadingKind(Read_Stmt, *this);
#ifndef NDEBUG
unsigned PrevNumStmts = StmtStack.size();
#endif
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
RecordData Record;
unsigned Idx;
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
PCHStmtReader Reader(*this, Record, Idx);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
Stmt::EmptyShell Empty;
while (true) {
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
unsigned Code = Cursor.ReadCode();
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
if (Code == llvm::bitc::END_BLOCK) {
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
if (Cursor.ReadBlockEnd()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("error at end of block in PCH file");
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
return 0;
}
break;
}
if (Code == llvm::bitc::ENTER_SUBBLOCK) {
// No known subblocks, always skip them.
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
Cursor.ReadSubBlockID();
if (Cursor.SkipBlock()) {
Make the PCH reader use the diagnostics system for its complaints. llvm-svn: 70330
2009-04-29 05:53:25 +08:00
Error("malformed block record in PCH file");
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
return 0;
}
continue;
}
if (Code == llvm::bitc::DEFINE_ABBREV) {
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
Cursor.ReadAbbrevRecord();
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
continue;
}
Stmt *S = 0;
Idx = 0;
Record.clear();
bool Finished = false;
change the interface to ReadStmt to force clients to pass a cursor in to read from. llvm-svn: 70188
2009-04-27 13:41:06 +08:00
switch ((pch::StmtCode)Cursor.ReadRecord(Code, Record)) {
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::STMT_STOP:
Finished = true;
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
case pch::STMT_NULL_PTR:
S = 0;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::STMT_NULL:
S = new (Context) NullStmt(Empty);
break;
case pch::STMT_COMPOUND:
S = new (Context) CompoundStmt(Empty);
break;
case pch::STMT_CASE:
S = new (Context) CaseStmt(Empty);
break;
case pch::STMT_DEFAULT:
S = new (Context) DefaultStmt(Empty);
break;
case pch::STMT_LABEL:
S = new (Context) LabelStmt(Empty);
break;
case pch::STMT_IF:
S = new (Context) IfStmt(Empty);
break;
case pch::STMT_SWITCH:
S = new (Context) SwitchStmt(Empty);
break;
case pch::STMT_WHILE:
S = new (Context) WhileStmt(Empty);
break;
case pch::STMT_DO:
S = new (Context) DoStmt(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::STMT_FOR:
S = new (Context) ForStmt(Empty);
break;
case pch::STMT_GOTO:
S = new (Context) GotoStmt(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::STMT_INDIRECT_GOTO:
S = new (Context) IndirectGotoStmt(Empty);
break;
case pch::STMT_CONTINUE:
S = new (Context) ContinueStmt(Empty);
break;
case pch::STMT_BREAK:
S = new (Context) BreakStmt(Empty);
break;
case pch::STMT_RETURN:
S = new (Context) ReturnStmt(Empty);
break;
case pch::STMT_DECL:
S = new (Context) DeclStmt(Empty);
break;
case pch::STMT_ASM:
S = new (Context) AsmStmt(Empty);
break;
case pch::EXPR_PREDEFINED:
S = new (Context) PredefinedExpr(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
case pch::EXPR_DECL_REF:
S = new (Context) DeclRefExpr(Empty);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
case pch::EXPR_INTEGER_LITERAL:
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
S = new (Context) IntegerLiteral(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::EXPR_FLOATING_LITERAL:
S = new (Context) FloatingLiteral(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::EXPR_IMAGINARY_LITERAL:
S = new (Context) ImaginaryLiteral(Empty);
break;
case pch::EXPR_STRING_LITERAL:
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
S = StringLiteral::CreateEmpty(*Context,
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
Record[PCHStmtReader::NumExprFields + 1]);
break;
case pch::EXPR_CHARACTER_LITERAL:
S = new (Context) CharacterLiteral(Empty);
break;
case pch::EXPR_PAREN:
S = new (Context) ParenExpr(Empty);
break;
case pch::EXPR_UNARY_OPERATOR:
S = new (Context) UnaryOperator(Empty);
break;
Completely reimplement __builtin_offsetof, based on a patch by Roberto Amadini. This change introduces a new expression node type, OffsetOfExpr, that describes __builtin_offsetof. Previously, __builtin_offsetof was implemented using a unary operator whose subexpression involved various synthesized array-subscript and member-reference expressions, which was ugly and made it very hard to instantiate as a template. OffsetOfExpr represents the AST more faithfully, with proper type source information and a more compact representation. OffsetOfExpr also has support for dependent __builtin_offsetof expressions; it can be value-dependent, but will never be type-dependent (like sizeof or alignof). This commit introduces template instantiation for __builtin_offsetof as well. There are two major caveats to this patch: 1) CodeGen cannot handle the case where __builtin_offsetof is not a constant expression, so it produces an error. So, to avoid regressing in C, we retain the old UnaryOperator-based __builtin_offsetof implementation in C while using the shiny new OffsetOfExpr implementation in C++. The old implementation can go away once we have proper CodeGen support for this case, which we expect won't cause much trouble in C++. 2) __builtin_offsetof doesn't work well with non-POD class types, particularly when the designated field is found within a base class. I will address this in a subsequent patch. Fixes PR5880 and a bunch of assertions when building Boost.Python tests. llvm-svn: 102542
2010-04-29 06:16:22 +08:00
case pch::EXPR_OFFSETOF:
S = OffsetOfExpr::CreateEmpty(*Context,
Record[PCHStmtReader::NumExprFields],
Record[PCHStmtReader::NumExprFields + 1]);
break;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::EXPR_SIZEOF_ALIGN_OF:
S = new (Context) SizeOfAlignOfExpr(Empty);
break;
case pch::EXPR_ARRAY_SUBSCRIPT:
S = new (Context) ArraySubscriptExpr(Empty);
break;
case pch::EXPR_CALL:
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
S = new (Context) CallExpr(*Context, Stmt::CallExprClass, Empty);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::EXPR_MEMBER:
S = new (Context) MemberExpr(Empty);
break;
case pch::EXPR_BINARY_OPERATOR:
S = new (Context) BinaryOperator(Empty);
break;
case pch::EXPR_COMPOUND_ASSIGN_OPERATOR:
S = new (Context) CompoundAssignOperator(Empty);
break;
case pch::EXPR_CONDITIONAL_OPERATOR:
S = new (Context) ConditionalOperator(Empty);
break;
case pch::EXPR_IMPLICIT_CAST:
S = new (Context) ImplicitCastExpr(Empty);
break;
case pch::EXPR_CSTYLE_CAST:
S = new (Context) CStyleCastExpr(Empty);
break;
case pch::EXPR_COMPOUND_LITERAL:
S = new (Context) CompoundLiteralExpr(Empty);
break;
case pch::EXPR_EXT_VECTOR_ELEMENT:
S = new (Context) ExtVectorElementExpr(Empty);
break;
case pch::EXPR_INIT_LIST:
Use ASTVector instead of std::vector for the Exprs in InitListExpr. Performance measurements of '-fsyntax-only' on combine.c (403.gcc) shows no real performance change, but now the vector isn't leaked. llvm-svn: 101195
2010-04-14 07:39:13 +08:00
S = new (Context) InitListExpr(*getContext(), Empty);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::EXPR_DESIGNATED_INIT:
Teach PCH that ASTContext is optional. Move -parse-noop and -Eonly (so far) processing to after PCH is loaded. -Eonly and -parse-noop are close to working with PCH now but are not quite there yet. llvm-svn: 70257
2009-04-28 05:45:14 +08:00
S = DesignatedInitExpr::CreateEmpty(*Context,
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
Record[PCHStmtReader::NumExprFields] - 1);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::EXPR_IMPLICIT_VALUE_INIT:
S = new (Context) ImplicitValueInitExpr(Empty);
break;
case pch::EXPR_VA_ARG:
S = new (Context) VAArgExpr(Empty);
break;
case pch::EXPR_ADDR_LABEL:
S = new (Context) AddrLabelExpr(Empty);
break;
case pch::EXPR_STMT:
S = new (Context) StmtExpr(Empty);
break;
case pch::EXPR_TYPES_COMPATIBLE:
S = new (Context) TypesCompatibleExpr(Empty);
break;
case pch::EXPR_CHOOSE:
S = new (Context) ChooseExpr(Empty);
break;
case pch::EXPR_GNU_NULL:
S = new (Context) GNUNullExpr(Empty);
break;
case pch::EXPR_SHUFFLE_VECTOR:
S = new (Context) ShuffleVectorExpr(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::EXPR_BLOCK:
S = new (Context) BlockExpr(Empty);
break;
case pch::EXPR_BLOCK_DECL_REF:
S = new (Context) BlockDeclRefExpr(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::EXPR_OBJC_STRING_LITERAL:
S = new (Context) ObjCStringLiteral(Empty);
break;
case pch::EXPR_OBJC_ENCODE:
S = new (Context) ObjCEncodeExpr(Empty);
break;
case pch::EXPR_OBJC_SELECTOR_EXPR:
S = new (Context) ObjCSelectorExpr(Empty);
break;
case pch::EXPR_OBJC_PROTOCOL_EXPR:
S = new (Context) ObjCProtocolExpr(Empty);
break;
case pch::EXPR_OBJC_IVAR_REF_EXPR:
S = new (Context) ObjCIvarRefExpr(Empty);
break;
case pch::EXPR_OBJC_PROPERTY_REF_EXPR:
S = new (Context) ObjCPropertyRefExpr(Empty);
break;
case pch::EXPR_OBJC_KVC_REF_EXPR:
Using "ObjCImplicitSetterGetterRefExpr" instead of "ObjCImplctSetterGetterRefExpr". A field rename and more comments. llvm-svn: 79537
2009-08-21 01:02:02 +08:00
S = new (Context) ObjCImplicitSetterGetterRefExpr(Empty);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::EXPR_OBJC_MESSAGE_EXPR:
Overhaul the AST representation of Objective-C message send expressions, to improve source-location information, clarify the actual receiver of the message, and pave the way for proper C++ support. The ObjCMessageExpr node represents four different kinds of message sends in a single AST node: 1) Send to a object instance described by an expression (e.g., [x method:5]) 2) Send to a class described by the class name (e.g., [NSString method:5]) 3) Send to a superclass class (e.g, [super method:5] in class method) 4) Send to a superclass instance (e.g., [super method:5] in instance method) Previously these four cases where tangled together. Now, they have more distinct representations. Specific changes: 1) Unchanged; the object instance is represented by an Expr*. 2) Previously stored the ObjCInterfaceDecl* referring to the class receiving the message. Now stores a TypeSourceInfo* so that we know how the class was spelled. This both maintains typedef information and opens the door for more complicated C++ types (e.g., dependent types). There was an alternative, unused representation of these sends by naming the class via an IdentifierInfo *. In practice, we either had an ObjCInterfaceDecl *, from which we would get the IdentifierInfo *, or we fell into the case below... 3) Previously represented by a class message whose IdentifierInfo * referred to "super". Sema and CodeGen would use isStr("super") to determine if they had a send to super. Now represented as a "class super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). 4) Previously represented by an instance message whose receiver is a an ObjCSuperExpr, which Sema and CodeGen would check for via isa<ObjCSuperExpr>(). Now represented as an "instance super" send, where we have both the location of the "super" keyword and the ObjCInterfaceDecl* of the superclass we're targetting (statically). Note that ObjCSuperExpr only has one remaining use in the AST, which is for "super.prop" references. The new representation of ObjCMessageExpr is 2 pointers smaller than the old one, since it combines more storage. It also eliminates a leak when we loaded message-send expressions from a precompiled header. The representation also feels much cleaner to me; comments welcome! This patch attempts to maintain the same semantics we previously had with Objective-C message sends. In several places, there are massive changes that boil down to simply replacing a nested-if structure such as: if (message has a receiver expression) { // instance message if (isa<ObjCSuperExpr>(...)) { // send to super } else { // send to an object } } else { // class message if (name->isStr("super")) { // class send to super } else { // send to class } } with a switch switch (E->getReceiverKind()) { case ObjCMessageExpr::SuperInstance: ... case ObjCMessageExpr::Instance: ... case ObjCMessageExpr::SuperClass: ... case ObjCMessageExpr::Class:... } There are quite a few places (particularly in the checkers) where send-to-super is effectively ignored. I've placed FIXMEs in most of them, and attempted to address send-to-super in a reasonable way. This could use some review. llvm-svn: 101972
2010-04-21 08:45:42 +08:00
S = ObjCMessageExpr::CreateEmpty(*Context,
Record[PCHStmtReader::NumExprFields]);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::EXPR_OBJC_SUPER_EXPR:
S = new (Context) ObjCSuperExpr(Empty);
break;
Allow front-end 'isa' access on object's of type 'id'. Enhance test case to cover 'isa' access on interface types (clang produces an error, GCC produces a warning). Still need back-end CodeGen for ObjCIsaExpr. llvm-svn: 76979
2009-07-25 01:54:45 +08:00
case pch::EXPR_OBJC_ISA:
S = new (Context) ObjCIsaExpr(Empty);
break;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
case pch::STMT_OBJC_FOR_COLLECTION:
S = new (Context) ObjCForCollectionStmt(Empty);
break;
case pch::STMT_OBJC_CATCH:
S = new (Context) ObjCAtCatchStmt(Empty);
break;
case pch::STMT_OBJC_FINALLY:
S = new (Context) ObjCAtFinallyStmt(Empty);
break;
case pch::STMT_OBJC_AT_TRY:
Improve the AST representation of Objective-C @try/@catch/@finally statements. Instead of the @try having a single @catch, where all of the @catch's were chained (using an O(n^2) algorithm nonetheless), @try just holds an array of its @catch blocks. The resulting AST is slightly more compact (not important) and better represents the actual language semantics (good). llvm-svn: 102221
2010-04-24 06:50:49 +08:00
S = ObjCAtTryStmt::CreateEmpty(*Context,
Record[PCHStmtReader::NumStmtFields],
Record[PCHStmtReader::NumStmtFields + 1]);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
break;
case pch::STMT_OBJC_AT_SYNCHRONIZED:
S = new (Context) ObjCAtSynchronizedStmt(Empty);
break;
case pch::STMT_OBJC_AT_THROW:
S = new (Context) ObjCAtThrowStmt(Empty);
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Read/write a CXXOperatorCallExpr from/to PCH files. llvm-svn: 75598
2009-07-14 11:19:21 +08:00
case pch::EXPR_CXX_OPERATOR_CALL:
S = new (Context) CXXOperatorCallExpr(*Context, Empty);
break;
pchify CXXMemberCallExpr correctly. Before it would serialize and deserialize as a CallExpr which is close, but ends up deserializing with the wrong stmt class. llvm-svn: 103371
2010-05-09 13:36:05 +08:00
case pch::EXPR_CXX_MEMBER_CALL:
S = new (Context) CXXMemberCallExpr(*Context, Empty);
break;
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
case pch::EXPR_CXX_CONSTRUCT:
S = new (Context) CXXConstructExpr(Empty, *Context,
Fix broken de/serialization for a couple of C++ Exprs. llvm-svn: 106726
2010-06-24 16:57:09 +08:00
Record[PCHStmtReader::NumExprFields]);
Improve handling of initialization by constructor, by ensuring that such initializations properly convert constructor arguments and fill in default arguments where necessary. This also makes the ownership model more clear. llvm-svn: 81394
2009-09-10 07:08:42 +08:00
break;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
case pch::EXPR_CXX_STATIC_CAST:
S = new (Context) CXXStaticCastExpr(Empty);
break;
case pch::EXPR_CXX_DYNAMIC_CAST:
S = new (Context) CXXDynamicCastExpr(Empty);
break;
case pch::EXPR_CXX_REINTERPRET_CAST:
S = new (Context) CXXReinterpretCastExpr(Empty);
break;
case pch::EXPR_CXX_CONST_CAST:
S = new (Context) CXXConstCastExpr(Empty);
break;
case pch::EXPR_CXX_FUNCTIONAL_CAST:
S = new (Context) CXXFunctionalCastExpr(Empty);
break;
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
case pch::EXPR_CXX_BOOL_LITERAL:
S = new (Context) CXXBoolLiteralExpr(Empty);
break;
Add PCH support for CXXStaticCastExpr, CXXDynamicCastExpr, CXXReinterpretCastExpr, CXXConstCastExpr and CXXFunctionalCastExpr. llvm-svn: 93658
2010-01-17 05:21:01 +08:00
Roll r95513 back in. llvm-svn: 95515
2010-02-07 14:32:43 +08:00
case pch::EXPR_CXX_NULL_PTR_LITERAL:
S = new (Context) CXXNullPtrLiteralExpr(Empty);
break;
pch'ify typeid. llvm-svn: 103374
2010-05-09 14:03:39 +08:00
case pch::EXPR_CXX_TYPEID_EXPR:
S = new (Context) CXXTypeidExpr(Empty, true);
break;
case pch::EXPR_CXX_TYPEID_TYPE:
S = new (Context) CXXTypeidExpr(Empty, false);
break;
pch'ify 'this' and 'throw' llvm-svn: 103375
2010-05-09 14:15:05 +08:00
case pch::EXPR_CXX_THIS:
S = new (Context) CXXThisExpr(Empty);
break;
case pch::EXPR_CXX_THROW:
S = new (Context) CXXThrowExpr(Empty);
break;
pch'ify default argument definitions and uses. llvm-svn: 103376
2010-05-09 14:40:08 +08:00
case pch::EXPR_CXX_DEFAULT_ARG:
S = new (Context) CXXDefaultArgExpr(Empty);
break;
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
case pch::EXPR_CXX_BIND_TEMPORARY:
S = new (Context) CXXBindTemporaryExpr(Empty);
break;
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
case pch::EXPR_CXX_ZERO_INIT_VALUE:
S = new (Context) CXXZeroInitValueExpr(Empty);
break;
case pch::EXPR_CXX_NEW:
S = new (Context) CXXNewExpr(Empty);
break;
Read/write CXXDeleteExpr from/to PCH. llvm-svn: 106552
2010-06-23 01:07:59 +08:00
case pch::EXPR_CXX_DELETE:
S = new (Context) CXXDeleteExpr(Empty);
break;
Support CXXPseudoDestructorExpr for PCH. llvm-svn: 106999
2010-06-28 17:32:03 +08:00
case pch::EXPR_CXX_PSEUDO_DESTRUCTOR:
S = new (Context) CXXPseudoDestructorExpr(Empty);
break;
pch'ify CXXNewExpr and CXXZeroInitValueExpr llvm-svn: 103390
2010-05-10 09:22:27 +08:00
pchify CXXTemporary, CXXBindTemporaryExpr, and CXXExprWithTemporaries. llvm-svn: 103387
2010-05-10 08:25:06 +08:00
case pch::EXPR_CXX_EXPR_WITH_TEMPORARIES:
S = new (Context) CXXExprWithTemporaries(Empty);
break;
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
case pch::EXPR_CXX_DEPENDENT_SCOPE_MEMBER:
S = CXXDependentScopeMemberExpr::CreateEmpty(*Context,
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
/*NumTemplateArgs=*/Record[PCHStmtReader::NumExprFields]);
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
break;
Support DependentScopeDeclRefExpr for PCH. llvm-svn: 106998
2010-06-28 17:31:56 +08:00
case pch::EXPR_CXX_DEPENDENT_SCOPE_DECL_REF:
S = DependentScopeDeclRefExpr::CreateEmpty(*Context,
/*NumTemplateArgs=*/Record[PCHStmtReader::NumExprFields]);
break;
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
case pch::EXPR_CXX_UNRESOLVED_CONSTRUCT:
S = CXXUnresolvedConstructExpr::CreateEmpty(*Context,
Support UnresolvedMemberExpr for PCH. llvm-svn: 106831
2010-06-25 17:03:26 +08:00
/*NumArgs=*/Record[PCHStmtReader::NumExprFields]);
break;
case pch::EXPR_CXX_UNRESOLVED_MEMBER:
S = UnresolvedMemberExpr::CreateEmpty(*Context,
/*NumTemplateArgs=*/Record[PCHStmtReader::NumExprFields]);
Support a couple more C++ Exprs for PCH. llvm-svn: 106727
2010-06-24 16:57:31 +08:00
break;
Support UnresolvedLookupExpr for PCH. llvm-svn: 106832
2010-06-25 17:03:34 +08:00
case pch::EXPR_CXX_UNRESOLVED_LOOKUP:
S = UnresolvedLookupExpr::CreateEmpty(*Context,
/*NumTemplateArgs=*/Record[PCHStmtReader::NumExprFields]);
break;
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}
// We hit a STMT_STOP, so we're done with this expression.
if (Finished)
break;
++NumStatementsRead;
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
if (S)
Reader.Visit(S);
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
assert(Idx == Record.size() && "Invalid deserialization of statement");
StmtStack.push_back(S);
}
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
#ifndef NDEBUG
assert(StmtStack.size() > PrevNumStmts && "Read too many sub stmts!");
assert(StmtStack.size() == PrevNumStmts + 1 && "Extra expressions on stack!");
#endif
return StmtStack.pop_back_val();
split stmt/expr deserialization out to PCHReaderStmt.cpp llvm-svn: 70186
2009-04-27 13:14:47 +08:00
}