Remove all contents of the cfg namespace to the global namespace

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2369 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Analysis/Dominators.h b/include/llvm/Analysis/Dominators.h
index 437a4fc1f3ac0b4b44ea7981c7130c72da1187cf..3a29eec6c887bb1a0770ee0402a28296fbcca3c8 100644 (file)
--- a/include/llvm/Analysis/Dominators.h
+++ b/include/llvm/Analysis/Dominators.h
@@ -21,8 +21,6 @@
 #include "llvm/Pass.h"
 #include <set>
 
-namespace cfg {
-
 //===----------------------------------------------------------------------===//
 //
 // DominatorBase - Base class that other, more interesting dominator analyses
@@ -301,6 +299,4 @@ public:
   }
 };
 
-} // End namespace cfg
-
 #endif

diff --git a/include/llvm/Analysis/InductionVariable.h b/include/llvm/Analysis/InductionVariable.h
index 51399550b431a8938365fe00cfe8dce6de077ac6..951ac05135214ffc2f54dbf81ea5ad82e68a7ec6 100644 (file)
--- a/include/llvm/Analysis/InductionVariable.h
+++ b/include/llvm/Analysis/InductionVariable.h
@@ -22,7 +22,7 @@
 class Value;
 class PHINode;
 class Instruction;
-namespace cfg { class LoopInfo; class Loop; }
+class LoopInfo; class Loop;
 
 class InductionVariable {
 public:
@@ -40,11 +40,11 @@ public:
   // Create an induction variable for the specified value.  If it is a PHI, and
   // if it's recognizable, classify it and fill in instance variables.
   //
-  InductionVariable(PHINode *PN, cfg::LoopInfo *LoopInfo = 0);
+  InductionVariable(PHINode *PN, LoopInfo *LoopInfo = 0);
 
   // Classify Induction
   static enum iType Classify(const Value *Start, const Value *Step,
-                            const cfg::Loop *L = 0);
+                            const Loop *L = 0);
 };
 
 #endif

diff --git a/include/llvm/Analysis/Interval.h b/include/llvm/Analysis/Interval.h
index 5fdb71dc38ade5cb47b64935f3fd23677044cab2..b297441ecae8574c8d2582cff08b3da53a6e0dea 100644 (file)
--- a/include/llvm/Analysis/Interval.h
+++ b/include/llvm/Analysis/Interval.h
@@ -1,6 +1,6 @@
 //===- llvm/Analysis/Interval.h - Interval Class Declaration -----*- C++ -*--=//
 //
-// This file contains the declaration of the cfg::Interval class, which
+// This file contains the declaration of the Interval class, which
 // represents a set of CFG nodes and is a portion of an interval partition.
 // 
 // Intervals have some interesting and useful properties, including the
@@ -17,8 +17,6 @@
 
 class BasicBlock;
 
-namespace cfg {
-
 //===----------------------------------------------------------------------===//
 //
 // Interval Class - An Interval is a set of nodes defined such that every node
@@ -89,27 +87,24 @@ public:
   bool isLoop() const;
 };
 
-}    // End namespace cfg
-
 // succ_begin/succ_end - define methods so that Intervals may be used
 // just like BasicBlocks can with the succ_* functions, and *::succ_iterator.
 //
