fix cpp11 compile errors

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 334 matching lines @@
     const AbstractType& type,
     const AbstractTypeArguments& instantiator_type_arguments,
     const Bool& result) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const Type& instance_type = Type::Handle(instance.GetType());
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
-    OS::PrintErr("%s: '%s' %"Pd" %s '%s' %"Pd" (pc: %#"Px").\n",
+    OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n",
                  message,
                  String::Handle(instance_type.Name()).ToCString(),
                  Class::Handle(instance_type.type_class()).id(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(type.Name()).ToCString(),
                  Class::Handle(type.type_class()).id(),
                  caller_frame->pc());
   } else {
     // Instantiate type before printing.
     Error& malformed_error = Error::Handle();
     const AbstractType& instantiated_type = AbstractType::Handle(
         type.InstantiateFrom(instantiator_type_arguments, &malformed_error));
-    OS::PrintErr("%s: '%s' %s '%s' instantiated from '%s' (pc: %#"Px").\n",
+    OS::PrintErr("%s: '%s' %s '%s' instantiated from '%s' (pc: %#" Px ").\n",
                  message,
                  String::Handle(instance_type.Name()).ToCString(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(instantiated_type.Name()).ToCString(),
                  String::Handle(type.Name()).ToCString(),
                  caller_frame->pc());
     if (!malformed_error.IsNull()) {
       OS::Print("  malformed error: %s\n", malformed_error.ToErrorCString());
     }
   }
@@ skipping 102 matching lines @@
         i,
         &last_instance_class_id,
         &last_instance_type_arguments,
         &last_instantiator_type_arguments,
         &last_result);
     if ((last_instance_class_id == instance_class.id()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
       if (FLAG_trace_type_checks) {
-        OS::PrintErr("%"Pd" ", i);
+        OS::PrintErr("%" Pd " ", i);
         if (type_arguments_replaced) {
           PrintTypeCheck("Duplicate cache entry (canonical.)", instance, type,
               instantiator_type_arguments, result);
         } else {
           PrintTypeCheck("WARNING Duplicate cache entry", instance, type,
               instantiator_type_arguments, result);
         }
       }
       // Can occur if we have canonicalized arguments.
       // TODO(srdjan): Investigate why this assert can fail.
       // ASSERT(type_arguments_replaced);
       return;
     }
   }
   if (!instantiator_type_arguments.IsInstantiatedTypeArguments()) {
     new_cache.AddCheck(instance_class.id(),
                        instance_type_arguments,
                        instantiator_type_arguments,
                        result);
   }
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       Error& malformed_error = Error::Handle();
       test_type = type.InstantiateFrom(instantiator_type_arguments,
                                        &malformed_error);
       ASSERT(malformed_error.IsNull());  // Malformed types are not optimized.
     }
-    OS::PrintErr("  Updated test cache %p ix: %"Pd" with "
-        "(cid: %"Pd", type-args: %p, instantiator: %p, result: %s)\n"
-        "    instance  [class: (%p '%s' cid: %"Pd"),    type-args: %p %s]\n"
-        "    test-type [class: (%p '%s' cid: %"Pd"), in-type-args: %p %s]\n",
+    OS::PrintErr("  Updated test cache %p ix: %" Pd " with "
+        "(cid: %" Pd ", type-args: %p, instantiator: %p, result: %s)\n"
+        "    instance  [class: (%p '%s' cid: %" Pd "),    type-args: %p %s]\n"
+        "    test-type [class: (%p '%s' cid: %" Pd "), in-type-args: %p %s]\n",
         new_cache.raw(),
         len,
 
         instance_class.id(),
         instance_type_arguments.raw(),
         instantiator_type_arguments.raw(),
         result.ToCString(),
 
         instance_class.raw(),
         String::Handle(instance_class.Name()).ToCString(),
@@ skipping 198 matching lines @@
   }
   const Code& target_code = Code::Handle(target_function.CurrentCode());
   // Before patching verify that we are not repeatedly patching to the same
   // target.
   ASSERT(target_code.EntryPoint() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code));
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), caller_code,
                                  target_code.EntryPoint());
   caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   if (FLAG_trace_patching) {
-    OS::PrintErr("PatchStaticCall: patching from %#"Px" to '%s' %#"Px"\n",
+    OS::PrintErr("PatchStaticCall: patching from %#" Px " to '%s' %#" Px "\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         target_code.EntryPoint());
   }
   arguments.SetReturn(target_code);
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
 // function cache of the receiver's class and returns the compiled code or null.
@@ skipping 139 matching lines @@
     ASSERT(caller_frame != NULL);
     if (FLAG_trace_ic_miss_in_optimized) {
       const Code& caller = Code::Handle(Code::LookupCode(caller_frame->pc()));
       if (caller.is_optimized()) {
         OS::PrintErr("IC miss in optimized code; call %s -> %s\n",
             Function::Handle(caller.function()).ToCString(),
             target_function.ToCString());
       }
     }
     if (FLAG_trace_ic) {
-      OS::PrintErr("InlineCacheMissHandler %d call at %#"Px"' "
-                   "adding <%s> id:%"Pd" -> <%s>\n",
+      OS::PrintErr("InlineCacheMissHandler %d call at %#" Px "' "
+                   "adding <%s> id:%" Pd " -> <%s>\n",
           args.length(),
           caller_frame->pc(),
           Class::Handle(receiver.clazz()).ToCString(),
           receiver.GetClassId(),
           target_function.ToCString());
     }
   }
   return target_function.raw();
 }
 
@@ skipping 86 matching lines @@
   }
   ASSERT(!target.IsNull() && target.HasCode());
   GrowableArray<intptr_t> cids(2);
   cids.Add(arg0.GetClassId());
   cids.Add(arg1.GetClassId());
   ic_data.AddCheck(cids, target);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
-    OS::PrintErr("StaticCallMissHandler at %#"Px" target %s (%"Pd", %"Pd")\n",
-        caller_frame->pc(), target.ToCString(), cids[0], cids[1]);
+    OS::PrintErr("StaticCallMissHandler at %#" Px
+                 " target %s (%" Pd ", %" Pd ")\n",
+                 caller_frame->pc(), target.ToCString(), cids[0], cids[1]);
   }
   arguments.SetReturn(target);
 }
 
 
 // Handle a miss of a megamorphic cache.
 //   Arg0: Receiver.
 //   Arg1: ICData object.
 //   Arg2: Arguments descriptor array.
 
@@ skipping 149 matching lines @@
 
   const Function& target_function =
       Function::Handle(receiver_class.GetInvocationDispatcher(
           target_name,
           arguments_descriptor,
           RawFunction::kInvokeFieldDispatcher));
   // Update IC data.
   ASSERT(!target_function.IsNull());
   ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
   if (FLAG_trace_ic) {
-    OS::PrintErr("InvokeField IC miss: adding <%s> id:%"Pd" -> <%s>\n",
+    OS::PrintErr("InvokeField IC miss: adding <%s> id:%" Pd " -> <%s>\n",
         Class::Handle(receiver.clazz()).ToCString(),
         receiver.GetClassId(),
         target_function.ToCString());
   }
   *result = DartEntry::InvokeFunction(target_function,
                                       arguments,
                                       arguments_descriptor);
   CheckResultError(*result);
   return true;
 }
