diff options
57 files changed, 750 insertions, 788 deletions
diff --git a/include/llvm/Analysis/IntervalIterator.h b/include/llvm/Analysis/IntervalIterator.h index 3c27f1ae8b..55413d4ada 100644 --- a/include/llvm/Analysis/IntervalIterator.h +++ b/include/llvm/Analysis/IntervalIterator.h @@ -4,7 +4,7 @@ // graph of some sort. This iterator is parametric, allowing iterator over the // following types of graphs: // -// 1. A Method* object, composed of BasicBlock nodes. +// 1. A Function* object, composed of BasicBlock nodes. // 2. An IntervalPartition& object, composed of Interval nodes. // // This iterator is defined to walk the control flow graph, returning intervals @@ -27,7 +27,7 @@ #define LLVM_INTERVAL_ITERATOR_H #include "llvm/Analysis/IntervalPartition.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/BasicBlock.h" #include "llvm/Support/CFG.h" #include <stack> @@ -47,7 +47,7 @@ inline BasicBlock *getNodeHeader(Interval *I) { return I->getHeaderNode(); } // source graph node that corresponds to the BasicBlock. This is the opposite // of getNodeHeader. // -inline BasicBlock *getSourceGraphNode(Method *, BasicBlock *BB) { +inline BasicBlock *getSourceGraphNode(Function *, BasicBlock *BB) { return BB; } inline Interval *getSourceGraphNode(IntervalPartition *IP, BasicBlock *BB) { @@ -93,7 +93,7 @@ public: typedef std::forward_iterator_tag iterator_category; IntervalIterator() {} // End iterator, empty stack - IntervalIterator(Method *M, bool OwnMemory) : IOwnMem(OwnMemory) { + IntervalIterator(Function *M, bool OwnMemory) : IOwnMem(OwnMemory) { OrigContainer = M; if (!ProcessInterval(M->front())) { assert(0 && "ProcessInterval should never fail for first interval!"); @@ -227,16 +227,16 @@ private: } }; -typedef IntervalIterator<BasicBlock, Method> method_interval_iterator; +typedef IntervalIterator<BasicBlock, Function> function_interval_iterator; typedef IntervalIterator<Interval, IntervalPartition> interval_part_interval_iterator; -inline method_interval_iterator intervals_begin(Method *M, - bool DeleteInts = true) { - return method_interval_iterator(M, DeleteInts); +inline function_interval_iterator intervals_begin(Function *F, + bool DeleteInts = true) { + return function_interval_iterator(F, DeleteInts); } -inline method_interval_iterator intervals_end(Method *M) { - return method_interval_iterator(); +inline function_interval_iterator intervals_end(Function *) { + return function_interval_iterator(); } inline interval_part_interval_iterator diff --git a/include/llvm/Support/CFG.h b/include/llvm/Support/CFG.h index b6aa56e385..db4c0c322e 100644 --- a/include/llvm/Support/CFG.h +++ b/include/llvm/Support/CFG.h @@ -1,6 +1,6 @@ //===-- llvm/Support/CFG.h - Process LLVM structures as graphs ---*- C++ -*--=// // -// This file defines specializations of GraphTraits that allow Methods and +// This file defines specializations of GraphTraits that allow Function and // BasicBlock graphs to be treated as proper graphs for generic algorithms. // //===----------------------------------------------------------------------===// @@ -9,7 +9,7 @@ #define LLVM_CFG_H #include "Support/GraphTraits.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/BasicBlock.h" #include "llvm/InstrTypes.h" #include <iterator> @@ -137,7 +137,7 @@ inline succ_const_iterator succ_end(const BasicBlock *BB) { // GraphTraits specializations for basic block graphs (CFGs) //===--------------------------------------------------------------------===// -// Provide specializations of GraphTraits to be able to treat a method as a +// Provide specializations of GraphTraits to be able to treat a function as a // graph of basic blocks... template <> struct GraphTraits<BasicBlock*> { @@ -167,9 +167,9 @@ template <> struct GraphTraits<const BasicBlock*> { } }; -// Provide specializations of GraphTraits to be able to treat a method as a +// Provide specializations of GraphTraits to be able to treat a function as a // graph of basic blocks... and to walk it in inverse order. Inverse order for -// a method is considered to be when traversing the predecessor edges of a BB +// a function is considered to be when traversing the predecessor edges of a BB // instead of the successor edges. // template <> struct GraphTraits<Inverse<BasicBlock*> > { @@ -201,34 +201,36 @@ template <> struct GraphTraits<Inverse<const BasicBlock*> > { //===--------------------------------------------------------------------===// -// GraphTraits specializations for method basic block graphs (CFGs) +// GraphTraits specializations for function basic block graphs (CFGs) //===--------------------------------------------------------------------===// -// Provide specializations of GraphTraits to be able to treat a method as a +// Provide specializations of GraphTraits to be able to treat a function as a // graph of basic blocks... these are the same as the basic block iterators, -// except that the root node is implicitly the first node of the method. +// except that the root node is implicitly the first node of the function. // -template <> struct GraphTraits<Method*> : public GraphTraits<BasicBlock*> { - static NodeType *getEntryNode(Method *M) { return M->front(); } +template <> struct GraphTraits<Function*> : public GraphTraits<BasicBlock*> { + static NodeType *getEntryNode(Function *F) { return F->getEntryNode(); } }; -template <> struct GraphTraits<const Method*> : +template <> struct GraphTraits<const Function*> : public GraphTraits<const BasicBlock*> { - static NodeType *getEntryNode(const Method *M) { return M->front(); } + static NodeType *getEntryNode(const Function *F) { return F->getEntryNode(); } }; -// Provide specializations of GraphTraits to be able to treat a method as a +// Provide specializations of GraphTraits to be able to treat a function as a // graph of basic blocks... and to walk it in inverse order. Inverse order for -// a method is considered to be when traversing the predecessor edges of a BB +// a function is considered to be when traversing the predecessor edges of a BB // instead of the successor edges. // -template <> struct GraphTraits<Inverse<Method*> > : +template <> struct GraphTraits<Inverse<Function*> > : public GraphTraits<Inverse<BasicBlock*> > { - static NodeType *getEntryNode(Inverse<Method *> G) { return G.Graph->front();} + static NodeType *getEntryNode(Inverse<Function*> G) { + return G.Graph->front(); + } }; -template <> struct GraphTraits<Inverse<const Method*> > : +template <> struct GraphTraits<Inverse<const Function*> > : public GraphTraits<Inverse<const BasicBlock*> > { - static NodeType *getEntryNode(Inverse<const Method *> G) { + static NodeType *getEntryNode(Inverse<const Function *> G) { return G.Graph->front(); } }; diff --git a/include/llvm/Support/InstIterator.h b/include/llvm/Support/InstIterator.h index 517e6d26a4..b2b1058056 100644 --- a/include/llvm/Support/InstIterator.h +++ b/include/llvm/Support/InstIterator.h @@ -1,7 +1,7 @@ //===-- llvm/Support/InstIterator.h - Classes for inst iteration -*- C++ -*--=// // // This file contains definitions of two iterators for iterating over the -// instructions in a method. This is effectively a wrapper around a two level +// instructions in a function. This is effectively a wrapper around a two level // iterator that can probably be genericized later. // // Note that this iterator gets invalidated any time that basic blocks or @@ -13,7 +13,7 @@ #define LLVM_INST_ITERATOR_H #include "llvm/BasicBlock.h" -#include "llvm/Method.h" +#include "llvm/Function.h" // This class is implements inst_begin() & inst_end() for // inst_iterator and const_inst_iterator's. @@ -96,20 +96,21 @@ private: }; -typedef InstIterator<ValueHolder<BasicBlock, Method, Method>, Method::iterator, - BasicBlock::iterator, Instruction*> inst_iterator; -typedef InstIterator<const ValueHolder<BasicBlock, Method, Method>, - Method::const_iterator, +typedef InstIterator<ValueHolder<BasicBlock, Function, Function>, + Function::iterator, BasicBlock::iterator, + Instruction*> inst_iterator; +typedef InstIterator<const ValueHolder<BasicBlock, Function, Function>, + Function::const_iterator, BasicBlock::const_iterator, const Instruction*> const_inst_iterator; -inline inst_iterator inst_begin(Method *M) { return inst_iterator(*M); } -inline inst_iterator inst_end(Method *M) { return inst_iterator(*M, true); } -inline const_inst_iterator inst_begin(const Method *M) { - return const_inst_iterator(*M); +inline inst_iterator inst_begin(Function *F) { return inst_iterator(*F); } +inline inst_iterator inst_end(Function *F) { return inst_iterator(*F, true); } +inline const_inst_iterator inst_begin(const Function *F) { + return const_inst_iterator(*F); } -inline const_inst_iterator inst_end(const Method *M) { - return const_inst_iterator(*M, true); +inline const_inst_iterator inst_end(const Function *F) { + return const_inst_iterator(*F, true); } #endif diff --git a/include/llvm/Transforms/Scalar/DCE.h b/include/llvm/Transforms/Scalar/DCE.h index a8dcb59146..35b929d7e7 100644 --- a/include/llvm/Transforms/Scalar/DCE.h +++ b/include/llvm/Transforms/Scalar/DCE.h @@ -8,7 +8,7 @@ #ifndef LLVM_TRANSFORMS_SCALAR_DCE_H #define LLVM_TRANSFORMS_SCALAR_DCE_H -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/BasicBlock.h" class Pass; @@ -60,6 +60,6 @@ Pass *createAgressiveDCEPass(); // // WARNING: The entry node of a method may not be simplified. // -bool SimplifyCFG(Method::iterator &BBIt); +bool SimplifyCFG(Function::iterator &BBIt); #endif diff --git a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp index 0179cbb74c..d689d93cd4 100644 --- a/lib/Analysis/IPA/FindUnsafePointerTypes.cpp +++ b/lib/Analysis/IPA/FindUnsafePointerTypes.cpp @@ -1,4 +1,4 @@ -//===- SafePointerAccess.cpp - Check pointer usage safety -------------------=// +//===- FindUnsafePointerTypes.cpp - Check pointer usage safety --------------=// // // This file defines a pass that can be used to determine, interprocedurally, // which pointer types are accessed unsafely in a program. If there is an @@ -20,7 +20,7 @@ #include "llvm/Assembly/CachedWriter.h" #include "llvm/Type.h" #include "llvm/Instruction.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/Module.h" #include "llvm/Support/InstIterator.h" #include "Support/CommandLine.h" @@ -51,14 +51,10 @@ static inline bool isSafeInstruction(const Instruction *I) { } -// runOnMethod - Inspect the operations that the specified method does on -// values of various types. If they are deemed to be 'unsafe' note that the -// type is not safe to transform. -// bool FindUnsafePointerTypes::run(Module *Mod) { for (Module::iterator MI = Mod->begin(), ME = Mod->end(); MI != ME; ++MI) { - const Method *M = *MI; // We don't need/want write access + const Function *M = *MI; // We don't need/want write access for (const_inst_iterator I = inst_begin(M), E = inst_end(M); I != E; ++I) { const Instruction *Inst = *I; const Type *ITy = Inst->getType(); diff --git a/lib/Analysis/IPA/FindUsedTypes.cpp b/lib/Analysis/IPA/FindUsedTypes.cpp index e67fe322f7..5c961d2beb 100644 --- a/lib/Analysis/IPA/FindUsedTypes.cpp +++ b/lib/Analysis/IPA/FindUsedTypes.cpp @@ -1,4 +1,4 @@ -//===- FindUsedTypes.h - Find all Types used by a module --------------------=// +//===- FindUsedTypes.cpp - Find all Types used by a module ------------------=// // // This pass is used to seek out all of the types in use by the program. // @@ -10,7 +10,7 @@ #include "llvm/GlobalVariable.h" #include "llvm/DerivedTypes.h" #include "llvm/Module.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/Instruction.h" #include "llvm/Support/InstIterator.h" @@ -41,7 +41,7 @@ void FindUsedTypes::IncorporateSymbolTable(const SymbolTable *ST) { assert(0 && "Unimp"); } -// doPerMethodWork - This incorporates all types used by the specified method +// run - This incorporates all types used by the specified module // bool FindUsedTypes::run(Module *m) { UsedTypes.clear(); // reset if run multiple times... @@ -54,12 +54,12 @@ bool FindUsedTypes::run(Module *m) { IncorporateType((*I)->getType()); for (Module::iterator MI = m->begin(), ME = m->end(); MI != ME; ++MI) { - const Method *M = *MI; + const Function *M = *MI; if (IncludeSymbolTables && M->hasSymbolTable()) IncorporateSymbolTable(M->getSymbolTable()); // Add symtab first... - // Loop over all of the instructions in the method, adding their return type - // as well as the types of their operands. + // Loop over all of the instructions in the function, adding their return + // type as well as the types of their operands. // for (const_inst_iterator II = inst_begin(M), IE = inst_end(M); II != IE; ++II) { diff --git a/lib/Analysis/IntervalPartition.cpp b/lib/Analysis/IntervalPartition.cpp index f524d016f1..197bed26d7 100644 --- a/lib/Analysis/IntervalPartition.cpp +++ b/lib/Analysis/IntervalPartition.cpp @@ -1,7 +1,7 @@ //===- IntervalPartition.cpp - Interval Partition module code ----*- C++ -*--=// // // This file contains the definition of the cfg::IntervalPartition class, which -// calculates and represent the interval partition of a method. +// calculates and represent the interval partition of a function. // //===----------------------------------------------------------------------===// @@ -17,7 +17,7 @@ AnalysisID IntervalPartition::ID(AnalysisID::create<IntervalPartition>()); // IntervalPartition Implementation //===----------------------------------------------------------------------===// -// destroy - Reset state back to before method was analyzed +// destroy - Reset state back to before function was analyzed void IntervalPartition::destroy() { for_each(begin(), end(), deleter<cfg::Interval>); IntervalMap.clear(); @@ -50,14 +50,14 @@ void IntervalPartition::updatePredecessors(cfg::Interval *Int) { } // IntervalPartition ctor - Build the first level interval partition for the -// specified method... +// specified function... // -bool IntervalPartition::runOnMethod(Method *M) { +bool IntervalPartition::runOnMethod(Function *M) { assert(M->front() && "Cannot operate on prototypes!"); // Pass false to intervals_begin because we take ownership of it's memory - method_interval_iterator I = intervals_begin(M, false); - assert(I != intervals_end(M) && "No intervals in method!?!?!"); + function_interval_iterator I = intervals_begin(M, false); + assert(I != intervals_end(M) && "No intervals in function!?!?!"); addIntervalToPartition(RootInterval = *I); @@ -80,8 +80,8 @@ bool IntervalPartition::runOnMethod(Method *M) { // distinguish it from a copy constructor. Always pass in false for now. // IntervalPartition::IntervalPartition(IntervalPartition &IP, bool) { - Interval *MethodStart = IP.getRootInterval(); - assert(MethodStart && "Cannot operate on empty IntervalPartitions!"); + Interval *FunctionStart = IP.getRootInterval(); + assert(FunctionStart && "Cannot operate on empty IntervalPartitions!"); // Pass false to intervals_begin because we take ownership of it's memory interval_part_interval_iterator I = intervals_begin(IP, false); diff --git a/lib/Analysis/PostDominators.cpp b/lib/Analysis/PostDominators.cpp index 48cc86fcaf..71ee3d74cf 100644 --- a/lib/Analysis/PostDominators.cpp +++ b/lib/Analysis/PostDominators.cpp @@ -1,12 +1,13 @@ //===- DominatorSet.cpp - Dominator Set Calculation --------------*- C++ -*--=// // -// This file provides a simple class to calculate the dominator set of a method. +// This file provides a simple class to calculate the dominator set of a +// function. // //===----------------------------------------------------------------------===// #include "llvm/Analysis/Dominators.h" #include "llvm/Transforms/UnifyMethodExitNodes.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/Support/CFG.h" #include "Support/DepthFirstIterator.h" #include "Support/STLExtras.h" @@ -21,31 +22,31 @@ using std::set; AnalysisID cfg::DominatorSet::ID(AnalysisID::create<cfg::DominatorSet>()); AnalysisID cfg::DominatorSet::PostDomID(AnalysisID::create<cfg::DominatorSet>()); -bool cfg::DominatorSet::runOnMethod(Method *M) { +bool cfg::DominatorSet::runOnMethod(Function *F) { Doms.clear(); // Reset from the last time we were run... if (isPostDominator()) - calcPostDominatorSet(M); + calcPostDominatorSet(F); else - calcForwardDominatorSet(M); + calcForwardDominatorSet(F); return false; } // calcForwardDominatorSet - This method calculates the forward dominator sets -// for the specified method. +// for the specified function. // -void cfg::DominatorSet::calcForwardDominatorSet(Method *M) { +void cfg::DominatorSet::calcForwardDominatorSet(Function *M) { Root = M->getEntryNode(); assert(pred_begin(Root) == pred_end(Root) && - "Root node has predecessors in method!"); + "Root node has predecessors in function!"); bool Changed; do { Changed = false; DomSetType WorkingSet; - df_iterator<Method*> It = df_begin(M), End = df_end(M); + df_iterator<Function*> It = df_begin(M), End = df_end(M); for ( ; It != End; ++It) { const BasicBlock *BB = *It; pred_const_iterator PI = pred_begin(BB), PEnd = pred_end(BB); @@ -75,19 +76,19 @@ void cfg::DominatorSet::calcForwardDominatorSet(Method *M) { } while (Changed); } -// Postdominator set constructor. This ctor converts the specified method to +// Postdominator set constructor. This ctor converts the specified function to // only have a single exit node (return stmt), then calculates the post -// dominance sets for the method. +// dominance sets for the function. // -void cfg::DominatorSet::calcPostDominatorSet(Method *M) { +void cfg::DominatorSet::calcPostDominatorSet(Function *M) { // Since we require that the unify all exit nodes pass has been run, we know - // that there can be at most one return instruction in the method left. + // that there can be at most one return instruction in the function left. // Get it. // Root = getAnalysis<UnifyMethodExitNodes>().getExitNode(); - if (Root == 0) { // No exit node for the method? Postdomsets are all empty - for (Method::const_iterator MI = M->begin(), ME = M->end(); MI != ME; ++MI) + if (Root == 0) { // No exit node for the function? Postdomsets are all empty + for (Function::const_iterator MI = M->begin(), ME = M->end(); MI!=ME; ++MI) Doms[*MI] = DomSetType(); return; } @@ -207,12 +208,12 @@ void cfg::DominatorTree::reset() { // Given immediate dominators, we can also calculate the dominator tree cfg::DominatorTree::DominatorTree(const ImmediateDominators &IDoms) : DominatorBase(IDoms.getRoot()) { - const Method *M = Root->getParent(); + const Function *M = Root->getParent(); Nodes[Root] = new Node(Root, 0); // Add a node for the root... // Iterate over all nodes in depth first order... - for (df_iterator<const Method*> I = df_begin(M), E = df_end(M); I != E; ++I) { + for (df_iterator<const Function*> I = df_begin(M), E = df_end(M); I!=E; ++I) { const BasicBlock *BB = *I, *IDom = IDoms[*I]; if (IDom != 0) { // Ignore the root node and other nasty nodes @@ -249,7 +250,7 @@ void cfg::DominatorTree::calculate(const DominatorSet &DS) { // current node, and it is our idom! We know that we have already added // a DominatorTree node for our idom, because the idom must be a // predecessor in the depth first order that we are iterating through the - // method. + // function. // DominatorSet::DomSetType::const_iterator I = Dominators.begin(); DominatorSet::DomSetType::const_iterator End = Dominators.end(); @@ -290,7 +291,7 @@ void cfg::DominatorTree::calculate(const DominatorSet &DS) { // chain than the current node, and it is our idom! We know that we have // already added a DominatorTree node for our idom, because the idom must // be a predecessor in the depth first order that we are iterating through - // the method. + // the function. // DominatorSet::DomSetType::const_iterator I = Dominators.begin(); DominatorSet::DomSetType::const_iterator End = Dominators.end(); diff --git a/lib/Bytecode/Writer/InstructionWriter.cpp b/lib/Bytecode/Writer/InstructionWriter.cpp index 0be903aad0..c32c6b476f 100644 --- a/lib/Bytecode/Writer/InstructionWriter.cpp +++ b/lib/Bytecode/Writer/InstructionWriter.cpp @@ -11,7 +11,7 @@ #include "WriterInternals.h" #include "llvm/Module.h" -#include "llvm/Method.h" +#include "llvm/Function.h" #include "llvm/BasicBlock.h" #include "llvm/Instruction.h" #include "llvm/DerivedTypes.h" @@ -52,7 +52,7 @@ static void outputInstructionFormat0(const Instruction *I, } -// outputInstrVarArgsCall - Output the obsurdly annoying varargs method calls. +// outputInstrVarArgsCall - Output the obsurdly annoying varargs function calls. // This are more annoying than m |