Overhaul of Stmt allocation:
- Made allocation of Stmt objects using vanilla new/delete a *compiler
error* by making this new/delete "protected" within class Stmt.
- Now the only way to allocate Stmt objects is by using the new
operator that takes ASTContext& as an argument. This ensures that
all Stmt nodes are allocated from the same (pool) allocator.
- Naturally, these two changes required that *all* creation sites for
AST nodes use new (ASTContext&). This is a large patch, but the
majority of the changes are just this mechanical adjustment.
- The above changes also mean that AST nodes can no longer be
deallocated using 'delete'. Instead, one most do
StmtObject->Destroy(ASTContext&) or do
ASTContextObject.Deallocate(StmtObject) (the latter not running the
'Destroy' method).
Along the way I also...
- Made CompoundStmt allocate its array of Stmt* using the allocator in
ASTContext (previously it used std::vector). There are a whole
bunch of other Stmt classes that need to be similarly changed to
ensure that all memory allocated for ASTs comes from the allocator
in ASTContext.
- Added a new smart pointer ExprOwningPtr to Sema.h. This replaces
the uses of llvm::OwningPtr within Sema, as llvm::OwningPtr used
'delete' to free memory instead of a Stmt's 'Destroy' method.
Big thanks to Doug Gregor for helping with the acrobatics of making
'new/delete' private and the new smart pointer ExprOwningPtr!
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@63997 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 89fdbe3..d686167 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -54,8 +54,8 @@
}
void StringLiteral::Destroy(ASTContext &C) {
- C.Deallocate(const_cast<char*>(StrData));
this->~StringLiteral();
+ C.Deallocate(const_cast<char*>(StrData));
}
bool UnaryOperator::isPostfix(Opcode Op) {
@@ -104,8 +104,8 @@
// Postfix Operators.
//===----------------------------------------------------------------------===//
-CallExpr::CallExpr(StmtClass SC, Expr *fn, Expr **args, unsigned numargs,
- QualType t, SourceLocation rparenloc)
+CallExpr::CallExpr(StmtClass SC, Expr *fn, Expr **args,
+ unsigned numargs, QualType t, SourceLocation rparenloc)
: Expr(SC, t,
fn->isTypeDependent() || hasAnyTypeDependentArguments(args, numargs),
fn->isValueDependent() || hasAnyValueDependentArguments(args, numargs)),
@@ -133,14 +133,14 @@
/// setNumArgs - This changes the number of arguments present in this call.
/// Any orphaned expressions are deleted by this, and any new operands are set
/// to null.
-void CallExpr::setNumArgs(unsigned NumArgs) {
+void CallExpr::setNumArgs(ASTContext& C, unsigned NumArgs) {
// No change, just return.
if (NumArgs == getNumArgs()) return;
// If shrinking # arguments, just delete the extras and forgot them.
if (NumArgs < getNumArgs()) {
for (unsigned i = NumArgs, e = getNumArgs(); i != e; ++i)
- delete getArg(i);
+ getArg(i)->Destroy(C);
this->NumArgs = NumArgs;
return;
}
@@ -154,7 +154,7 @@
for (unsigned i = getNumArgs()+ARGS_START; i != NumArgs+ARGS_START; ++i)
NewSubExprs[i] = 0;
- delete[] SubExprs;
+ delete [] SubExprs;
SubExprs = NewSubExprs;
this->NumArgs = NumArgs;
}
@@ -1391,10 +1391,10 @@
// will iterate over the size expression. However, this expression belongs
// to the type, not to this, so we don't want to delete it.
// We still want to delete this expression.
- // FIXME: Same as in Stmt::Destroy - will be eventually in ASTContext's
- // pool allocator.
- if (isArgumentType())
- delete this;
+ if (isArgumentType()) {
+ this->~SizeOfAlignOfExpr();
+ C.Deallocate(this);
+ }
else
Expr::Destroy(C);
}
diff --git a/lib/AST/ExprCXX.cpp b/lib/AST/ExprCXX.cpp
index b328c1e..801a0f2 100644
--- a/lib/AST/ExprCXX.cpp
+++ b/lib/AST/ExprCXX.cpp
@@ -20,10 +20,10 @@
// FIXME: Cannot destroy the decl here, because it is linked into the
// DeclContext's chain.
//getVarDecl()->Destroy(C);
- delete this;
+ this->~CXXConditionDeclExpr();
+ C.Deallocate(this);
}
-
//===----------------------------------------------------------------------===//
// Child Iterators for iterating over subexpressions/substatements
//===----------------------------------------------------------------------===//
diff --git a/lib/AST/Stmt.cpp b/lib/AST/Stmt.cpp
index 541bb04..49c8c80 100644
--- a/lib/AST/Stmt.cpp
+++ b/lib/AST/Stmt.cpp
@@ -219,7 +219,7 @@
// CompoundStmt
Stmt::child_iterator CompoundStmt::child_begin() { return &Body[0]; }
-Stmt::child_iterator CompoundStmt::child_end() { return &Body[0]+Body.size(); }
+Stmt::child_iterator CompoundStmt::child_end() { return &Body[0]+NumStmts; }
// CaseStmt
Stmt::child_iterator CaseStmt::child_begin() { return &SubExprs[0]; }
diff --git a/lib/AST/StmtSerialization.cpp b/lib/AST/StmtSerialization.cpp
index 8d6636d..92713cc 100644
--- a/lib/AST/StmtSerialization.cpp
+++ b/lib/AST/StmtSerialization.cpp
@@ -483,7 +483,8 @@
S.EmitOwnedPtr(Init);
}
-CompoundLiteralExpr* CompoundLiteralExpr::CreateImpl(Deserializer& D, ASTContext& C) {
+CompoundLiteralExpr* CompoundLiteralExpr::CreateImpl(Deserializer& D,
+ ASTContext& C) {
QualType Q = QualType::ReadVal(D);
SourceLocation L = SourceLocation::ReadVal(D);
bool fileScope = D.ReadBool();
@@ -495,10 +496,8 @@
void CompoundStmt::EmitImpl(Serializer& S) const {
S.Emit(LBracLoc);
S.Emit(RBracLoc);
- S.Emit(Body.size());
-
- for (const_body_iterator I=body_begin(), E=body_end(); I!=E; ++I)
- S.EmitOwnedPtr(*I);
+ S.Emit(NumStmts);
+ if (NumStmts) S.BatchEmitOwnedPtrs(NumStmts, &Body[0]);
}
CompoundStmt* CompoundStmt::CreateImpl(Deserializer& D, ASTContext& C) {
@@ -507,13 +506,15 @@
unsigned size = D.ReadInt();
CompoundStmt* stmt = new (C, llvm::alignof<CompoundStmt>())
- CompoundStmt(NULL, 0, LB, RB);
+ CompoundStmt(C, NULL, 0, LB, RB);
+
+ stmt->NumStmts = size;
- stmt->Body.reserve(size);
-
- for (unsigned i = 0; i < size; ++i)
- stmt->Body.push_back(D.ReadOwnedPtr<Stmt>(C));
-
+ if (size) {
+ stmt->Body = new (C) Stmt*[size];
+ D.BatchReadOwnedPtrs(size, &stmt->Body[0], C);
+ }
+
return stmt;
}
@@ -1306,7 +1307,7 @@
Expr *B = D.ReadOwnedPtr<Expr>(C);
IdentifierInfo *A = D.ReadPtr<IdentifierInfo>();
SourceLocation AL = SourceLocation::ReadVal(D);
- return new ExtVectorElementExpr(T, B, *A, AL);
+ return new (C) ExtVectorElementExpr(T, B, *A, AL);
}
void BlockExpr::EmitImpl(Serializer& S) const {