Fix a windows build issue

runtime/vm/simulator_arm64.cc

 // Copyright (c) 2014, 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 <setjmp.h>  // NOLINT
 #include <stdlib.h>
 
 #include "vm/globals.h"
 #if defined(TARGET_ARCH_ARM64)
 
@@ skipping 180 matching lines @@
         return false;
       }
       *value = *(reinterpret_cast<int64_t*>(addr));
       return true;
     }
   }
   if (strcmp("pc", desc) == 0) {
     *value = sim_->get_pc();
     return true;
   }
-  bool retval = SScanF(desc, "0x%"Px64, value) == 1;
+  bool retval = SScanF(desc, "0x%" Px64, value) == 1;
   if (!retval) {
-    retval = SScanF(desc, "%"Px64, value) == 1;
+    retval = SScanF(desc, "%" Px64, value) == 1;
   }
   return retval;
 }
 
 
 bool SimulatorDebugger::GetSValue(char* desc, uint32_t* value) {
   VRegister vreg = LookupVRegisterByName(desc);
   if (vreg != kNoVRegister) {
     *value = sim_->get_vregisters(vreg, 0);
     return true;
@@ skipping 258 matching lines @@
       } else if ((strcmp(cmd, "c") == 0) || (strcmp(cmd, "cont") == 0)) {
         // Execute the one instruction we broke at with breakpoints disabled.
         sim_->InstructionDecode(reinterpret_cast<Instr*>(sim_->get_pc()));
         // Leave the debugger shell.
         done = true;
       } else if ((strcmp(cmd, "p") == 0) || (strcmp(cmd, "print") == 0)) {
         if (args == 2) {
           uint64_t value;
           if (strcmp(arg1, "icount") == 0) {
             value = sim_->get_icount();
-            OS::Print("icount: %"Pu64" 0x%"Px64"\n", value, value);
+            OS::Print("icount: %" Pu64 " 0x%" Px64 "\n", value, value);
           } else if (GetValue(arg1, &value)) {
-            OS::Print("%s: %"Pu64" 0x%"Px64"\n", arg1, value, value);
+            OS::Print("%s: %" Pu64 " 0x%" Px64 "\n", arg1, value, value);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("print <reg or icount or value or *addr>\n");
         }
       } else if ((strcmp(cmd, "pf") == 0) ||
                  (strcmp(cmd, "printfloat") == 0)) {
         if (args == 2) {
           uint32_t value;
           if (GetSValue(arg1, &value)) {
             float svalue = bit_cast<float, uint32_t>(value);
             OS::Print("%s: %d 0x%x %.8g\n",
                 arg1, value, value, svalue);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printfloat <vreg or *addr>\n");
         }
       } else if ((strcmp(cmd, "pd") == 0) ||
                  (strcmp(cmd, "printdouble") == 0)) {
         if (args == 2) {
           uint64_t long_value;
           if (GetDValue(arg1, &long_value)) {
             double dvalue = bit_cast<double, uint64_t>(long_value);
-            OS::Print("%s: %"Pu64" 0x%"Px64" %.8g\n",
+            OS::Print("%s: %" Pu64 " 0x%" Px64 " %.8g\n",
                 arg1, long_value, long_value, dvalue);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printdouble <vreg or *addr>\n");
         }
       } else if ((strcmp(cmd, "pq") == 0) ||
                  (strcmp(cmd, "printquad") == 0)) {
         if (args == 2) {
           simd_value_t quad_value;
           if (GetQValue(arg1, &quad_value)) {
             const int64_t d0 = quad_value.bits.i64[0];
             const int64_t d1 = quad_value.bits.i64[1];
             const double dval0 = bit_cast<double, int64_t>(d0);
             const double dval1 = bit_cast<double, int64_t>(d1);
             const int32_t s0 = quad_value.bits.i32[0];
             const int32_t s1 = quad_value.bits.i32[1];
             const int32_t s2 = quad_value.bits.i32[2];
             const int32_t s3 = quad_value.bits.i32[3];
             const float sval0 = bit_cast<float, int32_t>(s0);
             const float sval1 = bit_cast<float, int32_t>(s1);
             const float sval2 = bit_cast<float, int32_t>(s2);
             const float sval3 = bit_cast<float, int32_t>(s3);
-            OS::Print("%s: %"Pu64" 0x%"Px64" %.8g\n", arg1, d0, d0, dval0);
-            OS::Print("%s: %"Pu64" 0x%"Px64" %.8g\n", arg1, d1, d1, dval1);
+            OS::Print("%s: %" Pu64 " 0x%" Px64 " %.8g\n", arg1, d0, d0, dval0);
+            OS::Print("%s: %" Pu64 " 0x%" Px64 " %.8g\n", arg1, d1, d1, dval1);
             OS::Print("%s: %d 0x%x %.8g\n", arg1, s0, s0, sval0);
             OS::Print("%s: %d 0x%x %.8g\n", arg1, s1, s1, sval1);
             OS::Print("%s: %d 0x%x %.8g\n", arg1, s2, s2, sval2);
             OS::Print("%s: %d 0x%x %.8g\n", arg1, s3, s3, sval3);
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printquad <vreg or *addr>\n");
         }
       } else if ((strcmp(cmd, "po") == 0) ||
                  (strcmp(cmd, "printobject") == 0)) {
         if (args == 2) {
           uint64_t value;
           // Make the dereferencing '*' optional.
           if (((arg1[0] == '*') && GetValue(arg1 + 1, &value)) ||
               GetValue(arg1, &value)) {
             if (Isolate::Current()->heap()->Contains(value)) {
               OS::Print("%s: \n", arg1);
 #if defined(DEBUG)
               const Object& obj = Object::Handle(
                   reinterpret_cast<RawObject*>(value));
               obj.Print();
 #endif  // defined(DEBUG)
             } else {
-              OS::Print("0x%"Px64" is not an object reference\n", value);
+              OS::Print("0x%" Px64 " is not an object reference\n", value);
             }
           } else {
             OS::Print("%s unrecognized\n", arg1);
           }
         } else {
           OS::Print("printobject <*reg or *addr>\n");
         }
       } else if (strcmp(cmd, "disasm") == 0) {
         uint64_t start = 0;
         uint64_t end = 0;
         if (args == 1) {
           start = sim_->get_pc();
           end = start + (10 * Instr::kInstrSize);
         } else if (args == 2) {
           if (GetValue(arg1, &start)) {
             // No length parameter passed, assume 10 instructions.
             if (Simulator::IsIllegalAddress(start)) {
               // If start isn't a valid address, warn and use PC instead.
-              OS::Print("First argument yields invalid address: 0x%"Px64"\n",
+              OS::Print("First argument yields invalid address: 0x%" Px64 "\n",
                         start);
               OS::Print("Using PC instead\n");
               start = sim_->get_pc();
             }
             end = start + (10 * Instr::kInstrSize);
           }
         } else {
           uint64_t length;
           if (GetValue(arg1, &start) && GetValue(arg2, &length)) {
             if (Simulator::IsIllegalAddress(start)) {
               // If start isn't a valid address, warn and use PC instead.
-              OS::Print("First argument yields invalid address: 0x%"Px64"\n",
+              OS::Print("First argument yields invalid address: 0x%" Px64 "\n",
                         start);
               OS::Print("Using PC instead\n");
               start = sim_->get_pc();
             }
             end = start + (length * Instr::kInstrSize);
           }
         }
         if ((start > 0) && (end > start)) {
           Disassembler::Disassemble(start, end);
         } else {
@@ skipping 2691 matching lines @@
   } else {
     UnimplementedInstruction(instr);
   }
 }
 
 
 // Executes the current instruction.
 void Simulator::InstructionDecode(Instr* instr) {
   pc_modified_ = false;
   if (IsTracingExecution()) {
-    OS::Print("%"Pu64, icount_);
+    OS::Print("%" Pu64, icount_);
     const uword start = reinterpret_cast<uword>(instr);
     const uword end = start + Instr::kInstrSize;
     Disassembler::Disassemble(start, end);
   }
 
   if (instr->IsDPImmediateOp()) {
     DecodeDPImmediate(instr);
   } else if (instr->IsCompareBranchOp()) {
     DecodeCompareBranch(instr);
   } else if (instr->IsLoadStoreOp()) {
@@ skipping 184 matching lines @@
   set_register(NULL, kExceptionObjectReg, bit_cast<int64_t>(raw_exception));
   set_register(NULL, kStackTraceObjectReg, bit_cast<int64_t>(raw_stacktrace));
   buf->Longjmp();
 }
 
 }  // namespace dart
 
 #endif  // !defined(HOST_ARCH_ARM64)
 
 #endif  // defined TARGET_ARCH_ARM64