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

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 342 matching lines @@
     const AbstractType& type,
     const AbstractTypeArguments& instantiator_type_arguments,
     const Bool& result) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
 
   const Type& instance_type = Type::Handle(instance.GetType());
   ASSERT(instance_type.IsInstantiated());
   if (type.IsInstantiated()) {
-    OS::Print("%s: '%s' %d %s '%s' %d (pc: 0x%x).\n",
+    OS::Print("%s: '%s' %"Pd" %s '%s' %"Pd" (pc: %#"Px").\n",
               message,
               String::Handle(instance_type.Name()).ToCString(),
               Class::Handle(instance_type.type_class()).id(),
               (result.raw() == Bool::True()) ? "is" : "is !",
               String::Handle(type.Name()).ToCString(),
               Class::Handle(type.type_class()).id(),
               caller_frame->pc());
   } else {
     // Instantiate type before printing.
     const AbstractType& instantiated_type =
         AbstractType::Handle(type.InstantiateFrom(instantiator_type_arguments));
-    OS::Print("%s: '%s' %s '%s' instantiated from '%s' (pc: 0x%x).\n",
+    OS::Print("%s: '%s' %s '%s' instantiated from '%s' (pc: %#"Px").\n",
               message,
               String::Handle(instance_type.Name()).ToCString(),
               (result.raw() == Bool::True()) ? "is" : "is !",
               String::Handle(instantiated_type.Name()).ToCString(),
               String::Handle(type.Name()).ToCString(),
               caller_frame->pc());
   }
   const Function& function = Function::Handle(
       caller_frame->LookupDartFunction());
   OS::Print(" -> Function %s\n", function.ToFullyQualifiedCString());
@@ skipping 111 matching lines @@
         i,
         &last_instance_class_id,
         &last_instance_type_arguments,
         &last_instantiator_type_arguments,
         &last_result);
     if ((last_instance_class_id == instance_class.id()) &&
         (last_instance_type_arguments.raw() == instance_type_arguments.raw()) &&
         (last_instantiator_type_arguments.raw() ==
          instantiator_type_arguments.raw())) {
       if (FLAG_trace_type_checks) {
-        OS::Print("%d ", i);
+        OS::Print("%"Pd" ", i);
         if (type_arguments_replaced) {
           PrintTypeCheck("Duplicate cache entry (canonical.)", instance, type,
               instantiator_type_arguments, result);
         } else {
           PrintTypeCheck("WARNING Duplicate cache entry", instance, type,
               instantiator_type_arguments, result);
         }
       }
       // Can occur if we have canonicalized arguments.
       // TODO(srdjan): Investigate why this assert can fail.
       // ASSERT(type_arguments_replaced);
       return;
     }
   }
   new_cache.AddCheck(instance_class.id(),
                      instance_type_arguments,
                      instantiator_type_arguments,
                      result);
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
       test_type = type.InstantiateFrom(instantiator_type_arguments);
     }
