Add attributions so printf like functions can have their arguments checked.

runtime/vm/il_printer.cc

 // Copyright (c) 2012, 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/il_printer.h"
 
 #include "vm/intermediate_language.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
@@ skipping 33 matching lines @@
     Instruction* current = block_order_[i];
     for (ForwardInstructionIterator it(current->AsBlockEntry());
          !it.Done();
          it.Advance()) {
       current = it.Current();
       OS::Print("\n");
       PrintInstruction(current);
     }
     if (current->next() != NULL) {
       ASSERT(current->next()->IsBlockEntry());
-      OS::Print(" goto %d", current->next()->AsBlockEntry()->block_id());
+      OS::Print(" goto %"Pd"", current->next()->AsBlockEntry()->block_id());
     }
     OS::Print("\n");
   }
 }
 
 
 void FlowGraphPrinter::PrintInstruction(Instruction* instr) {
   char str[1000];
   BufferFormatter f(str, sizeof(str));
   instr->PrintTo(&f);
   if (FLAG_print_environments && (instr->env() != NULL)) {
     instr->env()->PrintTo(&f);
   }
   if (print_locations_ && (instr->locs() != NULL)) {
     instr->locs()->PrintTo(&f);
   }
   if (instr->lifetime_position() != -1) {
-    OS::Print("%3d: ", instr->lifetime_position());
+    OS::Print("%3"Pd": ", instr->lifetime_position());
   }
   OS::Print("%s", str);
 }
 
 
 void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
                                       intptr_t token_pos,
                                       Value* value,
                                       const AbstractType& dst_type,
                                       const String& dst_name,
@@ skipping 11 matching lines @@
                          "type '%s' of '%s'.",
                          eliminated ? "Eliminated" : "Generated",
                          compile_type_name,
                          eliminated ? "more" : "not more",
                          String::Handle(dst_type.Name()).ToCString(),
                          dst_name.ToCString());
 }
 
 
 static void PrintICData(BufferFormatter* f, const ICData& ic_data) {
-  f->Print(" IC[%d: ", ic_data.NumberOfChecks());
+  f->Print(" IC[%"Pd": ", ic_data.NumberOfChecks());
   Function& target = Function::Handle();
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<intptr_t> class_ids;
     ic_data.GetCheckAt(i, &class_ids, &target);
     if (i > 0) {
       f->Print(" | ");
     }
     for (intptr_t k = 0; k < class_ids.length(); k++) {
       if (k > 0) {
         f->Print(", ");
       }
       const Class& cls =
           Class::Handle(Isolate::Current()->class_table()->At(class_ids[k]));
       f->Print("%s", String::Handle(cls.Name()).ToCString());
     }
   }
   f->Print("]");
 }
 
 
 void Definition::PrintTo(BufferFormatter* f) const {
   // Do not access 'deopt_id()' as it asserts that the computation can
   // deoptimize.
-  f->Print("%s:%d(", DebugName(), deopt_id_);
+  f->Print("%s:%"Pd"(", DebugName(), deopt_id());
   PrintOperandsTo(f);
   f->Print(")");
 }
 
 
 void Definition::PrintOperandsTo(BufferFormatter* f) const {
   for (int i = 0; i < InputCount(); ++i) {
     if (i > 0) f->Print(", ");
     if (InputAt(i) != NULL) InputAt(i)->PrintTo(f);
   }
 }
 
 
 void Definition::PrintToVisualizer(BufferFormatter* f) const {
   PrintTo(f);
 }
 
 
 void Value::PrintTo(BufferFormatter* f) const {
   if (definition()->HasSSATemp()) {
-    f->Print("v%d", definition()->ssa_temp_index());
+    f->Print("v%"Pd"", definition()->ssa_temp_index());
   } else {
-    f->Print("t%d", definition()->temp_index());
+    f->Print("t%"Pd"", definition()->temp_index());
   }
 }
 
 
 void ConstantInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("#%s", value().ToCString());
 }
 
 
 void AssertAssignableInstr::PrintOperandsTo(BufferFormatter* f) const {
@@ skipping 12 matching lines @@
 
 
 void AssertBooleanInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   f->Print("%s", is_eliminated() ? " eliminated" : "");
 }
 
 
 void ArgumentDefinitionTestInstr::PrintOperandsTo(BufferFormatter* f) const {
   saved_arguments_descriptor()->PrintTo(f);
-  f->Print(", ?%s @%d",
+  f->Print(", ?%s @%"Pd"",
            formal_parameter_name().ToCString(),
            formal_parameter_index());
 }
 
 
 void ClosureCallInstr::PrintOperandsTo(BufferFormatter* f) const {
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
@@ skipping 41 matching lines @@
 void StaticCallInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s ", String::Handle(function().name()).ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
 void LoadLocalInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%s lvl:%d", local().name().ToCString(), context_level());
+  f->Print("%s lvl:%"Pd"", local().name().ToCString(), context_level());
 }
 
 
 void StoreLocalInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", local().name().ToCString());
   value()->PrintTo(f);
-  f->Print(", lvl: %d", context_level());
+  f->Print(", lvl: %"Pd"", context_level());
 }
 
 
 void NativeCallInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", native_name().ToCString());
 }
 
 
 void LoadInstanceFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", String::Handle(field().name()).ToCString());
@@ skipping 78 matching lines @@
   f->Print("%s", function().ToCString());
   for (intptr_t i = 0; i < ArgumentCount(); ++i) {
     if (i > 0) f->Print(", ");
     ArgumentAt(i)->value()->PrintTo(f);
   }
 }
 
 
 void LoadVMFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
-  f->Print(", %d", offset_in_bytes());
+  f->Print(", %"Pd"", offset_in_bytes());
 }
 
 
 void StoreVMFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   dest()->PrintTo(f);
-  f->Print(", %d, ", offset_in_bytes());
+  f->Print(", %"Pd", ", offset_in_bytes());
   value()->PrintTo(f);
 }
 
 
 void InstantiateTypeArgumentsInstr::PrintOperandsTo(BufferFormatter* f) const {
   const String& type_args = String::Handle(type_arguments().Name());
   f->Print("%s, ", type_args.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
 void ExtractConstructorTypeArgumentsInstr::PrintOperandsTo(
     BufferFormatter* f) const {
   const String& type_args = String::Handle(type_arguments().Name());
   f->Print("%s, ", type_args.ToCString());
   instantiator()->PrintTo(f);
 }
 
 
 void AllocateContextInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%d", num_context_variables());
+  f->Print("%"Pd"", num_context_variables());
 }
 
 
 void CatchEntryInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, %s",
            exception_var().name().ToCString(),
            stacktrace_var().name().ToCString());
 }
 
 
@@ skipping 27 matching lines @@
 }
 
 
 void CheckClassInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   PrintICData(f, unary_checks());
 }
 
 
 void GraphEntryInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("%2d: [graph]", block_id());
+  f->Print("%2"Pd": [graph]", block_id());
   if (start_env_ != NULL) {
     f->Print("\n{\n");
     const GrowableArray<Value*>& values = start_env_->values();
     for (intptr_t i = 0; i < values.length(); i++) {
       Definition* def = values[i]->definition();
-      f->Print("  ", i);
+      f->Print("  ");
       def->PrintTo(f);
       f->Print("\n");
     }
     f->Print("} ");
     start_env_->PrintTo(f);
   }
 }
 
 
 void JoinEntryInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("%2d: [join]", block_id());
+  f->Print("%2"Pd": [join]", block_id());
   if (phis_ != NULL) {
     for (intptr_t i = 0; i < phis_->length(); ++i) {
       if ((*phis_)[i] == NULL) continue;
       f->Print("\n");
       (*phis_)[i]->PrintTo(f);
     }
   }
   if (HasParallelMove()) {
     f->Print("\n");
     parallel_move()->PrintTo(f);
   }
 }
 
 
 static void PrintPropagatedType(BufferFormatter* f, const Definition& def) {
   if (def.HasPropagatedType()) {
     String& name = String::Handle();
     name = AbstractType::Handle(def.PropagatedType()).Name();
     f->Print(" {PT: %s}", name.ToCString());
   }
   if (def.has_propagated_cid()) {
     const Class& cls = Class::Handle(
         Isolate::Current()->class_table()->At(def.propagated_cid()));
     f->Print(" {PCid: %s}", String::Handle(cls.Name()).ToCString());
   }
 }
 
 
 void PhiInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("    v%d <- phi(", ssa_temp_index());
+  f->Print("    v%"Pd" <- phi(", ssa_temp_index());
   for (intptr_t i = 0; i < inputs_.length(); ++i) {
     if (inputs_[i] != NULL) inputs_[i]->PrintTo(f);
     if (i < inputs_.length() - 1) f->Print(", ");
   }
   f->Print(")");
   PrintPropagatedType(f, *this);
 }
 
 
 void ParameterInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("    v%d <- parameter(%d)",
+  f->Print("    v%"Pd" <- parameter(%"Pd")",
            HasSSATemp() ? ssa_temp_index() : temp_index(),
            index());
   PrintPropagatedType(f, *this);
 }
 
 
 void TargetEntryInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("%2d: [target", block_id());
