Fix printf modifiers from %d to % Pd to fix compilation on Mac.

runtime/vm/flow_graph_optimizer.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_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 4747 matching lines @@
       Definition* defn = worklist.definitions()[j];
 
       if (FLAG_trace_smi_widening) {
         OS::Print("> %s\n", defn->ToCString());
       }
 
       if (defn->IsBinarySmiOp() &&
           BenefitsFromWidening(defn->AsBinarySmiOp())) {
         gain++;
         if (FLAG_trace_smi_widening) {
-          OS::Print("^ [%d] (o) %s\n", gain, defn->ToCString());
+          OS::Print("^ [%" Pd "] (o) %s\n", gain, defn->ToCString());
         }
       }
 
       const intptr_t defn_loop = loops[defn->GetBlock()->preorder_number()];
 
       // Process all inputs.
       for (intptr_t k = 0; k < defn->InputCount(); k++) {
         Definition* input = defn->InputAt(k)->definition();
         if (input->IsBinarySmiOp() &&
             CanBeWidened(input->AsBinarySmiOp())) {
           worklist.Add(input);
         } else if (input->IsPhi() && input->Type()->ToCid() == kSmiCid) {
           worklist.Add(input);
         } else if (input->IsBinaryMintOp()) {
           // Mint operation produces untagged result. We avoid tagging.
           gain++;
           if (FLAG_trace_smi_widening) {
-            OS::Print("^ [%d] (i) %s\n", gain, input->ToCString());
+            OS::Print("^ [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         } else if (defn_loop == loops[input->GetBlock()->preorder_number()] &&
                    (input->Type()->ToCid() == kSmiCid)) {
           // Input comes from the same loop, is known to be smi and requires
           // untagging.
           // TODO(vegorov) this heuristic assumes that values that are not
           // known to be smi have to be checked and this check can be
           // coalesced with untagging. Start coalescing them.
           gain--;
           if (FLAG_trace_smi_widening) {
-            OS::Print("v [%d] (i) %s\n", gain, input->ToCString());
+            OS::Print("v [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         }
       }
 
       // Process all uses.
       for (Value* use = defn->input_use_list();
            use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         Definition* use_defn = instr->AsDefinition();
         if (use_defn == NULL) {
           // We assume that tagging before returning or pushing argument costs
           // very little compared to the cost of the return/call itself.
           if (!instr->IsReturn() && !instr->IsPushArgument()) {
             gain--;
             if (FLAG_trace_smi_widening) {
-              OS::Print("v [%d] (u) %s\n",
-                        gain, use->instruction()->ToCString());
+              OS::Print("v [%" Pd "] (u) %s\n",
+                        gain,
+                        use->instruction()->ToCString());
             }
           }
           continue;
         } else if (use_defn->IsBinarySmiOp() &&
                    CanBeWidened(use_defn->AsBinarySmiOp())) {
           worklist.Add(use_defn);
         } else if (use_defn->IsPhi() &&
                    use_defn->AsPhi()->Type()->ToCid() == kSmiCid) {
           worklist.Add(use_defn);
         } else if (use_defn->IsBinaryMintOp()) {
           // BinaryMintOp requires untagging of its inputs.
           // Converting kUnboxedInt32 to kUnboxedMint is essentially zero cost
           // sign extension operation.
           gain++;
           if (FLAG_trace_smi_widening) {
-            OS::Print("^ [%d] (u) %s\n", gain, use->instruction()->ToCString());
+            OS::Print("^ [%" Pd "] (u) %s\n",
+                      gain,
+                      use->instruction()->ToCString());
           }
         } else if (defn_loop == loops[instr->GetBlock()->preorder_number()]) {
           gain--;
           if (FLAG_trace_smi_widening) {
-            OS::Print("v [%d] (u) %s\n", gain, use->instruction()->ToCString());
+            OS::Print("v [%" Pd "] (u) %s\n",
+                      gain,
+                      use->instruction()->ToCString());
           }
         }
       }
     }
 
     processed->AddAll(worklist.contains());
 
     if (FLAG_trace_smi_widening) {
-      OS::Print("~ %s gain %d\n", op->ToCString(), gain);
+      OS::Print("~ %s gain %" Pd "\n", op->ToCString(), gain);
     }
 
     if (gain > 0) {
       // We have positive gain from widening. Convert all BinarySmiOpInstr into
       // BinaryInt32OpInstr and set representation of all phis to kUnboxedInt32.
       for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
         Definition* defn = worklist.definitions()[j];
         ASSERT(defn->IsPhi() || defn->IsBinarySmiOp());
 
         if (defn->IsBinarySmiOp()) {
@@ skipping 5098 matching lines @@
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits_collector_.exits().length(); i++) {
     CreateMaterializationAt(
         exits_collector_.exits()[i], alloc, alloc->cls(), *slots);
   }
 }
 
 
 }  // namespace dart