@@ skipping 56 matching lines @@
       // Operators calls have two or three arguments tested ([], []=, etc.)
       ASSERT(ic_data.num_args_tested() > 1);
       GrowableArray<intptr_t> class_ids(ic_data.num_args_tested());
       class_ids.Add(receiver_cid);
       for (intptr_t i = 1; i < ic_data.num_args_tested(); ++i) {
         class_ids.Add(Object::Handle(args.At(i)).GetClassId());
       }
       ic_data.AddCheck(class_ids, target_function);
     }
     if (FLAG_trace_ic) {
-      OS::PrintErr("NoSuchMethod IC miss: adding <%s> id:%"Pd" -> <%s>\n",
+      OS::PrintErr("NoSuchMethod IC miss: adding <%s> id:%" Pd " -> <%s>\n",
           Class::Handle(receiver.clazz()).ToCString(),
           receiver_cid,
           target_function.ToCString());
     }
     result = DartEntry::InvokeFunction(target_function, args, args_descriptor);
   }
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
@@ skipping 92 matching lines @@
 
   if (FLAG_use_osr && (interrupt_bits == 0)) {
     DartFrameIterator iterator;
     StackFrame* frame = iterator.NextFrame();
     const Function& function = Function::Handle(frame->LookupDartFunction());
     ASSERT(!function.IsNull());
     if (!CanOptimizeFunction(function, isolate)) return;
     intptr_t osr_id =
         Code::Handle(function.unoptimized_code()).GetDeoptIdForOsr(frame->pc());
     if (FLAG_trace_osr) {
-      OS::Print("Attempting OSR for %s at id=%"Pd", count=%"Pd"\n",
+      OS::Print("Attempting OSR for %s at id=%" Pd ", count=%" Pd "\n",
                 function.ToFullyQualifiedCString(),
                 osr_id,
                 function.usage_counter());
     }
 
     const Code& original_code = Code::Handle(function.CurrentCode());
     const Error& error =
         Error::Handle(Compiler::CompileOptimizedFunction(function, osr_id));
     if (!error.IsNull()) Exceptions::PropagateError(error);
 
@@ skipping 14 matching lines @@
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   ASSERT(arguments.ArgCount() ==
          kTraceICCallRuntimeEntry.argument_count());
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
-  OS::PrintErr("IC call @%#"Px": ICData: %p cnt:%"Pd" nchecks: %"Pd" %s %s\n",
+  OS::PrintErr("IC call @%#" Px ": ICData: %p cnt:%" Pd " nchecks: %" Pd
+      " %s %s\n",
       frame->pc(),
       ic_data.raw(),
       function.usage_counter(),
       ic_data.NumberOfChecks(),
       ic_data.is_closure_call() ? "closure" : "",
       function.ToFullyQualifiedCString());
 }
 
 
 // This is called from function that needs to be optimized.
@@ skipping 40 matching lines @@
   ASSERT(frame->IsDartFrame());
   const Code& caller_code = Code::Handle(frame->LookupDartCode());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       caller_code.GetStaticCallTargetFunctionAt(frame->pc()));
   const Code& target_code = Code::Handle(target_function.CurrentCode());
   CodePatcher::PatchStaticCallAt(frame->pc(), caller_code,
                                  target_code.EntryPoint());
   caller_code.SetStaticCallTargetCodeAt(frame->pc(), target_code);
   if (FLAG_trace_patching) {
-    OS::PrintErr("FixCallersTarget: patching from %#"Px" to '%s' %#"Px"\n",
+    OS::PrintErr("FixCallersTarget: patching from %#" Px " to '%s' %#" Px "\n",
         frame->pc(),
         Function::Handle(target_code.function()).ToFullyQualifiedCString(),
         target_code.EntryPoint());
   }
   arguments.SetReturn(target_code);
 }
 
 
 const char* DeoptReasonToText(intptr_t deopt_id) {
   switch (deopt_id) {
@@ skipping 154 matching lines @@
 
   intptr_t deopt_reason = kDeoptUnknown;
   const DeoptInfo& deopt_info = DeoptInfo::Handle(
       optimized_code.GetDeoptInfoAtPc(caller_frame->pc(), &deopt_reason));
   ASSERT(!deopt_info.IsNull());
 
   CopyFrame(optimized_code, *caller_frame);
   if (FLAG_trace_deoptimization || FLAG_trace_deoptimization_verbose) {
     Function& function = Function::Handle(optimized_code.function());
     OS::PrintErr(
-        "Deoptimizing (reason %"Pd" '%s') at pc %#"Px" '%s' (count %d)\n",
+        "Deoptimizing (reason %" Pd " '%s') at pc %#" Px " '%s' (count %d)\n",
         deopt_reason,
         DeoptReasonToText(deopt_reason),
         caller_frame->pc(),
         function.ToFullyQualifiedCString(),
         function.deoptimization_counter());
   }
 
   // Compute the stack size of the unoptimized frame.  For functions with
   // optional arguments the deoptimization info does not describe the
   // incoming arguments.
@@ skipping 63 matching lines @@
   // Populate stack frames.
   for (intptr_t to_index = frame_size - 1, from_index = len - 1;
        to_index >= 0;
        to_index--, from_index--) {
     intptr_t* to_addr = deopt_context.GetToFrameAddressAt(to_index);
     deopt_instructions[from_index]->Execute(&deopt_context, to_addr);
   }
 
   if (FLAG_trace_deoptimization_verbose) {
     for (intptr_t i = 0; i < frame_size; i++) {
-      OS::PrintErr("*%"Pd". [%"Px"] %#014"Px" [%s]\n",
+      OS::PrintErr("*%" Pd ". [%" Px "] %#014" Px " [%s]\n",
                    i,
                    reinterpret_cast<uword>(&start[i]),
                    start[i],
                    deopt_instructions[i + (len - frame_size)]->ToCString());
     }
   }
 }
 
 
 // The stack has been adjusted to fit all values for unoptimized frame.
@@ skipping 70 matching lines @@
     StackFrame* top_frame = iterator.NextFrame();
     ASSERT(top_frame != NULL);
     const Code& code = Code::Handle(top_frame->LookupDartCode());
     const Function& top_function = Function::Handle(code.function());
     const Script& script = Script::Handle(top_function.script());
     const intptr_t token_pos = code.GetTokenIndexOfPC(top_frame->pc());
     intptr_t line, column;
     script.GetTokenLocation(token_pos, &line, &column);
     String& line_string = String::Handle(script.GetLine(line));
     OS::PrintErr("  Function: %s\n", top_function.ToFullyQualifiedCString());
-    OS::PrintErr("  Line %"Pd": '%s'\n", line, line_string.ToCString());
-    OS::PrintErr("  Deopt args: %"Pd"\n", deopt_arguments);
+    OS::PrintErr("  Line %" Pd ": '%s'\n", line, line_string.ToCString());
+    OS::PrintErr("  Deopt args: %" Pd "\n", deopt_arguments);
   }
 }
 
 
 DEFINE_LEAF_RUNTIME_ENTRY(intptr_t,
                           BigintCompare,
                           2,
                           RawBigint* left,
                           RawBigint* right) {
   Isolate* isolate = Isolate::Current();
@@ skipping 28 matching lines @@
 //   Arg1: Value that is being stored.
 DEFINE_RUNTIME_ENTRY(UpdateFieldCid, 2) {
   ASSERT(arguments.ArgCount() == kUpdateFieldCidRuntimeEntry.argument_count());
   const Field& field = Field::CheckedHandle(arguments.ArgAt(0));
   const Object& value = Object::Handle(arguments.ArgAt(1));
 
   field.UpdateCid(value.GetClassId());
 }
 
 }  // namespace dart