+  f->Print("%2"Pd": [target", block_id());
   if (IsCatchEntry()) {
-    f->Print(" catch %d]", catch_try_index());
+    f->Print(" catch %"Pd"]", catch_try_index());
   } else {
     f->Print("]");
   }
   if (HasParallelMove()) {
     f->Print("\n");
     parallel_move()->PrintTo(f);
   }
 }
 
 
 void PushArgumentInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
   value()->PrintTo(f);
 }
 
 
 void ReturnInstr::PrintTo(BufferFormatter* f) const {
-  f->Print("    %s:%d ", DebugName(), deopt_id());
+  f->Print("    %s:%"Pd" ", DebugName(), deopt_id());
   value()->PrintTo(f);
 }
 
 
 void ThrowInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s" , DebugName());
 }
 
 
 void ReThrowInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
 }
 
 
 void GotoInstr::PrintTo(BufferFormatter* f) const {
   if (HasParallelMove()) {
     parallel_move()->PrintTo(f);
   } else {
     f->Print("    ");
   }
-  f->Print(" goto %d", successor()->block_id());
+  f->Print(" goto %"Pd"", successor()->block_id());
 }
 
 
 void BranchInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
   f->Print("if ");
   comparison()->PrintTo(f);
 
-  f->Print(" goto (%d, %d)",
+  f->Print(" goto (%"Pd", %"Pd")",
             true_successor()->block_id(),
             false_successor()->block_id());
 }
 
 
 void ParallelMoveInstr::PrintTo(BufferFormatter* f) const {
   f->Print("    %s ", DebugName());
   for (intptr_t i = 0; i < moves_.length(); i++) {
     if (i != 0) f->Print(", ");
     moves_[i]->dest().PrintTo(f);
     f->Print(" <- ");
     moves_[i]->src().PrintTo(f);
   }
 }
 
 
 void FlowGraphVisualizer::Print(const char* format, ...) {
   char str[1000];
   BufferFormatter f(str, sizeof(str));
-  f.Print("%*s", 2 * indent_, "");
+  f.Print("%*s", static_cast<int>(2 * indent_), "");
   va_list args;
   va_start(args, format);
   f.VPrint(format, args);
   va_end(args);
   (*Dart::flow_graph_writer())(str, strlen(str));
 }
 
 
 void FlowGraphVisualizer::PrintInstruction(Instruction* instr) {
   char str[1000];
@@ skipping 24 matching lines @@
     END("compilation");
   }
 
   {
     BEGIN("cfg");
     Print("%s \"%s\"\n", "name", "Flow graph builder");
 
     for (intptr_t i = 0; i < block_order_.length(); ++i) {
       BEGIN("block");
       BlockEntryInstr* entry = block_order_[i];
-      Print("%s \"B%d\"\n", "name", entry->block_id());
+      Print("%s \"B%"Pd"\"\n", "name", entry->block_id());
       Print("%s %d\n", "from_bci", -1);  // Required field. Unused.
       Print("%s %d\n", "to_bci", -1);  // Required field. Unused.
 
       Print("predecessors");
       for (intptr_t j = 0; j < entry->PredecessorCount(); ++j) {
         BlockEntryInstr* pred = entry->PredecessorAt(j);
-        Print(" \"B%d\"", pred->block_id());
+        Print(" \"B%"Pd"\"", pred->block_id());
       }
       Print("\n");
 
       Print("successors");
       Instruction* last = entry->last_instruction();
       for (intptr_t j = 0; j < last->SuccessorCount(); ++j) {
         intptr_t next_id = last->SuccessorAt(j)->block_id();
-        Print(" \"B%d\"", next_id);
+        Print(" \"B%"Pd"\"", next_id);
       }
       Print("\n");
 
       // TODO(fschneider): Use this for exception handlers.
       Print("xhandlers\n");
 
       // Can be freely used to mark blocks
       Print("flags\n");
 
       if (entry->dominator() != NULL) {
-        Print("%s \"B%d\"\n", "dominator", entry->dominator()->block_id());
+        Print("%s \"B%"Pd"\"\n", "dominator", entry->dominator()->block_id());
       }
 
       // TODO(fschneider): Mark blocks with loop nesting level.
       Print("%s %d\n", "loop_depth", 0);
 
       {
         BEGIN("states");  // Required section.
         {
           BEGIN("locals");  // Required section.
           JoinEntryInstr* join = entry->AsJoinEntry();
           intptr_t num_phis = (join != NULL && join->phi_count())
               ? join->phis()->length()
               : 0;
-          Print("%s %d\n", "size", num_phis);
+          Print("%s %"Pd"\n", "size", num_phis);
           for (intptr_t j = 0; j < num_phis; ++j) {
             PhiInstr* phi = (*join->phis())[j];
             if (phi != NULL) {
-              Print("%d ", j);  // Print variable index.
+              Print("%"Pd" ", j);  // Print variable index.
               char buffer[120];
               BufferFormatter formatter(buffer, sizeof(buffer));
               phi->PrintToVisualizer(&formatter);
               Print("%s\n", buffer);
             }
           }
           END("locals");
         }
         END("states");
       }
 
       {
         BEGIN("HIR");
         // Print the block entry.
         Print("0 0 ");  // Required fields "bci" and "use". Unused.
         PrintInstruction(block_order_[i]);
         // And all the successors until an exit, branch, or a block entry.
         BlockEntryInstr* entry = block_order_[i];
         Instruction* current = entry;
         for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
           current = it.Current();
           Print("0 0 ");
           PrintInstruction(current);
         }
         if (current->next() != NULL) {
           ASSERT(current->next()->IsBlockEntry());
-          Print("0 0 _ Goto B%d <|@\n",
+          Print("0 0 _ Goto B%"Pd" <|@\n",
                 current->next()->AsBlockEntry()->block_id());
         }
         END("HIR");
       }
       END("block");
     }
     END("cfg");
   }
 #undef BEGIN
 #undef END