-    OS::Print("  Updated test cache 0x%x ix:%d:\n"
-        "    [0x%x %s %d, 0x%x %s]\n"
-        "    [0x%x %s %d, 0x%x %s] %s\n",
+    OS::Print("  Updated test cache %p ix:%"Pd":\n"
+        "    [%p %s %"Pd", %p %s]\n"
+        "    [%p %s %"Pd", %p %s] %s\n",
         new_cache.raw(),
         len,
         instance_class.raw(),
         instance_class.ToCString(),
         instance_class.id(),
         instance_type_arguments.raw(),
         instance_type_arguments.ToCString(),
         test_type.type_class(),
         Class::Handle(test_type.type_class()).ToCString(),
         Class::Handle(test_type.type_class()).id(),
@@ skipping 209 matching lines @@
   ASSERT(caller_frame != NULL);
   uword target = 0;
   Function& target_function = Function::Handle();
   CodePatcher::GetStaticCallAt(caller_frame->pc(), &target_function, &target);
   ASSERT(target_function.HasCode());
   uword new_target = Code::Handle(target_function.CurrentCode()).EntryPoint();
   // Verify that we are not patching repeatedly.
   ASSERT(target != new_target);
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), new_target);
   if (FLAG_trace_patching) {
-    OS::Print("PatchStaticCall: patching from 0x%x to '%s' 0x%x\n",
+    OS::Print("PatchStaticCall: patching from %#"Px" to '%s' %#"Px"\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         new_target);
   }
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
 // function cache of the receiver's class and returns the compiled code or null.
 // Only the number of named arguments is checked, but not the actual names.
@@ skipping 140 matching lines @@
                              target_function);
   } else {
     GrowableArray<intptr_t> class_ids(args.length());
     ASSERT(ic_data.num_args_tested() == args.length());
     for (intptr_t i = 0; i < args.length(); i++) {
       class_ids.Add(Class::Handle(args[i]->clazz()).id());
     }
     ic_data.AddCheck(class_ids, target_function);
   }
   if (FLAG_trace_ic) {
-    OS::Print("InlineCacheMissHandler %d call at 0x%x' "
-              "adding <%s> id:%d -> <%s>\n",
+    OS::Print("InlineCacheMissHandler %d call at %#"Px"' "
+              "adding <%s> id:%"Pd" -> <%s>\n",
         args.length(),
         caller_frame->pc(),
         Class::Handle(receiver.clazz()).ToCString(),
         Class::Handle(receiver.clazz()).id(),
         target_function.ToCString());
   }
   return target_function.raw();
 }
 
 
