fix cpp11 compile errors

runtime/vm/simulator_arm.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 <math.h>  // for isnan.
 #include <setjmp.h>
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM)
@@ skipping 276 matching lines @@
                                        bool is_optimized,
                                        bool is_inlined) {
   const Script& script = Script::Handle(function.script());
   const String& func_name = String::Handle(function.QualifiedUserVisibleName());
   const String& url = String::Handle(script.url());
   intptr_t line = -1;
   intptr_t column = -1;
   if (token_pos >= 0) {
     script.GetTokenLocation(token_pos, &line, &column);
   }
-  OS::Print("pc=0x%"Px" fp=0x%"Px" sp=0x%"Px" %s%s (%s:%"Pd":%"Pd")\n",
+  OS::Print("pc=0x%" Px " fp=0x%" Px " sp=0x%" Px " %s%s (%s:%" Pd ":%" Pd ")\n",

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

OS::Print("pc=0x%" Px " fp=0x%" Px " sp=0x%" Px " %s%s (%s:%" Pd
          ":%" Pd ")\n",

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

Done.

             pc, fp, sp,
             is_optimized ? (is_inlined ? "inlined " : "optimized ") : "",
             func_name.ToCString(),
             url.ToCString(),
             line, column);
 }
 
 
 void SimulatorDebugger::PrintBacktrace() {
   StackFrameIterator frames(sim_->get_register(FP),
@@ skipping 29 matching lines @@
                            true, true);
           }
         }
         // Print the optimized inlining frame below.
       }
       PrintDartFrame(frame->pc(), frame->fp(), frame->sp(),
                      function,
                      GetApproximateTokenIndex(code, frame->pc()),
                      code.is_optimized(), false);
     } else {
-      OS::Print("pc=0x%"Px" fp=0x%"Px" sp=0x%"Px" %s frame\n",
+      OS::Print("pc=0x%" Px " fp=0x%" Px " sp=0x%" Px " %s frame\n",
                 frame->pc(), frame->fp(), frame->sp(),
                 frame->IsEntryFrame() ? "entry" :
                     frame->IsExitFrame() ? "exit" :
                         frame->IsStubFrame() ? "stub" : "invalid");
     }
     frame = frames.NextFrame();
   }
 }
 
 
@@ skipping 57 matching lines @@
   arg2[ARG_SIZE] = 0;
 
   // Undo all set breakpoints while running in the debugger shell. This will
   // make them invisible to all commands.
   UndoBreakpoints();
 
   while (!done) {
     if (last_pc != sim_->get_pc()) {
       last_pc = sim_->get_pc();
       if (Simulator::IsIllegalAddress(last_pc)) {
-        OS::Print("pc is out of bounds: 0x%"Px"\n", last_pc);
+        OS::Print("pc is out of bounds: 0x%" Px "\n", last_pc);
       } else {
         Disassembler::Disassemble(last_pc, last_pc + Instr::kInstrSize);
       }
     }
     char* line = ReadLine("sim> ");
     if (line == NULL) {
       FATAL("ReadLine failed");
     } else {
       // Use sscanf to parse the individual parts of the command line. At the
       // moment no command expects more than two parameters.
@@ skipping 533 matching lines @@
   return dregisters_[reg];
 }
 
 
 void Simulator::HandleIllegalAccess(uword addr, Instr* instr) {
   uword fault_pc = get_pc();
   // The debugger will not be able to single step past this instruction, but
   // it will be possible to disassemble the code and inspect registers.
   char buffer[128];
   snprintf(buffer, sizeof(buffer),
-           "illegal memory access at 0x%"Px", pc=0x%"Px"\n",
+           "illegal memory access at 0x%" Px ", pc=0x%" Px "\n",
            addr, fault_pc);
   SimulatorDebugger dbg(this);
   dbg.Stop(instr, buffer);
   // The debugger will return control in non-interactive mode.
   FATAL("Cannot continue execution after illegal memory access.");
 }
 
 
 // Processor versions prior to ARMv7 could not do unaligned reads and writes.
 // On some ARM platforms an interrupt is caused.  On others it does a funky
 // rotation thing.  However, from version v7, unaligned access is supported.
 // Note that simulator runs have the runtime system running directly on the host
 // system and only generated code is executed in the simulator.  Since the host
 // is typically IA32 we will get the correct ARMv7-like behaviour on unaligned
 // accesses, but we should actually not generate code accessing unaligned data,
 // so we still want to know and abort if we encounter such code.
 void Simulator::UnalignedAccess(const char* msg, uword addr, Instr* instr) {
   // The debugger will not be able to single step past this instruction, but
   // it will be possible to disassemble the code and inspect registers.
   char buffer[64];
   snprintf(buffer, sizeof(buffer),
-           "unaligned %s at 0x%"Px", pc=%p\n", msg, addr, instr);
+           "unaligned %s at 0x%" Px ", pc=%p\n", msg, addr, instr);
   SimulatorDebugger dbg(this);
   dbg.Stop(instr, buffer);
   // The debugger will return control in non-interactive mode.
   FATAL("Cannot continue execution after unaligned access.");
 }
 
 
 void Simulator::UnimplementedInstruction(Instr* instr) {
   char buffer[64];
   snprintf(buffer, sizeof(buffer), "Unimplemented instruction: pc=%p\n", instr);
@@ skipping 487 matching lines @@
   int svc = instr->SvcField();
   switch (svc) {
     case kRedirectionSvcCode: {
       SimulatorSetjmpBuffer buffer(this);
 
       if (!setjmp(buffer.buffer_)) {
         int32_t saved_lr = get_register(LR);
         Redirection* redirection = Redirection::FromSvcInstruction(instr);
         uword external = redirection->external_function();
         if (FLAG_trace_sim) {
-          OS::Print("Call to host function at 0x%"Pd"\n", external);
+          OS::Print("Call to host function at 0x%" Pd "\n", external);
         }
 
         if ((redirection->call_kind() == kRuntimeCall) ||
             (redirection->call_kind() == kBootstrapNativeCall) ||
             (redirection->call_kind() == kNativeCall)) {
           // Set the top_exit_frame_info of this simulator to the native stack.
           set_top_exit_frame_info(reinterpret_cast<uword>(&buffer));
         }
         if (redirection->call_kind() == kRuntimeCall) {
           NativeArguments arguments;
@@ skipping 2147 matching lines @@
   set_register(kExceptionObjectReg, bit_cast<int32_t>(raw_exception));
   set_register(kStackTraceObjectReg, bit_cast<int32_t>(raw_stacktrace));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM)
 
 #endif  // defined TARGET_ARCH_ARM