RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-04-06 02:01:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Remove using declarations

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6306 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2003-05-22 22:00:07 +00:00
parent 01e770a9e5
commit de579f11ff
5 changed files with 36 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/Transforms/IPO/DeadTypeElimination.cpp
View File

@ -12,8 +12,6 @@
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "Support/Statistic.h" #include "Support/Statistic.h"
using std::vector;
namespace { namespace {
struct DTE : public Pass { struct DTE : public Pass {
// doPassInitialization - For this pass, it removes global symbol table // doPassInitialization - For this pass, it removes global symbol table

45
lib/Transforms/IPO/MutateStructTypes.cpp
View File

@ -15,18 +15,12 @@
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/SymbolTable.h" #include "llvm/SymbolTable.h"
#include "llvm/iPHINode.h" #include "llvm/Instructions.h"
#include "llvm/iMemory.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
#include "llvm/Constants.h" #include "llvm/Constants.h"
#include "Support/STLExtras.h" #include "Support/STLExtras.h"
#include "Support/Statistic.h" #include "Support/Statistic.h"
#include <algorithm> #include <algorithm>
using std::map;
using std::vector;
// ValuePlaceHolder - A stupid little marker value. It appears as an // ValuePlaceHolder - A stupid little marker value. It appears as an
// instruction of type Instruction::UserOp1. // instruction of type Instruction::UserOp1.
// //
@ -43,7 +37,7 @@ const Type *MutateStructTypes::ConvertType(const Type *Ty) {
if (Ty->isPrimitiveType() || if (Ty->isPrimitiveType() ||
isa<OpaqueType>(Ty)) return Ty; // Don't convert primitives isa<OpaqueType>(Ty)) return Ty; // Don't convert primitives
map<const Type *, PATypeHolder>::iterator I = TypeMap.find(Ty); std::map<const Type *, PATypeHolder>::iterator I = TypeMap.find(Ty);
if (I != TypeMap.end()) return I->second; if (I != TypeMap.end()) return I->second;
const Type *DestTy = 0; const Type *DestTy = 0;
@ -55,7 +49,7 @@ const Type *MutateStructTypes::ConvertType(const Type *Ty) {
case Type::FunctionTyID: { case Type::FunctionTyID: {
const FunctionType *MT = cast<FunctionType>(Ty); const FunctionType *MT = cast<FunctionType>(Ty);
const Type *RetTy = ConvertType(MT->getReturnType()); const Type *RetTy = ConvertType(MT->getReturnType());
vector<const Type*> ArgTypes; std::vector<const Type*> ArgTypes;
for (FunctionType::ParamTypes::const_iterator I = MT->getParamTypes().begin(), for (FunctionType::ParamTypes::const_iterator I = MT->getParamTypes().begin(),
E = MT->getParamTypes().end(); I != E; ++I) E = MT->getParamTypes().end(); I != E; ++I)
@ -67,7 +61,7 @@ const Type *MutateStructTypes::ConvertType(const Type *Ty) {
case Type::StructTyID: { case Type::StructTyID: {
const StructType *ST = cast<StructType>(Ty); const StructType *ST = cast<StructType>(Ty);
const StructType::ElementTypes &El = ST->getElementTypes(); const StructType::ElementTypes &El = ST->getElementTypes();
vector<const Type *> Types; std::vector<const Type *> Types;
for (StructType::ElementTypes::const_iterator I = El.begin(), E = El.end(); for (StructType::ElementTypes::const_iterator I = El.begin(), E = El.end();
I != E; ++I) I != E; ++I)
@ -103,7 +97,7 @@ const Type *MutateStructTypes::ConvertType(const Type *Ty) {
// using the specified OldTy as the base type being indexed into. // using the specified OldTy as the base type being indexed into.
// //
void MutateStructTypes::AdjustIndices(const CompositeType *OldTy, void MutateStructTypes::AdjustIndices(const CompositeType *OldTy,
vector<Value*> &Idx, std::vector<Value*> &Idx,
unsigned i) { unsigned i) {
assert(i < Idx.size() && "i out of range!"); assert(i < Idx.size() && "i out of range!");
const CompositeType *NewCT = cast<CompositeType>(ConvertType(OldTy)); const CompositeType *NewCT = cast<CompositeType>(ConvertType(OldTy));
@ -114,7 +108,8 @@ void MutateStructTypes::AdjustIndices(const CompositeType *OldTy,
unsigned ElNum = cast<ConstantUInt>(Idx[i])->getValue(); unsigned ElNum = cast<ConstantUInt>(Idx[i])->getValue();
assert(ElNum < OldST->getElementTypes().size()); assert(ElNum < OldST->getElementTypes().size());
map<const StructType*, TransformType>::iterator I = Transforms.find(OldST); std::map<const StructType*, TransformType>::iterator
I = Transforms.find(OldST);
if (I != Transforms.end()) { if (I != Transforms.end()) {
assert(ElNum < I->second.second.size()); assert(ElNum < I->second.second.size());
// Apply the XForm specified by Transforms map... // Apply the XForm specified by Transforms map...
@ -149,13 +144,13 @@ Value *MutateStructTypes::ConvertValue(const Value *V) {
// Check to see if this is an out of function reference first... // Check to see if this is an out of function reference first...
if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) { if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
// Check to see if the value is in the map... // Check to see if the value is in the map...
map<const GlobalValue*, GlobalValue*>::iterator I = GlobalMap.find(GV); std::map<const GlobalValue*, GlobalValue*>::iterator I = GlobalMap.find(GV);
if (I == GlobalMap.end()) if (I == GlobalMap.end())
return (Value*)GV; // Not mapped, just return value itself return (Value*)GV; // Not mapped, just return value itself
return I->second; return I->second;
} }
map<const Value*, Value*>::iterator I = LocalValueMap.find(V); std::map<const Value*, Value*>::iterator I = LocalValueMap.find(V);
if (I != LocalValueMap.end()) return I->second; if (I != LocalValueMap.end()) return I->second;
if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) { if (const BasicBlock *BB = dyn_cast<BasicBlock>(V)) {
@ -182,26 +177,26 @@ void MutateStructTypes::setTransforms(const TransformsType &XForm) {
// Loop over the types and insert dummy entries into the type map so that // Loop over the types and insert dummy entries into the type map so that
// recursive types are resolved properly... // recursive types are resolved properly...
for (map<const StructType*, vector<int> >::const_iterator I = XForm.begin(), for (std::map<const StructType*, std::vector<int> >::const_iterator
E = XForm.end(); I != E; ++I) { I = XForm.begin(), E = XForm.end(); I != E; ++I) {
const StructType *OldTy = I->first; const StructType *OldTy = I->first;
TypeMap.insert(std::make_pair(OldTy, OpaqueType::get())); TypeMap.insert(std::make_pair(OldTy, OpaqueType::get()));
} }
// Loop over the type specified and figure out what types they should become // Loop over the type specified and figure out what types they should become
for (map<const StructType*, vector<int> >::const_iterator I = XForm.begin(), for (std::map<const StructType*, std::vector<int> >::const_iterator
E = XForm.end(); I != E; ++I) { I = XForm.begin(), E = XForm.end(); I != E; ++I) {
const StructType *OldTy = I->first; const StructType *OldTy = I->first;
const vector<int> &InVec = I->second; const std::vector<int> &InVec = I->second;
assert(OldTy->getElementTypes().size() == InVec.size() && assert(OldTy->getElementTypes().size() == InVec.size() &&
"Action not specified for every element of structure type!"); "Action not specified for every element of structure type!");
vector<const Type *> NewType; std::vector<const Type *> NewType;
// Convert the elements of the type over, including the new position mapping // Convert the elements of the type over, including the new position mapping
int Idx = 0; int Idx = 0;
vector<int>::const_iterator TI = find(InVec.begin(), InVec.end(), Idx); std::vector<int>::const_iterator TI = find(InVec.begin(), InVec.end(), Idx);
while (TI != InVec.end()) { while (TI != InVec.end()) {
unsigned Offset = TI-InVec.begin(); unsigned Offset = TI-InVec.begin();
const Type *NewEl = ConvertType(OldTy->getContainedType(Offset)); const Type *NewEl = ConvertType(OldTy->getContainedType(Offset));
@ -308,7 +303,7 @@ void MutateStructTypes::removeDeadGlobals(Module &M) {
// //
void MutateStructTypes::transformFunction(Function *m) { void MutateStructTypes::transformFunction(Function *m) {
const Function *M = m; const Function *M = m;
map<const GlobalValue*, GlobalValue*>::iterator GMI = GlobalMap.find(M); std::map<const GlobalValue*, GlobalValue*>::iterator GMI = GlobalMap.find(M);
if (GMI == GlobalMap.end()) if (GMI == GlobalMap.end())
return; // Do not affect one of our new functions that we are creating return; // Do not affect one of our new functions that we are creating
@ -417,7 +412,7 @@ void MutateStructTypes::transformFunction(Function *m) {
break; break;
case Instruction::GetElementPtr: { case Instruction::GetElementPtr: {
const GetElementPtrInst &GEP = cast<GetElementPtrInst>(I); const GetElementPtrInst &GEP = cast<GetElementPtrInst>(I);
vector<Value*> Indices(GEP.idx_begin(), GEP.idx_end()); std::vector<Value*> Indices(GEP.idx_begin(), GEP.idx_end());
if (!Indices.empty()) { if (!Indices.empty()) {
const Type *PTy = const Type *PTy =
cast<PointerType>(GEP.getOperand(0)->getType())->getElementType(); cast<PointerType>(GEP.getOperand(0)->getType())->getElementType();
@ -444,7 +439,7 @@ void MutateStructTypes::transformFunction(Function *m) {
break; break;
case Instruction::Call: { case Instruction::Call: {
Value *Meth = ConvertValue(I.getOperand(0)); Value *Meth = ConvertValue(I.getOperand(0));
vector<Value*> Operands; std::vector<Value*> Operands;
for (unsigned i = 1; i < I.getNumOperands(); ++i) for (unsigned i = 1; i < I.getNumOperands(); ++i)
Operands.push_back(ConvertValue(I.getOperand(i))); Operands.push_back(ConvertValue(I.getOperand(i)));
NewI = new CallInst(Meth, Operands); NewI = new CallInst(Meth, Operands);
@ -460,7 +455,7 @@ void MutateStructTypes::transformFunction(Function *m) {
NewBB->getInstList().push_back(NewI); NewBB->getInstList().push_back(NewI);
// Check to see if we had to make a placeholder for this value... // Check to see if we had to make a placeholder for this value...
map<const Value*,Value*>::iterator LVMI = LocalValueMap.find(&I); std::map<const Value*,Value*>::iterator LVMI = LocalValueMap.find(&I);
if (LVMI != LocalValueMap.end()) { if (LVMI != LocalValueMap.end()) {
// Yup, make sure it's a placeholder... // Yup, make sure it's a placeholder...
Instruction *I = cast<Instruction>(LVMI->second); Instruction *I = cast<Instruction>(LVMI->second);

11
lib/Transforms/Instrumentation/EmitFunctions.cpp
View File

@ -9,8 +9,6 @@
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
using std::vector;
namespace { namespace {
struct EmitFunctionTable : public Pass { struct EmitFunctionTable : public Pass {
bool run(Module &M); bool run(Module &M);
@ -21,13 +19,12 @@ namespace {
// Per Module pass for inserting function table // Per Module pass for inserting function table
bool EmitFunctionTable::run(Module &M){ bool EmitFunctionTable::run(Module &M){
vector<const Type*> vType; std::vector<const Type*> vType;
vector<Constant *> vConsts; std::vector<Constant *> vConsts;
for(Module::iterator MI = M.begin(), ME = M.end(); MI!=ME; ++MI) for(Module::iterator MI = M.begin(), ME = M.end(); MI != ME; ++MI)
if (!MI->isExternal()) { if (!MI->isExternal()) {
ConstantPointerRef *CP = ConstantPointerRef::get(MI);
vType.push_back(MI->getType()); vType.push_back(MI->getType());
vConsts.push_back(CP); vConsts.push_back(ConstantPointerRef::get(MI));
} }
StructType *sttype = StructType::get(vType); StructType *sttype = StructType::get(vType);

20
lib/Transforms/Scalar/ADCE.cpp
View File

@ -19,8 +19,6 @@
#include "Support/DepthFirstIterator.h" #include "Support/DepthFirstIterator.h"
#include "Support/Statistic.h" #include "Support/Statistic.h"
#include <algorithm> #include <algorithm>
using std::cerr;
using std::vector;
namespace { namespace {
Statistic<> NumBlockRemoved("adce", "Number of basic blocks removed"); Statistic<> NumBlockRemoved("adce", "Number of basic blocks removed");
@ -77,13 +75,13 @@ private:
inline void markInstructionLive(Instruction *I) { inline void markInstructionLive(Instruction *I) {
if (LiveSet.count(I)) return; if (LiveSet.count(I)) return;
DEBUG(cerr << "Insn Live: " << I); DEBUG(std::cerr << "Insn Live: " << I);
LiveSet.insert(I); LiveSet.insert(I);
WorkList.push_back(I); WorkList.push_back(I);
} }
inline void markTerminatorLive(const BasicBlock *BB) { inline void markTerminatorLive(const BasicBlock *BB) {
DEBUG(cerr << "Terminat Live: " << BB->getTerminator()); DEBUG(std::cerr << "Terminat Live: " << BB->getTerminator());
markInstructionLive((Instruction*)BB->getTerminator()); markInstructionLive((Instruction*)BB->getTerminator());
} }
}; };
@ -168,7 +166,7 @@ bool ADCE::doADCE() {
} }
} }
DEBUG(cerr << "Processing work list\n"); DEBUG(std::cerr << "Processing work list\n");
// AliveBlocks - Set of basic blocks that we know have instructions that are // AliveBlocks - Set of basic blocks that we know have instructions that are
// alive in them... // alive in them...
@ -208,14 +206,14 @@ bool ADCE::doADCE() {
markInstructionLive(Operand); markInstructionLive(Operand);
} }
if (DebugFlag) { DEBUG(
cerr << "Current Function: X = Live\n"; std::cerr << "Current Function: X = Live\n";
for (Function::iterator I = Func->begin(), E = Func->end(); I != E; ++I) for (Function::iterator I = Func->begin(), E = Func->end(); I != E; ++I)
for (BasicBlock::iterator BI = I->begin(), BE = I->end(); BI != BE; ++BI){ for (BasicBlock::iterator BI = I->begin(), BE = I->end(); BI != BE; ++BI){
if (LiveSet.count(BI)) cerr << "X "; if (LiveSet.count(BI)) std::cerr << "X ";
cerr << *BI; std::cerr << *BI;
} }
} );
// Find the first postdominator of the entry node that is alive. Make it the // Find the first postdominator of the entry node that is alive. Make it the
// new entry node... // new entry node...
@ -346,7 +344,7 @@ bool ADCE::doADCE() {
if (!AliveBlocks.count(BB)) { if (!AliveBlocks.count(BB)) {
// Remove all outgoing edges from this basic block and convert the // Remove all outgoing edges from this basic block and convert the
// terminator into a return instruction. // terminator into a return instruction.
vector<BasicBlock*> Succs(succ_begin(BB), succ_end(BB)); std::vector<BasicBlock*> Succs(succ_begin(BB), succ_end(BB));
if (!Succs.empty()) { if (!Succs.empty()) {
// Loop over all of the successors, removing this block from PHI node // Loop over all of the successors, removing this block from PHI node

7
lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
View File

@ -14,7 +14,6 @@
#include "llvm/iTerminators.h" #include "llvm/iTerminators.h"
#include "llvm/iPHINode.h" #include "llvm/iPHINode.h"
#include "llvm/Type.h" #include "llvm/Type.h"
using std::vector;
static RegisterOpt<UnifyFunctionExitNodes> static RegisterOpt<UnifyFunctionExitNodes>
X("mergereturn", "Unify function exit nodes"); X("mergereturn", "Unify function exit nodes");
@ -34,7 +33,7 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
// Loop over all of the blocks in a function, tracking all of the blocks that // Loop over all of the blocks in a function, tracking all of the blocks that
// return. // return.
// //
vector<BasicBlock*> ReturningBlocks; std::vector<BasicBlock*> ReturningBlocks;
for(Function::iterator I = F.begin(), E = F.end(); I != E; ++I) for(Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
if (isa<ReturnInst>(I->getTerminator())) if (isa<ReturnInst>(I->getTerminator()))
ReturningBlocks.push_back(I); ReturningBlocks.push_back(I);
@ -67,8 +66,8 @@ bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
// Loop over all of the blocks, replacing the return instruction with an // Loop over all of the blocks, replacing the return instruction with an
// unconditional branch. // unconditional branch.
// //
for (vector<BasicBlock*>::iterator I = ReturningBlocks.begin(), for (std::vector<BasicBlock*>::iterator I = ReturningBlocks.begin(),
E = ReturningBlocks.end(); I != E; ++I) { E = ReturningBlocks.end(); I != E; ++I) {
BasicBlock *BB = *I; BasicBlock *BB = *I;
// Add an incoming element to the PHI node for every return instruction that // Add an incoming element to the PHI node for every return instruction that