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

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

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

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

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

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

include/llvm/Analysis/LoopInfo.h

@@ -13,7 +13,6 @@
 #include "llvm/Pass.h"
 #include <set>
 
-namespace cfg {
 class DominatorSet;
 class LoopInfo;
 
@@ -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

include/llvm/Analysis/Writer.h

@@ -10,8 +10,6 @@
 
 #include <iosfwd>
 
-namespace cfg {
-
 // This library provides support for printing out Intervals.
 class Interval;
 class IntervalPartition;
@@ -69,8 +67,6 @@ namespace cfg {
   WriteToOutput(L, o); return o;
 }
 
-}  // End namespace CFG
-
 class InductionVariable;
 void WriteToOutput(const InductionVariable &, std::ostream &o);
 inline std::ostream &operator <<(std::ostream &o, const InductionVariable &IV) {

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);
 

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:
@@ -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

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:
@@ -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