@@ skipping 340 matching lines @@
   }
 }
 
 
 static void PrintCaller(const char* msg) {
   DartFrameIterator iterator;
   StackFrame* top_frame = iterator.NextFrame();
   ASSERT(top_frame != NULL);
   const Function& top_function = Function::Handle(
       top_frame->LookupDartFunction());
-  OS::Print("Failed: '%s' %s @ 0x%x\n",
+  OS::Print("Failed: '%s' %s @ %#"Px"\n",
       msg, top_function.ToFullyQualifiedCString(), top_frame->pc());
   StackFrame* caller_frame = iterator.NextFrame();
   if (caller_frame != NULL) {
     const Function& caller_function = Function::Handle(
         caller_frame->LookupDartFunction());
     const Code& code = Code::Handle(caller_frame->LookupDartCode());
     OS::Print("  -> caller: %s (%s)\n",
         caller_function.ToFullyQualifiedCString(),
         code.is_optimized() ? "optimized" : "unoptimized");
   }
@@ skipping 81 matching lines @@
     ASSERT(frame->IsDartFrame());
     uword target = 0;
     Function& target_function = Function::Handle();
     CodePatcher::GetStaticCallAt(frame->pc(), &target_function, &target);
     ASSERT(target_function.HasCode());
     const uword new_entry_point =
         Code::Handle(function.CurrentCode()).EntryPoint();
     ASSERT(target != new_entry_point);  // Why patch otherwise.
     CodePatcher::PatchStaticCallAt(frame->pc(), new_entry_point);
     if (FLAG_trace_patching) {
-      OS::Print("FixCallersTarget: patching from 0x%x to '%s' 0x%x\n",
+      OS::Print("FixCallersTarget: patching from %#"Px" to '%s' %#"Px"\n",
           frame->pc(),
           target_function.ToFullyQualifiedCString(),
           new_entry_point);
     }
   }
 }
 
 
 static const char* DeoptReasonToText(intptr_t deopt_id) {
   switch (deopt_id) {
@@ skipping 130 matching lines @@
   intptr_t deopt_id, deopt_reason, deopt_index;
   GetDeoptIxDescrAtPc(optimized_code, caller_frame->pc(),
                       &deopt_id, &deopt_reason, &deopt_index);
   ASSERT(deopt_id != Isolate::kNoDeoptId);
 
   CopyFrame(optimized_code, *caller_frame);
   if (FLAG_trace_deopt) {
     intptr_t deopt_id, deopt_reason, deopt_index;
     GetDeoptIxDescrAtPc(optimized_code, caller_frame->pc(),
                         &deopt_id, &deopt_reason, &deopt_index);
-    OS::Print("Deoptimizing (reason %d '%s') at pc 0x%x id %d '%s'\n",
+    OS::Print("Deoptimizing (reason %"Pd" '%s') at pc %#"Px" id %"Pd" '%s'\n",
         deopt_reason,
         DeoptReasonToText(deopt_reason),
         caller_frame->pc(),
         deopt_id,
         Function::Handle(optimized_code.function()).ToFullyQualifiedCString());
   }
 
   // Compute the stack size of unoptimized frame
   const Array& deopt_info_array =
       Array::Handle(optimized_code.deopt_info_array());
@@ skipping 36 matching lines @@
       + num_args;
   DeoptimizationContext deopt_context(start,
                                       to_frame_size,
                                       Array::Handle(code.object_table()),
                                       num_args);
   for (intptr_t to_index = 0; to_index < len; to_index++) {
     deopt_instructions[to_index]->Execute(&deopt_context, to_index);
   }
   if (FLAG_trace_deopt) {
     for (intptr_t i = 0; i < len; i++) {
-      OS::Print("*%d. [0x%0" PRIxPTR "] 0x%012" PRIxPTR " [%s]\n",
+      OS::Print("*%"Pd". [%p] %#014"Px" [%s]\n",
           i,
           &start[i],
           start[i],
           deopt_instructions[i]->ToCString());
     }
   }
 }
 
 
 // The stack has been adjusted to fit all values for unoptimized frame.
@@ skipping 16 matching lines @@
   intptr_t* frame_copy = isolate->deopt_frame_copy();
   intptr_t* cpu_registers_copy = isolate->deopt_cpu_registers_copy();
   double* xmm_registers_copy = isolate->deopt_xmm_registers_copy();
 
   intptr_t deopt_id, deopt_reason, deopt_index;
   GetDeoptIxDescrAtPc(optimized_code, caller_frame->pc(),
                       &deopt_id, &deopt_reason, &deopt_index);
   ASSERT(deopt_id != Isolate::kNoDeoptId);
   uword continue_at_pc = unoptimized_code.GetDeoptBeforePcAtDeoptId(deopt_id);
   if (FLAG_trace_deopt) {
-    OS::Print("  -> continue at 0x%x\n", continue_at_pc);
+    OS::Print("  -> continue at %#"Px"\n", continue_at_pc);
     // TODO(srdjan): If we could allow GC, we could print the line where
     // deoptimization occured.
   }
   const Array& deopt_info_array =
       Array::Handle(optimized_code.deopt_info_array());
   ASSERT(!deopt_info_array.IsNull());
   DeoptInfo& deopt_info = DeoptInfo::Handle();
   deopt_info ^= deopt_info_array.At(deopt_index);
   ASSERT(!deopt_info.IsNull());
   DeoptimizeWithDeoptInfo(optimized_code, deopt_info, *caller_frame);
@@ skipping 21 matching lines @@
   DeferredDouble* deferred_double = Isolate::Current()->DetachDeferredDoubles();
 
   while (deferred_double != NULL) {
     DeferredDouble* current = deferred_double;
     deferred_double = deferred_double->next();
 
     RawDouble** slot = current->slot();
     *slot = Double::New(current->value());
 
     if (FLAG_trace_deopt) {
-      OS::Print("materialing double at 0x%" PRIxPTR ": %g\n",
+      OS::Print("materialing double at %p: %g\n",
                 current->slot(),
                 current->value());
     }
 
     delete current;
   }
 }
 
 
 }  // namespace dart