@@ skipping 10 matching lines @@
   }
 }
 
 
 void JoinEntryInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ [join]");
 }
 
 
 void PhiInstr::PrintToVisualizer(BufferFormatter* f) const {
-  f->Print("v%d [", ssa_temp_index());
+  f->Print("v%"Pd" [", ssa_temp_index());
   for (intptr_t i = 0; i < InputCount(); ++i) {
     if (i > 0) f->Print(" ");
     InputAt(i)->PrintTo(f);
   }
   f->Print("]");
 }
 
 
 void ParameterInstr::PrintToVisualizer(BufferFormatter* f) const {
   ASSERT(HasSSATemp());
   ASSERT(temp_index() == -1);
-  f->Print("v%d Parameter(%d)", ssa_temp_index(), index());
+  f->Print("v%"Pd" Parameter(%"Pd")", ssa_temp_index(), index());
 }
 
 
 void TargetEntryInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ [target");
   if (IsCatchEntry()) {
-    f->Print(" catch %d]", catch_try_index());
+    f->Print(" catch %"Pd"]", catch_try_index());
   } else {
     f->Print("]");
   }
 }
 
 
 void PushArgumentInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s ", DebugName());
   value()->PrintTo(f);
 }
 
 
 void ReturnInstr::PrintToVisualizer(BufferFormatter* f) const {
-  f->Print("_ %s:%d ", DebugName(), deopt_id());
+  f->Print("_ %s:%"Pd" ", DebugName(), deopt_id());
   value()->PrintTo(f);
 }
 
 
 void ThrowInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s ", DebugName());
 }
 
 
 void ReThrowInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s ", DebugName());
 }
 
 
 void GotoInstr::PrintToVisualizer(BufferFormatter* f) const {
-  f->Print("_ goto B%d", successor()->block_id());
+  f->Print("_ goto B%"Pd"", successor()->block_id());
 }
 
 
 void BranchInstr::PrintToVisualizer(BufferFormatter* f) const {
   f->Print("_ %s ", DebugName());
   f->Print("if ");
   comparison()->PrintTo(f);
-  f->Print(" goto (B%d, B%d)",
+  f->Print(" goto (B%"Pd", B%"Pd")",
             true_successor()->block_id(),
             false_successor()->block_id());
 }
 
 
 void ParallelMoveInstr::PrintToVisualizer(BufferFormatter* f) const {
   UNIMPLEMENTED();
 }
 
 
 void Environment::PrintTo(BufferFormatter* f) const {
   f->Print(" env={ ");
   for (intptr_t i = 0; i < values_.length(); ++i) {
     if (i > 0) f->Print(", ");
     values_[i]->PrintTo(f);
     if ((locations_ != NULL) && !locations_[i].IsInvalid()) {
       f->Print(" [");
       locations_[i].PrintTo(f);
       f->Print("]");
     }
   }
   f->Print(" }");
 }
 
 }  // namespace dart