Changes in directory llvm/lib/Analysis:
ScalarEvolution.cpp updated: 1.52 -> 1.53
---
Log message:
Fix some more static dtor issues.
---
Diffs of the changes: (+36 -33)
ScalarEvolution.cpp | 69 +++++++++++++++++++++++++++-------------------------
1 files changed, 36 insertions(+), 33 deletions(-)
Index: llvm/lib/Analysis/ScalarEvolution.cpp
diff -u llvm/lib/Analysis/ScalarEvolution.cpp:1.52
llvm/lib/Analysis/ScalarEvolution.cpp:1.53
--- llvm/lib/Analysis/ScalarEvolution.cpp:1.52 Thu Sep 28 18:35:49 2006
+++ llvm/lib/Analysis/ScalarEvolution.cpp Wed Oct 4 16:49:37 2006
@@ -70,9 +70,10 @@
#include "llvm/Transforms/Scalar.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Compiler.h"
#include "llvm/Support/ConstantRange.h"
#include "llvm/Support/InstIterator.h"
-#include "llvm/Support/Compiler.h"
+#include "llvm/Support/ManagedStatic.h"
#include "llvm/ADT/Statistic.h"
#include <cmath>
#include <iostream>
@@ -165,11 +166,11 @@
// SCEVConstants - Only allow the creation of one SCEVConstant for any
// particular value. Don't use a SCEVHandle here, or else the object will
// never be deleted!
-static std::map<ConstantInt*, SCEVConstant*> SCEVConstants;
+static ManagedStatic<std::map<ConstantInt*, SCEVConstant*> > SCEVConstants;
SCEVConstant::~SCEVConstant() {
- SCEVConstants.erase(V);
+ SCEVConstants->erase(V);
}
SCEVHandle SCEVConstant::get(ConstantInt *V) {
@@ -179,7 +180,7 @@
V = cast<ConstantUInt>(ConstantExpr::getCast(V, NewTy));
}
- SCEVConstant *&R = SCEVConstants[V];
+ SCEVConstant *&R = (*SCEVConstants)[V];
if (R == 0) R = new SCEVConstant(V);
return R;
}
@@ -197,7 +198,8 @@
// SCEVTruncates - Only allow the creation of one SCEVTruncateExpr for any
// particular input. Don't use a SCEVHandle here, or else the object will
// never be deleted!
-static std::map<std::pair<SCEV*, const Type*>, SCEVTruncateExpr*>
SCEVTruncates;
+static ManagedStatic<std::map<std::pair<SCEV*, const Type*>,
+ SCEVTruncateExpr*> > SCEVTruncates;
SCEVTruncateExpr::SCEVTruncateExpr(const SCEVHandle &op, const Type *ty)
: SCEV(scTruncate), Op(op), Ty(ty) {
@@ -209,7 +211,7 @@
}
SCEVTruncateExpr::~SCEVTruncateExpr() {
- SCEVTruncates.erase(std::make_pair(Op, Ty));
+ SCEVTruncates->erase(std::make_pair(Op, Ty));
}
ConstantRange SCEVTruncateExpr::getValueRange() const {
@@ -223,8 +225,8 @@
// SCEVZeroExtends - Only allow the creation of one SCEVZeroExtendExpr for any
// particular input. Don't use a SCEVHandle here, or else the object will
never
// be deleted!
-static std::map<std::pair<SCEV*, const Type*>,
- SCEVZeroExtendExpr*> SCEVZeroExtends;
+static ManagedStatic<std::map<std::pair<SCEV*, const Type*>,
+ SCEVZeroExtendExpr*> > SCEVZeroExtends;
SCEVZeroExtendExpr::SCEVZeroExtendExpr(const SCEVHandle &op, const Type *ty)
: SCEV(scTruncate), Op(op), Ty(ty) {
@@ -236,7 +238,7 @@
}
SCEVZeroExtendExpr::~SCEVZeroExtendExpr() {
- SCEVZeroExtends.erase(std::make_pair(Op, Ty));
+ SCEVZeroExtends->erase(std::make_pair(Op, Ty));
}
ConstantRange SCEVZeroExtendExpr::getValueRange() const {
@@ -250,13 +252,13 @@
// SCEVCommExprs - Only allow the creation of one SCEVCommutativeExpr for any
// particular input. Don't use a SCEVHandle here, or else the object will
never
// be deleted!
-static std::map<std::pair<unsigned, std::vector<SCEV*> >,
- SCEVCommutativeExpr*> SCEVCommExprs;
+static ManagedStatic<std::map<std::pair<unsigned, std::vector<SCEV*> >,
+ SCEVCommutativeExpr*> > SCEVCommExprs;
SCEVCommutativeExpr::~SCEVCommutativeExpr() {
- SCEVCommExprs.erase(std::make_pair(getSCEVType(),
- std::vector<SCEV*>(Operands.begin(),
- Operands.end())));
+ SCEVCommExprs->erase(std::make_pair(getSCEVType(),
+ std::vector<SCEV*>(Operands.begin(),
+ Operands.end())));
}
void SCEVCommutativeExpr::print(std::ostream &OS) const {
@@ -298,10 +300,11 @@
// SCEVSDivs - Only allow the creation of one SCEVSDivExpr for any particular
// input. Don't use a SCEVHandle here, or else the object will never be
// deleted!
-static std::map<std::pair<SCEV*, SCEV*>, SCEVSDivExpr*> SCEVSDivs;
+static ManagedStatic<std::map<std::pair<SCEV*, SCEV*>,
+ SCEVSDivExpr*> > SCEVSDivs;
SCEVSDivExpr::~SCEVSDivExpr() {
- SCEVSDivs.erase(std::make_pair(LHS, RHS));
+ SCEVSDivs->erase(std::make_pair(LHS, RHS));
}
void SCEVSDivExpr::print(std::ostream &OS) const {
@@ -317,13 +320,13 @@
// SCEVAddRecExprs - Only allow the creation of one SCEVAddRecExpr for any
// particular input. Don't use a SCEVHandle here, or else the object will
never
// be deleted!
-static std::map<std::pair<const Loop *, std::vector<SCEV*> >,
- SCEVAddRecExpr*> SCEVAddRecExprs;
+static ManagedStatic<std::map<std::pair<const Loop *, std::vector<SCEV*> >,
+ SCEVAddRecExpr*> > SCEVAddRecExprs;
SCEVAddRecExpr::~SCEVAddRecExpr() {
- SCEVAddRecExprs.erase(std::make_pair(L,
- std::vector<SCEV*>(Operands.begin(),
- Operands.end())));
+ SCEVAddRecExprs->erase(std::make_pair(L,
+ std::vector<SCEV*>(Operands.begin(),
+ Operands.end())));
}
SCEVHandle SCEVAddRecExpr::
@@ -366,9 +369,9 @@
// SCEVUnknowns - Only allow the creation of one SCEVUnknown for any particular
// value. Don't use a SCEVHandle here, or else the object will never be
// deleted!
-static std::map<Value*, SCEVUnknown*> SCEVUnknowns;
+static ManagedStatic<std::map<Value*, SCEVUnknown*> > SCEVUnknowns;
-SCEVUnknown::~SCEVUnknown() { SCEVUnknowns.erase(V); }
+SCEVUnknown::~SCEVUnknown() { SCEVUnknowns->erase(V); }
bool SCEVUnknown::isLoopInvariant(const Loop *L) const {
// All non-instruction values are loop invariant. All instructions are loop
@@ -571,7 +574,7 @@
return SCEVAddRecExpr::get(Operands, AddRec->getLoop());
}
- SCEVTruncateExpr *&Result = SCEVTruncates[std::make_pair(Op, Ty)];
+ SCEVTruncateExpr *&Result = (*SCEVTruncates)[std::make_pair(Op, Ty)];
if (Result == 0) Result = new SCEVTruncateExpr(Op, Ty);
return Result;
}
@@ -585,7 +588,7 @@
// operands (often constants). This would allow analysis of something like
// this: for (unsigned char X = 0; X < 100; ++X) { int Y = X; }
- SCEVZeroExtendExpr *&Result = SCEVZeroExtends[std::make_pair(Op, Ty)];
+ SCEVZeroExtendExpr *&Result = (*SCEVZeroExtends)[std::make_pair(Op, Ty)];
if (Result == 0) Result = new SCEVZeroExtendExpr(Op, Ty);
return Result;
}
@@ -813,8 +816,8 @@
// Okay, it looks like we really DO need an add expr. Check to see if we
// already have one, otherwise create a new one.
std::vector<SCEV*> SCEVOps(Ops.begin(), Ops.end());
- SCEVCommutativeExpr *&Result = SCEVCommExprs[std::make_pair(scAddExpr,
- SCEVOps)];
+ SCEVCommutativeExpr *&Result = (*SCEVCommExprs)[std::make_pair(scAddExpr,
+ SCEVOps)];
if (Result == 0) Result = new SCEVAddExpr(Ops);
return Result;
}
@@ -976,8 +979,8 @@
// Okay, it looks like we really DO need an mul expr. Check to see if we
// already have one, otherwise create a new one.
std::vector<SCEV*> SCEVOps(Ops.begin(), Ops.end());
- SCEVCommutativeExpr *&Result = SCEVCommExprs[std::make_pair(scMulExpr,
- SCEVOps)];
+ SCEVCommutativeExpr *&Result = (*SCEVCommExprs)[std::make_pair(scMulExpr,
+ SCEVOps)];
if (Result == 0)
Result = new SCEVMulExpr(Ops);
return Result;
@@ -1004,7 +1007,7 @@
// FIXME: implement folding of (X*4)/4 when we know X*4 doesn't overflow.
- SCEVSDivExpr *&Result = SCEVSDivs[std::make_pair(LHS, RHS)];
+ SCEVSDivExpr *&Result = (*SCEVSDivs)[std::make_pair(LHS, RHS)];
if (Result == 0) Result = new SCEVSDivExpr(LHS, RHS);
return Result;
}
@@ -1040,8 +1043,8 @@
}
SCEVAddRecExpr *&Result =
- SCEVAddRecExprs[std::make_pair(L, std::vector<SCEV*>(Operands.begin(),
- Operands.end()))];
+ (*SCEVAddRecExprs)[std::make_pair(L, std::vector<SCEV*>(Operands.begin(),
+ Operands.end()))];
if (Result == 0) Result = new SCEVAddRecExpr(Operands, L);
return Result;
}
@@ -1049,7 +1052,7 @@
SCEVHandle SCEVUnknown::get(Value *V) {
if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
return SCEVConstant::get(CI);
- SCEVUnknown *&Result = SCEVUnknowns[V];
+ SCEVUnknown *&Result = (*SCEVUnknowns)[V];
if (Result == 0) Result = new SCEVUnknown(V);
return Result;
}
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