-inline cfg::Interval::succ_iterator succ_begin(cfg::Interval *I) {
+inline Interval::succ_iterator succ_begin(Interval *I) {
   return I->Successors.begin();
 }
-inline cfg::Interval::succ_iterator succ_end(cfg::Interval *I)   {
+inline Interval::succ_iterator succ_end(Interval *I)   {
   return I->Successors.end();
 }
   
 // pred_begin/pred_end - define methods so that Intervals may be used
 // just like BasicBlocks can with the pred_* functions, and *::pred_iterator.
 //
-inline cfg::Interval::pred_iterator pred_begin(cfg::Interval *I) {
+inline Interval::pred_iterator pred_begin(Interval *I) {
   return I->Predecessors.begin();
 }
-inline cfg::Interval::pred_iterator pred_end(cfg::Interval *I)   {
+inline Interval::pred_iterator pred_end(Interval *I)   {
   return I->Predecessors.end();
 }
 
-
 #endif

diff --git a/include/llvm/Analysis/IntervalIterator.h b/include/llvm/Analysis/IntervalIterator.h
index 55413d4ada494131e4b44b2513119e349834c291..64c1b60b074893587f02f5c80c941dc9944bc64d 100644 (file)
--- a/include/llvm/Analysis/IntervalIterator.h
+++ b/include/llvm/Analysis/IntervalIterator.h
@@ -34,8 +34,6 @@
 #include <set>
 #include <algorithm>
 
-namespace cfg {
-
 // getNodeHeader - Given a source graph node and the source graph, return the 
 // BasicBlock that is the header node.  This is the opposite of
 // getSourceGraphNode.
@@ -248,6 +246,4 @@ inline interval_part_interval_iterator intervals_end(IntervalPartition &IP) {
   return interval_part_interval_iterator();
 }
 
-}    // End namespace cfg
-
 #endif

diff --git a/include/llvm/Analysis/IntervalPartition.h b/include/llvm/Analysis/IntervalPartition.h
index d31b5fd7506c54f02d2632378569c932f4cfc03c..281b32ed0e85c753140cafcbb82764755b1eed73 100644 (file)
--- a/include/llvm/Analysis/IntervalPartition.h
+++ b/include/llvm/Analysis/IntervalPartition.h
@@ -1,6 +1,6 @@
 //===- IntervalPartition.h - Interval partition Calculation ------*- C++ -*--=//
 //
-// This file contains the declaration of the cfg::IntervalPartition class, which
+// This file contains the declaration of the IntervalPartition class, which
 // calculates and represents the interval partition of a function, or a
 // preexisting interval partition.
 //
@@ -19,8 +19,6 @@
 #include "llvm/Analysis/Interval.h"
 #include "llvm/Pass.h"
 
-namespace cfg {
-
 //===----------------------------------------------------------------------===//
 //
 // IntervalPartition - This class builds and holds an "interval partition" for
@@ -93,6 +91,4 @@ private:
   void updatePredecessors(Interval *Int);
 };
 
-}    // End namespace cfg
-
 #endif

diff --git a/include/llvm/Analysis/LoopInfo.h b/include/llvm/Analysis/LoopInfo.h
index edbd55df406871a2c02cc5625d82059f834fa6e2..b56de0f80699dc1b98a2ba0b2e952ea4df2c5e42 100644 (file)
--- a/include/llvm/Analysis/LoopInfo.h
+++ b/include/llvm/Analysis/LoopInfo.h
@@ -13,9 +13,8 @@
 #include "llvm/Pass.h"
 #include <set>
 
-namespace cfg {
-  class DominatorSet;
-  class LoopInfo;
+class DominatorSet;
+class LoopInfo;
 
 //===----------------------------------------------------------------------===//
 // Loop class - Instances of this class are used to represent loops that are 
@@ -67,7 +66,7 @@ class LoopInfo : public FunctionPass {
   std::map<BasicBlock*, Loop*> BBMap;
   std::vector<Loop*> TopLevelLoops;
 public:
-  static AnalysisID ID;            // cfg::LoopInfo Analysis ID 
+  static AnalysisID ID;            // LoopInfo Analysis ID 
 
   // LoopInfo ctor - Calculate the natural loop information for a CFG
   LoopInfo(AnalysisID id) { assert(id == ID); }
@@ -117,6 +116,4 @@ private:
   Loop *ConsiderForLoop(BasicBlock *BB, const DominatorSet &DS);
 };
 
-}  // End namespace cfg
-
 #endif

diff --git a/include/llvm/Analysis/Writer.h b/include/llvm/Analysis/Writer.h
index 1b8ebe8d6ac47ee3619baf6f501a6d800063879d..2ecc22696b22308833f3f162f891812daf313a6e 100644 (file)
--- a/include/llvm/Analysis/Writer.h
+++ b/include/llvm/Analysis/Writer.h
@@ -10,66 +10,62 @@
 
 #include <iosfwd>
 
-namespace cfg {
+// This library provides support for printing out Intervals.
+class Interval;
+class IntervalPartition;
 
-  // This library provides support for printing out Intervals.
-  class Interval;
-  class IntervalPartition;
+void WriteToOutput(const Interval *I, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o, const Interval *I) {
+  WriteToOutput(I, o); return o;
+}
 
-  void WriteToOutput(const Interval *I, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o, const Interval *I) {
-    WriteToOutput(I, o); return o;
-  }
+void WriteToOutput(const IntervalPartition &IP, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o,
+                                 const IntervalPartition &IP) {
+  WriteToOutput(IP, o); return o;
+}
 
-  void WriteToOutput(const IntervalPartition &IP, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o,
-                                   const IntervalPartition &IP) {
-    WriteToOutput(IP, o); return o;
-  }
+// Stuff for printing out Dominator data structures...
+class DominatorSet;
+class ImmediateDominators;
+class DominatorTree;
+class DominanceFrontier;
 
-  // Stuff for printing out Dominator data structures...
-  class DominatorSet;
-  class ImmediateDominators;
-  class DominatorTree;
-  class DominanceFrontier;
+void WriteToOutput(const DominatorSet &, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o, const DominatorSet &DS) {
+  WriteToOutput(DS, o); return o;
+}
 
-  void WriteToOutput(const DominatorSet &, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o, const DominatorSet &DS) {
-    WriteToOutput(DS, o); return o;
-  }
+void WriteToOutput(const ImmediateDominators &, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o,
+                                 const ImmediateDominators &ID) {
+  WriteToOutput(ID, o); return o;
+}
 
-  void WriteToOutput(const ImmediateDominators &, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o,
-                                   const ImmediateDominators &ID) {
-    WriteToOutput(ID, o); return o;
-  }
+void WriteToOutput(const DominatorTree &, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o, const DominatorTree &DT) {
+  WriteToOutput(DT, o); return o;
+}
 
-  void WriteToOutput(const DominatorTree &, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o, const DominatorTree &DT) {
-    WriteToOutput(DT, o); return o;
-  }
+void WriteToOutput(const DominanceFrontier &, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o,
+                                 const DominanceFrontier &DF) {
+  WriteToOutput(DF, o); return o;
+}
 
-  void WriteToOutput(const DominanceFrontier &, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o,
-                                   const DominanceFrontier &DF) {
-    WriteToOutput(DF, o); return o;
-  }
+// Stuff for printing out Loop information
+class Loop;
+class LoopInfo;
 
-  // Stuff for printing out Loop information
-  class Loop;
-  class LoopInfo;
+void WriteToOutput(const LoopInfo &, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o, const LoopInfo &LI) {
+  WriteToOutput(LI, o); return o;
+}
 
-  void WriteToOutput(const LoopInfo &, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o, const LoopInfo &LI) {
-    WriteToOutput(LI, o); return o;
-  }
-  
-  void WriteToOutput(const Loop *, std::ostream &o);
-  inline std::ostream &operator <<(std::ostream &o, const Loop *L) {
-    WriteToOutput(L, o); return o;
-  }
-  
-}  // End namespace CFG
+void WriteToOutput(const Loop *, std::ostream &o);
+inline std::ostream &operator <<(std::ostream &o, const Loop *L) {
+  WriteToOutput(L, o); return o;
+}
 
 class InductionVariable;
 void WriteToOutput(const InductionVariable &, std::ostream &o);

diff --git a/include/llvm/Transforms/Scalar/InductionVars.h b/include/llvm/Transforms/Scalar/InductionVars.h
index b8d951bb2b5954278d0e005ffe3ad6297ff5bfa1..196bb1f10a22bf1e1bb45092ac1d23e3a2d51a5a 100644 (file)
--- a/include/llvm/Transforms/Scalar/InductionVars.h
+++ b/include/llvm/Transforms/Scalar/InductionVars.h
@@ -9,12 +9,12 @@
 #define LLVM_OPT_INDUCTION_VARS_H
 
 #include "llvm/Pass.h"
-namespace cfg { class IntervalPartition; }
+class IntervalPartition;
 
 struct InductionVariableCannonicalize : public FunctionPass {
   // doInductionVariableCannonicalize - Simplify induction variables in loops
   //
-  static bool doIt(Function *F, cfg::IntervalPartition &IP);
+  static bool doIt(Function *F, IntervalPartition &IP);
 
   virtual bool runOnFunction(Function *F);
 

diff --git a/lib/CodeGen/RegAlloc/PhyRegAlloc.h b/lib/CodeGen/RegAlloc/PhyRegAlloc.h
index 5cc01c67650da5795ba39b4b7446d75841fb45f1..3c4f98a8b959749d135f6fd893779739e7d63d1d 100644 (file)
--- a/lib/CodeGen/RegAlloc/PhyRegAlloc.h
+++ b/lib/CodeGen/RegAlloc/PhyRegAlloc.h
@@ -37,7 +37,7 @@ class MachineCodeForMethod;
 class MachineRegInfo;
 class FunctionLiveVarInfo;
 class MachineInstr;
-namespace cfg { class LoopInfo; }
+class LoopInfo;
 
 //----------------------------------------------------------------------------
 // Class AddedInstrns:
@@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable {
   const TargetMachine &TM;              // target machine
   const Function *Meth;                 // name of the function we work on
   MachineCodeForMethod &mcInfo;         // descriptor for method's native code
-  FunctionLiveVarInfo *const LVI;         // LV information for this method 
+  FunctionLiveVarInfo *const LVI;       // LV information for this method 
                                         // (already computed for BBs) 
   LiveRangeInfo LRI;                    // LR info  (will be computed)
   const MachineRegInfo &MRI;            // Machine Register information
@@ -79,13 +79,13 @@ class PhyRegAlloc: public NonCopyable {
   
   AddedInstrMapType AddedInstrMap;      // to store instrns added in this phase
   AddedInstrns AddedInstrAtEntry;       // to store instrns added at entry
-  cfg::LoopInfo *LoopDepthCalc;         // to calculate loop depths 
+  LoopInfo *LoopDepthCalc;              // to calculate loop depths 
   ReservedColorListType ResColList;     // A set of reserved regs if desired.
                                         // currently not used
 
 public:
   PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi,
-              cfg::LoopInfo *LoopDepthCalc);
+              LoopInfo *LoopDepthCalc);
   ~PhyRegAlloc();
 
   // main method called for allocating registers

diff --git a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
index 5cc01c67650da5795ba39b4b7446d75841fb45f1..3c4f98a8b959749d135f6fd893779739e7d63d1d 100644 (file)
--- a/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
+++ b/lib/Target/SparcV9/RegAlloc/PhyRegAlloc.h
@@ -37,7 +37,7 @@ class MachineCodeForMethod;
 class MachineRegInfo;
 class FunctionLiveVarInfo;
 class MachineInstr;
-namespace cfg { class LoopInfo; }
+class LoopInfo;
 
 //----------------------------------------------------------------------------
 // Class AddedInstrns:
@@ -70,7 +70,7 @@ class PhyRegAlloc: public NonCopyable {
   const TargetMachine &TM;              // target machine
   const Function *Meth;                 // name of the function we work on
   MachineCodeForMethod &mcInfo;         // descriptor for method's native code
-  FunctionLiveVarInfo *const LVI;         // LV information for this method 
+  FunctionLiveVarInfo *const LVI;       // LV information for this method 
                                         // (already computed for BBs) 
   LiveRangeInfo LRI;                    // LR info  (will be computed)
   const MachineRegInfo &MRI;            // Machine Register information
@@ -79,13 +79,13 @@ class PhyRegAlloc: public NonCopyable {
   
   AddedInstrMapType AddedInstrMap;      // to store instrns added in this phase
   AddedInstrns AddedInstrAtEntry;       // to store instrns added at entry
-  cfg::LoopInfo *LoopDepthCalc;         // to calculate loop depths 
+  LoopInfo *LoopDepthCalc;              // to calculate loop depths 
   ReservedColorListType ResColList;     // A set of reserved regs if desired.
                                         // currently not used
 
 public:
   PhyRegAlloc(Function *F, const TargetMachine& TM, FunctionLiveVarInfo *Lvi,
-              cfg::LoopInfo *LoopDepthCalc);
+              LoopInfo *LoopDepthCalc);
   ~PhyRegAlloc();
 
   // main method called for allocating registers