Instead of using a bool that constant has to be explained, use a self

explanitory enum instead.

llvm-svn: 4600

llvm/include/llvm/Analysis/DSGraph.h

@@ -125,25 +125,30 @@ public:
   //
   void removeDeadNodes(bool KeepAllGlobals = false, bool KeepCalls = true);
 
+  enum AllocaBit {
+    StripAllocaBit,
+    KeepAllocaBit
+  };
+
   // cloneInto - Clone the specified DSGraph into the current graph, returning
   // the Return node of the graph.  The translated ScalarMap for the old
-  // function is filled into the OldValMap member.  If StripScalars
-  // (StripAllocas) is set to true, Scalar (Alloca) markers are removed from the
-  // graph as the graph is being cloned.
+  // function is filled into the OldValMap member.  If StripAllocas is set to
+  // 'StripAllocaBit', Alloca markers are removed from the graph as the graph is
+  // being cloned.
   //
   DSNodeHandle cloneInto(const DSGraph &G,
                          std::map<Value*, DSNodeHandle> &OldValMap,
                          std::map<const DSNode*, DSNode*> &OldNodeMap,
-                         bool StripAllocas = false);
+                         AllocaBit StripAllocas = KeepAllocaBit);
 
   /// mergeInGraph - The method is used for merging graphs together.  If the
   /// argument graph is not *this, it makes a clone of the specified graph, then
   /// merges the nodes specified in the call site with the formal arguments in
-  /// the graph.  If the StripAlloca's argument is true then Alloca markers are
-  /// removed from nodes.
+  /// the graph.  If the StripAlloca's argument is 'StripAllocaBit' then Alloca
+  /// markers are removed from nodes.
   ///
-  void mergeInGraph(DSCallSite &CS, const DSGraph &Graph, bool StripAllocas);
-
+  void mergeInGraph(DSCallSite &CS, const DSGraph &Graph,
+                    AllocaBit StripAllocas);
 
 #if 0
   // cloneGlobalInto - Clone the given global node (or the node for the given

llvm/lib/Analysis/DataStructure/BottomUpClosure.cpp

@@ -93,7 +93,7 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) {
             DEBUG(std::cerr << "\t[BU] Self Inlining: " << F.getName() << "\n");
 
             // Handle self recursion by resolving the arguments and return value
-            Graph->mergeInGraph(Call, *Graph, true);
+            Graph->mergeInGraph(Call, *Graph, DSGraph::StripAllocaBit);
 
             // Erase the entry in the callees vector
             Callees.erase(Callees.begin()+c--);
@@ -120,7 +120,7 @@ DSGraph &BUDataStructures::calculateGraph(Function &F) {
             CallSitesForFunc.back().setCallee(0);
 
             // Handle self recursion by resolving the arguments and return value
-            Graph->mergeInGraph(Call, GI, true);
+            Graph->mergeInGraph(Call, GI, DSGraph::StripAllocaBit);
 
             // Erase the entry in the Callees vector
             Callees.erase(Callees.begin()+c--);

llvm/lib/Analysis/DataStructure/DataStructure.cpp

@@ -526,7 +526,7 @@ void DSNode::remapLinks(std::map<const DSNode*, DSNode*> &OldNodeMap) {
 DSNodeHandle DSGraph::cloneInto(const DSGraph &G, 
                                 std::map<Value*, DSNodeHandle> &OldValMap,
                                 std::map<const DSNode*, DSNode*> &OldNodeMap,
-                                bool StripAllocas) {
+                                AllocaBit StripAllocas) {
   assert(OldNodeMap.empty() && "Returned OldNodeMap should be empty!");
 
   unsigned FN = Nodes.size();           // First new node...
@@ -544,11 +544,10 @@ DSNodeHandle DSGraph::cloneInto(const DSGraph &G,
   for (unsigned i = FN, e = Nodes.size(); i != e; ++i)
     Nodes[i]->remapLinks(OldNodeMap);
 
-  // Remove local markers as specified
-  unsigned char StripBits = StripAllocas ? DSNode::AllocaNode : 0;
-  if (StripBits)
+  // Remove alloca markers as specified
+  if (StripAllocas == StripAllocaBit)
     for (unsigned i = FN, e = Nodes.size(); i != e; ++i)
-      Nodes[i]->NodeType &= ~StripBits;
+      Nodes[i]->NodeType &= ~DSNode::AllocaNode;
 
   // Copy the value map... and merge all of the global nodes...
   for (std::map<Value*, DSNodeHandle>::const_iterator I = G.ScalarMap.begin(),
@@ -580,7 +579,7 @@ DSNodeHandle DSGraph::cloneInto(const DSGraph &G,
 /// graph.
 ///
 void DSGraph::mergeInGraph(DSCallSite &CS, const DSGraph &Graph,
-                           bool StripAllocas) {
+                           AllocaBit StripAllocas) {
   std::map<Value*, DSNodeHandle> OldValMap;
   DSNodeHandle RetVal;
   std::map<Value*, DSNodeHandle> *ScalarMap = &OldValMap;

llvm/lib/Analysis/DataStructure/TopDownClosure.cpp

@@ -177,7 +177,7 @@ DSGraph &TDDataStructures::calculateGraph(Function &F) {
     // Strip scalars but not allocas since they are alive in callee.
     // 
     DSNodeHandle RetVal = Graph->cloneInto(CG, OldValMap, OldNodeMap,
-                                           /*StripAllocas*/ false);
+                                           DSGraph::KeepAllocaBit);
     ResolveCallSite(*Graph, DSCallSite(CallSiteInCG, OldNodeMap));
   }