fix cpp11 compile errors

runtime/vm/flow_graph_inliner.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_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 394 matching lines @@
     }
     // Create two call site collections to swap between.
     CallSites sites1(caller_graph_);
     CallSites sites2(caller_graph_);
     CallSites* call_sites_temp = NULL;
     collected_call_sites_ = &sites1;
     inlining_call_sites_ = &sites2;
     // Collect initial call sites.
     collected_call_sites_->FindCallSites(caller_graph_);
     while (collected_call_sites_->HasCalls()) {
-      TRACE_INLINING(OS::Print("  Depth %"Pd" ----------\n", inlining_depth_));
+      TRACE_INLINING(OS::Print("  Depth %" Pd " ----------\n",
+                               inlining_depth_));
       // Swap collected and inlining arrays and clear the new collecting array.
       call_sites_temp = collected_call_sites_;
       collected_call_sites_ = inlining_call_sites_;
       inlining_call_sites_ = call_sites_temp;
       collected_call_sites_->Clear();
       // Inline call sites at the current depth.
       InlineStaticCalls();
       InlineClosureCalls();
       InlineInstanceCalls();
       // Increment the inlining depth. Checked before recursive inlining.
@@ skipping 38 matching lines @@
       return false;
     }
 
     GrowableArray<Value*>* arguments = call_data->arguments;
     const intptr_t constant_arguments = CountConstants(*arguments);
     if (!ShouldWeInline(function,
                         function.optimized_instruction_count(),
                         function.optimized_call_site_count(),
                         constant_arguments)) {
       TRACE_INLINING(OS::Print("     Bailout: early heuristics with "
-                               "code size:  %"Pd", "
-                               "call sites: %"Pd", "
-                               "const args: %"Pd"\n",
+                               "code size:  %" Pd ", "
+                               "call sites: %" Pd ", "
+                               "const args: %" Pd "\n",
                                function.optimized_instruction_count(),
                                function.optimized_call_site_count(),
                                constant_arguments));
       return false;
     }
 
     // Abort if this is a recursive occurrence.
     Definition* call = call_data->call;
     if (!FLAG_inline_recursive && IsCallRecursive(function, call)) {
       function.set_is_inlinable(false);
@@ skipping 129 matching lines @@
       if (!ShouldWeInline(function, size, call_site_count, constants_count)) {
         // If size is larger than all thresholds, don't consider it again.
         if ((size > FLAG_inlining_size_threshold) &&
             (call_site_count > FLAG_inlining_callee_call_sites_threshold) &&
             (size > FLAG_inlining_constant_arguments_size_threshold)) {
           function.set_is_inlinable(false);
         }
         isolate->set_long_jump_base(base);
         isolate->set_deopt_id(prev_deopt_id);
         TRACE_INLINING(OS::Print("     Bailout: heuristics with "
-                                 "code size:  %"Pd", "
-                                 "call sites: %"Pd", "
-                                 "const args: %"Pd"\n",
+                                 "code size:  %" Pd ", "
+                                 "call sites: %" Pd ", "
+                                 "const args: %" Pd "\n",
                                  size,
                                  call_site_count,
                                  constants_count));
         return false;
       }
 
       // If depth is less or equal to threshold recursively add call sites.
       if (inlining_depth_ < FLAG_inlining_depth_threshold) {
         collected_call_sites_->FindCallSites(callee_graph);
       }
@@ skipping 785 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart