Fix a windows build issue

runtime/vm/disassembler_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 "vm/disassembler.h"
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 #include "platform/assert.h"
 
@@ skipping 357 matching lines @@
 // consumed by the caller.)  FormatOption returns the number of
 // characters that were consumed from the formatting string.
 int ARM64Decoder::FormatOption(Instr* instr, const char* format) {
   switch (format[0]) {
     case 'b': {
       if (format[3] == 'i') {
         ASSERT(STRING_STARTS_WITH(format, "bitimm"));
         const uint64_t imm = instr->ImmLogical();
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
-                                   "0x%"Px64,
+                                   "0x%" Px64,
                                    imm);
         return 6;
       } else {
         ASSERT(STRING_STARTS_WITH(format, "bitpos"));
         int bitpos = instr->Bits(19, 4) | (instr->Bit(31) << 5);
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "#%d",
                                    bitpos);
         return 6;
@@ skipping 131 matching lines @@
               Print("Unknown Shift");
             }
             ret = 6;
           }
         } else {
           ASSERT(STRING_STARTS_WITH(format, "imm16"));
           imm = instr->Imm16Field();
         }
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
-                                   "0x%"Px64,
+                                   "0x%" Px64,
                                    imm);
         return ret;
       } else {
         ASSERT(STRING_STARTS_WITH(format, "immd"));
         double dimm = bit_cast<double, int64_t>(
             Instr::VFPExpandImm(instr->Imm8Field()));
         buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                    remaining_size_in_buffer(),
                                    "%f",
                                    dimm);
         return 4;
       }
     }
     case 'm': {
       ASSERT(STRING_STARTS_WITH(format, "memop"));
       PrintMemOperand(instr);
       return 5;
     }
     case 'p': {
       if (format[1] == 'c') {
         if (format[2] == 'a') {
           ASSERT(STRING_STARTS_WITH(format, "pcadr"));
           const int64_t immhi = instr->SImm19Field();
           const int64_t immlo = instr->Bits(29, 2);
           const int64_t off = (immhi << 2) | immlo;
           const int64_t pc = reinterpret_cast<int64_t>(instr);
           const int64_t dest = pc + off;
           buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                      remaining_size_in_buffer(),
-                                     "0x%"Px64,
+                                     "0x%" Px64,
                                      dest);
         } else {
           ASSERT(STRING_STARTS_WITH(format, "pcldr"));
           const int64_t off = instr->SImm19Field() << 2;
           const int64_t pc = reinterpret_cast<int64_t>(instr);
           const int64_t dest = pc + off;
           buffer_pos_ += OS::SNPrint(current_position_in_buffer(),
                                      remaining_size_in_buffer(),
-                                     "0x%"Px64,
+                                     "0x%" Px64,
                                      dest);
         }
         return 5;
       } else {
         ASSERT(STRING_STARTS_WITH(format, "pmemop"));
         PrintPairMemOperand(instr);
         return 6;
       }
     }
     case 'r': {
@@ skipping 854 matching lines @@
   int32_t instruction_bits = Instr::At(pc)->InstructionBits();
   OS::SNPrint(hex_buffer, hex_size, "%08x", instruction_bits);
   if (out_instr_size) {
     *out_instr_size = Instr::kInstrSize;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM