fix cpp11 compile errors

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 285 matching lines @@
                                       Instruction* replacement,
                                       FlowGraph* graph) {
   Definition* current_defn = current->AsDefinition();
   if ((replacement != NULL) && (current_defn != NULL)) {
     Definition* replacement_defn = replacement->AsDefinition();
     ASSERT(replacement_defn != NULL);
     current_defn->ReplaceUsesWith(replacement_defn);
     EnsureSSATempIndex(graph, current_defn, replacement_defn);
 
     if (FLAG_trace_optimization) {
-      OS::Print("Replacing v%"Pd" with v%"Pd"\n",
+      OS::Print("Replacing v%" Pd " with v%" Pd "\n",
                 current_defn->ssa_temp_index(),
                 replacement_defn->ssa_temp_index());
     }
   } else if (FLAG_trace_optimization) {
     if (current_defn == NULL) {
       OS::Print("Removing %s\n", current->DebugName());
     } else {
       ASSERT(!current_defn->HasUses());
-      OS::Print("Removing v%"Pd".\n", current_defn->ssa_temp_index());
+      OS::Print("Removing v%" Pd ".\n", current_defn->ssa_temp_index());
     }
   }
   iterator->RemoveCurrentFromGraph();
 }
 
 
 bool FlowGraphOptimizer::Canonicalize() {
   bool changed = false;
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     BlockEntryInstr* entry = block_order_[i];
@@ skipping 3492 matching lines @@
   ASSERT(flow_graph->is_licm_allowed());
 }
 
 
 void LICM::Hoist(ForwardInstructionIterator* it,
                  BlockEntryInstr* pre_header,
                  Instruction* current) {
   // TODO(fschneider): Avoid repeated deoptimization when
   // speculatively hoisting checks.
   if (FLAG_trace_optimization) {
-    OS::Print("Hoisting instruction %s:%"Pd" from B%"Pd" to B%"Pd"\n",
+    OS::Print("Hoisting instruction %s:%" Pd " from B%" Pd " to B%" Pd "\n",
               current->DebugName(),
               current->GetDeoptId(),
               current->GetBlock()->block_id(),
               pre_header->block_id());
   }
   // Move the instruction out of the loop.
   current->RemoveEnvironment();
   it->RemoveCurrentFromGraph();
   GotoInstr* last = pre_header->last_instruction()->AsGoto();
   // Using kind kEffect will not assign a fresh ssa temporary index.
@@ skipping 328 matching lines @@
     switch (kind_) {
       case kNone:
         return "<none>";
 
       case kField: {
         const char* field_name = String::Handle(field().name()).ToCString();
         if (instance() == NULL) {
           return field_name;
         }
         return Isolate::Current()->current_zone()->PrintToString(
-            "<v%"Pd".%s>", instance()->ssa_temp_index(), field_name);
+            "<v%" Pd ".%s>", instance()->ssa_temp_index(), field_name);
       }
 
       case kVMField: {
         return Isolate::Current()->current_zone()->PrintToString(
-            "<v%"Pd"@%"Pd">", instance()->ssa_temp_index(), offset_in_bytes());
+            "<v%" Pd "@%" Pd ">", instance()->ssa_temp_index(), offset_in_bytes());

[siva, 2013/08/20 19:54:51]

"<v%" Pd "@%" Pd ">",
instance()->ssa_temp_index(), offset_in_bytes());

[Jacob, 2013/08/20 20:32:15]

Done.

       }
 
       case kIndexed: {
         return Isolate::Current()->current_zone()->PrintToString(
-            "<v%"Pd"[v%"Pd"]>",
+            "<v%" Pd "[v%" Pd "]>",
             instance()->ssa_temp_index(),
             index()->ssa_temp_index());
       }
 
       case kContext:
         return "<context>";
     }
     UNREACHABLE();
     return "<?>";
   }
@@ skipping 434 matching lines @@
       for (intptr_t j = 0; j < phi->InputCount(); j++) {
         input_place.set_instance(phi->InputAt(j)->definition());
 
         Place* result = map->Lookup(&input_place);
         if (result == NULL) {
           input_place.set_id(places->length());
           result = Place::Wrap(input_place);
           map->Insert(result);
           places->Add(result);
           if (FLAG_trace_optimization) {
-            OS::Print("  adding place %s as %"Pd"\n",
+            OS::Print("  adding place %s as %" Pd "\n",
                       result->ToCString(),
                       result->id());
           }
         }
 
         phi_moves->CreateOutgoingMove(block->PredecessorAt(j),
                                       result->id(),
                                       place->id());
       }
     }
@@ skipping 25 matching lines @@
       }
 
       Place* result = map->Lookup(&place);
       if (result == NULL) {
         place.set_id(places->length());
         result = Place::Wrap(place);
         map->Insert(result);
         places->Add(result);
 
         if (FLAG_trace_optimization) {
-          OS::Print("numbering %s as %"Pd"\n",
+          OS::Print("numbering %s as %" Pd "\n",
                     result->ToCString(),
                     result->id());
         }
       }
 
       instr->set_place_id(result->id());
     }
   }
 
   if (!has_loads) {
@@ skipping 225 matching lines @@
         }
 
         const intptr_t place_id = defn->place_id();
         if (gen->Contains(place_id)) {
           // This is a locally redundant load.
           ASSERT((out_values != NULL) && ((*out_values)[place_id] != NULL));
 
           Definition* replacement = (*out_values)[place_id];
           EnsureSSATempIndex(graph_, defn, replacement);
           if (FLAG_trace_optimization) {
-            OS::Print("Replacing load v%"Pd" with v%"Pd"\n",
+            OS::Print("Replacing load v%" Pd " with v%" Pd "\n",
                       defn->ssa_temp_index(),
                       replacement->ssa_temp_index());
           }
 
           defn->ReplaceUsesWith(replacement);
           instr_it.RemoveCurrentFromGraph();
           forwarded_ = true;
           continue;
         } else if (!kill->Contains(place_id)) {
           // This is an exposed load: it is the first representative of a
@@ skipping 189 matching lines @@
         for (intptr_t i = 0; i < phi_moves->length(); i++) {
           const intptr_t from = (*phi_moves)[i].from();
           const intptr_t to = (*phi_moves)[i].to();
           if (from == to) continue;
 
           (*block_out_values)[to] = (*temp_forwarded_values)[to];
         }
       }
 
       if (FLAG_trace_load_optimization) {
-        OS::Print("B%"Pd"\n", block->block_id());
+        OS::Print("B%" Pd "\n", block->block_id());
         OS::Print("  IN: ");
         aliased_set_->PrintSet(in_[preorder_number]);
         OS::Print("\n");
 
         OS::Print("  KILL: ");
         aliased_set_->PrintSet(kill_[preorder_number]);
         OS::Print("\n");
 
         OS::Print("  OUT: ");
         aliased_set_->PrintSet(out_[preorder_number]);
@@ skipping 43 matching lines @@
 
       for (BitVector::Iterator loop_it(header->loop_info());
            !loop_it.Done();
            loop_it.Advance()) {
         const intptr_t preorder_number = loop_it.Current();
         loop_gen->RemoveAll(kill_[preorder_number]);
       }
 
       if (FLAG_trace_optimization) {
         for (BitVector::Iterator it(loop_gen); !it.Done(); it.Advance()) {
-          OS::Print("place %s is loop invariant for B%"Pd"\n",
+          OS::Print("place %s is loop invariant for B%" Pd "\n",
                     aliased_set_->places()[it.Current()]->ToCString(),
                     header->block_id());
         }
       }
 
       invariant_loads->Add(loop_gen);
     }
 
     graph_->set_loop_invariant_loads(invariant_loads);
   }
@@ skipping 50 matching lines @@
       Definition* replacement = (*pred_out_values)[place_id]->Replacement();
       Value* input = new Value(replacement);
       phi->SetInputAt(i, input);
       replacement->AddInputUse(input);
     }
 
     phi->set_ssa_temp_index(graph_->alloc_ssa_temp_index());
     phis_.Add(phi);  // Postpone phi insertion until after load forwarding.
 
     if (FLAG_trace_load_optimization) {
-      OS::Print("created pending phi %s for %s at B%"Pd"\n",
+      OS::Print("created pending phi %s for %s at B%" Pd "\n",
                 phi->ToCString(),
                 aliased_set_->places()[place_id]->ToCString(),
                 block->block_id());
     }
   }
 
   // Iterate over basic blocks and replace exposed loads with incoming
   // values.
   void ForwardLoads() {
     for (BlockIterator block_it = graph_->reverse_postorder_iterator();
@@ skipping 18 matching lines @@
         // they might contain values that were replace and removed
         // from the graph by this iteration.
         // To prevent using them we additionally mark definitions themselves
         // as replaced and store a pointer to the replacement.
         replacement = replacement->Replacement();
 
         if (load != replacement) {
           EnsureSSATempIndex(graph_, load, replacement);
 
           if (FLAG_trace_optimization) {
-            OS::Print("Replacing load v%"Pd" with v%"Pd"\n",
+            OS::Print("Replacing load v%" Pd " with v%" Pd "\n",
                       load->ssa_temp_index(),
                       replacement->ssa_temp_index());
           }
 
           load->ReplaceUsesWith(replacement);
           load->RemoveFromGraph();
           load->SetReplacement(replacement);
           forwarded_ = true;
         }
       }
@@ skipping 1437 matching lines @@
   // instructions, previous pointers, predecessors, etc. after eliminating
   // unreachable code.  We do not maintain those properties during the
   // transformation.
   for (BlockIterator b = graph_->reverse_postorder_iterator();
        !b.Done();
        b.Advance()) {
     BlockEntryInstr* block = b.Current();
     JoinEntryInstr* join = block->AsJoinEntry();
     if (!reachable_->Contains(block->preorder_number())) {
       if (FLAG_trace_constant_propagation) {
-        OS::Print("Unreachable B%"Pd"\n", block->block_id());
+        OS::Print("Unreachable B%" Pd "\n", block->block_id());
       }
       // Remove all uses in unreachable blocks.
       if (join != NULL) {
         for (PhiIterator it(join); !it.Done(); it.Advance()) {
           it.Current()->UnuseAllInputs();
         }
       }
       block->UnuseAllInputs();
       for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
         it.Current()->UnuseAllInputs();
@@ skipping 59 matching lines @@
       if ((defn != NULL) &&
           IsConstant(defn->constant_value()) &&
           (defn->constant_value().IsSmi() || defn->constant_value().IsOld()) &&
           !defn->IsConstant() &&
           !defn->IsPushArgument() &&
           !defn->IsStoreIndexed() &&
           !defn->IsStoreInstanceField() &&
           !defn->IsStoreStaticField() &&
           !defn->IsStoreVMField()) {
         if (FLAG_trace_constant_propagation) {
-          OS::Print("Constant v%"Pd" = %s\n",
+          OS::Print("Constant v%" Pd " = %s\n",
                     defn->ssa_temp_index(),
                     defn->constant_value().ToCString());
         }
         ConstantInstr* constant = graph_->GetConstant(defn->constant_value());
         defn->ReplaceUsesWith(constant);
         i.RemoveCurrentFromGraph();
       }
     }
 
     // Replace branches where one target is unreachable with jumps.
@@ skipping 449 matching lines @@
   return true;
 }
 
 
 // Remove the given allocation from the graph. It is not observable.
 // If deoptimization occurs the object will be materialized.
 static void EliminateAllocation(AllocateObjectInstr* alloc) {
   ASSERT(IsAllocationSinkingCandidate(alloc));
 
   if (FLAG_trace_optimization) {
-    OS::Print("removing allocation from the graph: v%"Pd"\n",
+    OS::Print("removing allocation from the graph: v%" Pd "\n",
               alloc->ssa_temp_index());
   }
 
   // As an allocation sinking candidate it is only used in stores to its own
   // fields. Remove these stores.
   for (Value* use = alloc->input_use_list();
        use != NULL;
        use = alloc->input_use_list()) {
     use->instruction()->RemoveFromGraph();
   }
@@ skipping 18 matching lines @@
   // Collect sinking candidates.
   const GrowableArray<BlockEntryInstr*>& postorder = flow_graph_->postorder();
   for (BlockIterator block_it(postorder);
        !block_it.Done();
        block_it.Advance()) {
     BlockEntryInstr* block = block_it.Current();
     for (ForwardInstructionIterator it(block); !it.Done(); it.Advance()) {
       AllocateObjectInstr* alloc = it.Current()->AsAllocateObject();
       if ((alloc != NULL) && IsAllocationSinkingCandidate(alloc)) {
         if (FLAG_trace_optimization) {
-          OS::Print("discovered allocation sinking candidate: v%"Pd"\n",
+          OS::Print("discovered allocation sinking candidate: v%" Pd "\n",
                     alloc->ssa_temp_index());
         }
 
         // All sinking candidate are known to be not aliased.
         alloc->set_identity(AllocateObjectInstr::kNotAliased);
 
         candidates.Add(alloc);
       }
     }
   }
@@ skipping 161 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart