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

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 91 matching lines @@
   return Error::null();
 }
 
 
 static void InstallUnoptimizedCode(const Function& function) {
   // Disable optimized code.
   ASSERT(function.HasOptimizedCode());
   // Patch entry of optimized code.
   CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
   if (FLAG_trace_compiler) {
-    OS::Print("--> patching entry 0x%x\n",
+    OS::Print("--> patching entry %#"Px"\n",
               Code::Handle(function.CurrentCode()).EntryPoint());
   }
   // Use previously compiled code.
   function.SetCode(Code::Handle(function.unoptimized_code()));
   CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
   if (FLAG_trace_compiler) {
-    OS::Print("--> restoring entry at 0x%x\n",
+    OS::Print("--> restoring entry at %#"Px"\n",
               Code::Handle(function.unoptimized_code()).EntryPoint());
   }
 }
 
 
 // Return false if bailed out.
 static bool CompileParsedFunctionHelper(const ParsedFunction& parsed_function,
                                         bool optimized) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
@@ skipping 123 matching lines @@
       graph_compiler.FinalizePcDescriptors(code);
       graph_compiler.FinalizeDeoptInfo(code);
       graph_compiler.FinalizeStackmaps(code);
       graph_compiler.FinalizeVarDescriptors(code);
       graph_compiler.FinalizeExceptionHandlers(code);
       graph_compiler.FinalizeComments(code);
       if (optimized) {
         function.SetCode(code);
         CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
         if (FLAG_trace_compiler) {
-          OS::Print("--> patching entry 0x%x\n",
+          OS::Print("--> patching entry %#"Px"\n",
                     Code::Handle(function.unoptimized_code()).EntryPoint());
         }
       } else {
         function.set_unoptimized_code(code);
         function.SetCode(code);
         ASSERT(CodePatcher::CodeIsPatchable(code));
       }
     }
     is_compiled = true;
   } else {
@@ skipping 29 matching lines @@
                             start + instructions.size(),
                             code.comments());
   OS::Print("}\n");
 
   OS::Print("Pointer offsets for function: {\n");
   // Pointer offsets are stored in descending order.
   for (intptr_t i = code.pointer_offsets_length() - 1; i >= 0; i--) {
     const uword addr = code.GetPointerOffsetAt(i) + code.EntryPoint();
     Object& obj = Object::Handle();
     obj = *reinterpret_cast<RawObject**>(addr);
-    OS::Print(" %" PRIdPTR " : 0x%" PRIxPTR " '%s'\n",
+    OS::Print(" %d : %#"Px" '%s'\n",
               code.GetPointerOffsetAt(i), addr, obj.ToCString());
   }
   OS::Print("}\n");
 
   OS::Print("PC Descriptors for function '%s' {\n", function_fullname);
   PcDescriptors::PrintHeaderString();
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   OS::Print("%s}\n", descriptors.ToCString());
 
   const Array& deopt_info_array = Array::Handle(code.deopt_info_array());
   if (deopt_info_array.Length() > 0) {
     OS::Print("DeoptInfo: {\n");
     for (intptr_t i = 0; i < deopt_info_array.Length(); i++) {
-      OS::Print("  %d: %s\n",
+      OS::Print("  %"Pd": %s\n",
           i, Object::Handle(deopt_info_array.At(i)).ToCString());
     }
     OS::Print("}\n");
   }
 
   const Array& object_table = Array::Handle(code.object_table());
   if (object_table.Length() > 0) {
     OS::Print("Object Table: {\n");
     for (intptr_t i = 0; i < object_table.Length(); i++) {
-      OS::Print("  %d: %s\n", i,
+      OS::Print("  %"Pd": %s\n", i,
           Object::Handle(object_table.At(i)).ToCString());
     }
     OS::Print("}\n");
   }
 
   OS::Print("Stackmaps for function '%s' {\n", function_fullname);
   if (code.stackmaps() != Array::null()) {
     const Array& stackmap_table = Array::Handle(code.stackmaps());
     Stackmap& map = Stackmap::Handle();
     for (intptr_t i = 0; i < stackmap_table.Length(); ++i) {
       map ^= stackmap_table.At(i);
       OS::Print("%s\n", map.ToCString());
     }
   }
   OS::Print("}\n");
 
   OS::Print("Variable Descriptors for function '%s' {\n",
             function_fullname);
   const LocalVarDescriptors& var_descriptors =
       LocalVarDescriptors::Handle(code.var_descriptors());
   intptr_t var_desc_length =
       var_descriptors.IsNull() ? 0 : var_descriptors.Length();
   String& var_name = String::Handle();
   for (intptr_t i = 0; i < var_desc_length; i++) {
     var_name = var_descriptors.GetName(i);
     RawLocalVarDescriptors::VarInfo var_info;
     var_descriptors.GetInfo(i, &var_info);
     if (var_info.kind == RawLocalVarDescriptors::kContextChain) {
-      OS::Print("  saved CTX reg offset %" PRIdPTR "\n", var_info.index);
+      OS::Print("  saved CTX reg offset %"Pd"\n", var_info.index);
     } else {
       if (var_info.kind == RawLocalVarDescriptors::kContextLevel) {
-        OS::Print("  context level %" PRIdPTR " scope %d",
+        OS::Print("  context level %"Pd" scope %d",
                   var_info.index, var_info.scope_id);
       } else if (var_info.kind == RawLocalVarDescriptors::kStackVar) {
-        OS::Print("  stack var '%s' offset %" PRIdPTR,
+        OS::Print("  stack var '%s' offset %"Pd"",
                   var_name.ToCString(), var_info.index);
       } else {
         ASSERT(var_info.kind == RawLocalVarDescriptors::kContextVar);
-        OS::Print("  context var '%s' level %d offset %" PRIdPTR,
+        OS::Print("  context var '%s' level %d offset %"Pd"",
                   var_name.ToCString(), var_info.scope_id, var_info.index);
       }
-      OS::Print(" (valid %" PRIdPTR "-%" PRIdPTR ")\n",
+      OS::Print(" (valid %"Pd"-%"Pd")\n",
                 var_info.begin_pos, var_info.end_pos);
     }
   }
   OS::Print("}\n");
 
   OS::Print("Exception Handlers for function '%s' {\n", function_fullname);
   const ExceptionHandlers& handlers =
         ExceptionHandlers::Handle(code.exception_handlers());
   OS::Print("%s}\n", handlers.ToCString());
 }
 
 
 static RawError* CompileFunctionHelper(const Function& function,
                                        bool optimized) {
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   // Skips parsing if we need to only install unoptimized code.
   if (!optimized && !Code::Handle(function.unoptimized_code()).IsNull()) {
     InstallUnoptimizedCode(function);
     isolate->set_long_jump_base(base);
     return Error::null();
   }
   if (setjmp(*jump.Set()) == 0) {
     TIMERSCOPE(time_compilation);
     ParsedFunction parsed_function(function);
     if (FLAG_trace_compiler) {
-      OS::Print("Compiling %sfunction: '%s' @ token %d\n",
+      OS::Print("Compiling %sfunction: '%s' @ token %"Pd"\n",
                 (optimized ? "optimized " : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos());
     }
     Parser::ParseFunction(&parsed_function);
     parsed_function.AllocateVariables();
 
     const bool success =
         CompileParsedFunctionHelper(parsed_function, optimized);
     if (optimized && !success) {
       // Optimizer bailed out. Disable optimizations and to never try again.
       if (FLAG_trace_compiler) {
         OS::Print("--> disabling optimizations for '%s'\n",
                   function.ToFullyQualifiedCString());
       }
       function.set_is_optimizable(false);
       isolate->set_long_jump_base(base);
       return Error::null();
     }
 
     ASSERT(success);
 
     if (FLAG_trace_compiler) {
-      OS::Print("--> '%s' entry: 0x%x\n",
+      OS::Print("--> '%s' entry: %#"Px"\n",
                 function.ToFullyQualifiedCString(),
                 Code::Handle(function.CurrentCode()).EntryPoint());
     }
 
     if (Isolate::Current()->debugger()->IsActive()) {
       Isolate::Current()->debugger()->NotifyCompilation(function);
     }
 
     if (FLAG_disassemble) {
       DisassembleCode(function, optimized);
@@ skipping 127 matching lines @@
     result = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart