Rename createSimpleX86RegisterAllocator to createSimpleRegisterAllocator.

[oota-llvm.git] / lib / VMCore / SlotCalculator.cpp

diff --git a/lib/VMCore/SlotCalculator.cpp b/lib/VMCore/SlotCalculator.cpp
index f0a549e81cc8d6e5a2e8bde0e908ec03ffe8ff79..5f6f2e78359d27246afe927e3769d6b155ae489b 100644 (file)
--- a/lib/VMCore/SlotCalculator.cpp
+++ b/lib/VMCore/SlotCalculator.cpp
@@ -70,10 +70,9 @@ void SlotCalculator::processModule() {
   // Add all of the constants that the global variables might refer to first.
   //
   for (Module::const_giterator I = TheModule->gbegin(), E = TheModule->gend();
-       I != E; ++I) {
+       I != E; ++I)
     if (I->hasInitializer())
       insertValue(I->getInitializer());
-  }
 
   // Add all of the global variables to the value table...
   //
@@ -91,9 +90,9 @@ void SlotCalculator::processModule() {
   // Insert constants that are named at module level into the slot pool so that
   // the module symbol table can refer to them...
   //
-  if (TheModule->hasSymbolTable() && !IgnoreNamedNodes) {
+  if (!IgnoreNamedNodes) {
     SC_DEBUG("Inserting SymbolTable values:\n");
-    processSymbolTable(TheModule->getSymbolTable());
+    processSymbolTable(&TheModule->getSymbolTable());
   }
 
   SC_DEBUG("end processModule!\n");
@@ -157,8 +156,7 @@ void SlotCalculator::incorporateFunction(const Function *M) {
     // symboltable references to constants not in the output.  Scan for these
     // constants now.
     //
-    if (M->hasSymbolTable())
-      processSymbolTableConstants(M->getSymbolTable());
+    processSymbolTableConstants(&M->getSymbolTable());
   }
 
   SC_DEBUG("Inserting Labels:\n");
@@ -175,9 +173,9 @@ void SlotCalculator::incorporateFunction(const Function *M) {
   for_each(inst_begin(M), inst_end(M),
           bind_obj(this, &SlotCalculator::insertValue));
 
-  if (M->hasSymbolTable() && !IgnoreNamedNodes) {
+  if (!IgnoreNamedNodes) {
     SC_DEBUG("Inserting SymbolTable values:\n");
-    processSymbolTable(M->getSymbolTable());
+    processSymbolTable(&M->getSymbolTable());
   }
 
   SC_DEBUG("end processFunction!\n");
@@ -193,7 +191,7 @@ void SlotCalculator::purgeFunction() {
   for (unsigned i = 0; i < NumModuleTypes; ++i) {
     unsigned ModuleSize = ModuleLevel[i];  // Size of plane before function came
     TypePlane &CurPlane = Table[i];
-    //SC_DEBUG("Processing Plane " <<i<< " of size " << CurPlane.size() <<endl);
+    //SC_DEBUG("Processing Plane " <<i<< " of size " << CurPlane.size() <<"\n");
             
     while (CurPlane.size() != ModuleSize) {
       //SC_DEBUG("  Removing [" << i << "] Value=" << CurPlane.back() << "\n");
@@ -212,7 +210,7 @@ void SlotCalculator::purgeFunction() {
   while (NumModuleTypes != Table.size()) {
     TypePlane &Plane = Table.back();
     SC_DEBUG("Removing Plane " << (Table.size()-1) << " of size "
-            << Plane.size() << endl);
+            << Plane.size() << "\n");
     while (Plane.size()) {
       NodeMap.erase(NodeMap.find(Plane.back()));   // Erase from nodemap
       Plane.pop_back();                            // Shrink plane
@@ -240,7 +238,7 @@ int SlotCalculator::insertValue(const Value *D) {
     // initializers.
     //
     for(User::const_op_iterator I = U->op_begin(), E = U->op_end(); I != E; ++I)
-      if (!isa<GlobalValue>(*I))  // Don't chain insert global values
+      if (!isa<GlobalValue>(*I))     // Don't chain insert global values
        insertValue(*I);
   }
 
@@ -262,7 +260,7 @@ int SlotCalculator::insertVal(const Value *D, bool dontIgnore) {
     if (D->getType() == Type::VoidTy ||          // Ignore void type nodes
        (IgnoreNamedNodes &&                     // Ignore named and constants
         (D->hasName() || isa<Constant>(D)) && !isa<Type>(D))) {
-      SC_DEBUG("ignored value " << D << endl);
+      SC_DEBUG("ignored value " << D << "\n");
       return -1;                  // We do need types unconditionally though
     }
 
@@ -279,7 +277,7 @@ int SlotCalculator::insertVal(const Value *D, bool dontIgnore) {
     if ((ResultSlot = getValSlot(TheTy)) == -1) {
       ResultSlot = doInsertVal(TheTy);
       SC_DEBUG("  Inserted type: " << TheTy->getDescription() << " slot=" <<
-              ResultSlot << endl);
+              ResultSlot << "\n");
     }
 
     // Loop over any contained types in the definition... in reverse depth first
@@ -293,10 +291,10 @@ int SlotCalculator::insertVal(const Value *D, bool dontIgnore) {
        // If we haven't seen this sub type before, add it to our type table!
        const Type *SubTy = *I;
        if (getValSlot(SubTy) == -1) {
-         SC_DEBUG("  Inserting subtype: " << SubTy->getDescription() << endl);
+         SC_DEBUG("  Inserting subtype: " << SubTy->getDescription() << "\n");
          int Slot = doInsertVal(SubTy);
          SC_DEBUG("  Inserted subtype: " << SubTy->getDescription() << 
-                  " slot=" << Slot << endl);
+                  " slot=" << Slot << "\n");
        }
       }
     return ResultSlot;