[V8]Rename PrintF to FPrintF for file calls

Due to the fact that Windows CE defines File
to something very similar to const char *, the
compiler cannot differentiate anymore between
File* and const char*, so the function needs to
be renamed. In the std these function also is
called fprintf, so it seems to be a well known
problem.

Change-Id: I1d7d44a6325ec9f3de4b7496ae0a2d4ceb0512e6
Reviewed-by: Janne Anttila <janne.anttila@digia.com>
Reviewed-by: Lars Knoll <lars.knoll@digia.com>
Reviewed-by: Peter Varga <pvarga@inf.u-szeged.hu>

9 files changed, 334 insertions, 334 deletions

diff --git a/src/3rdparty/v8/src/assembler.cc b/src/3rdparty/v8/src/assembler.cc
index 1027987..c0867dd 100644
--- a/src/3rdparty/v8/src/assembler.cc
+++ b/src/3rdparty/v8/src/assembler.cc
@@ -682,38 +682,38 @@ const char* RelocInfo::RelocModeName(RelocInfo::Mode rmode) {
 
 
 void RelocInfo::Print(FILE* out) {
-  PrintF(out, "%p  %s", pc_, RelocModeName(rmode_));
+  FPrintF(out, "%p  %s", pc_, RelocModeName(rmode_));
   if (IsComment(rmode_)) {
-    PrintF(out, "  (%s)", reinterpret_cast<char*>(data_));
+    FPrintF(out, "  (%s)", reinterpret_cast<char*>(data_));
   } else if (rmode_ == EMBEDDED_OBJECT) {
-    PrintF(out, "  (");
+    FPrintF(out, "  (");
     target_object()->ShortPrint(out);
-    PrintF(out, ")");
+    FPrintF(out, ")");
   } else if (rmode_ == EXTERNAL_REFERENCE) {
     ExternalReferenceEncoder ref_encoder;
-    PrintF(out, " (%s)  (%p)",
+    FPrintF(out, " (%s)  (%p)",
            ref_encoder.NameOfAddress(*target_reference_address()),
            *target_reference_address());
   } else if (IsCodeTarget(rmode_)) {
     Code* code = Code::GetCodeFromTargetAddress(target_address());
-    PrintF(out, " (%s)  (%p)", Code::Kind2String(code->kind()),
+    FPrintF(out, " (%s)  (%p)", Code::Kind2String(code->kind()),
            target_address());
     if (rmode_ == CODE_TARGET_WITH_ID) {
       PrintF(" (id=%d)", static_cast<int>(data_));
     }
   } else if (IsPosition(rmode_)) {
-    PrintF(out, "  (%" V8_PTR_PREFIX "d)", data());
+    FPrintF(out, "  (%" V8_PTR_PREFIX "d)", data());
   } else if (rmode_ == RelocInfo::RUNTIME_ENTRY &&
              Isolate::Current()->deoptimizer_data() != NULL) {
     // Depotimization bailouts are stored as runtime entries.
     int id = Deoptimizer::GetDeoptimizationId(
         target_address(), Deoptimizer::EAGER);
     if (id != Deoptimizer::kNotDeoptimizationEntry) {
-      PrintF(out, "  (deoptimization bailout %d)", id);
+      FPrintF(out, "  (deoptimization bailout %d)", id);
     }
   }
 
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 #endif  // ENABLE_DISASSEMBLER
 
diff --git a/src/3rdparty/v8/src/elements-kind.cc b/src/3rdparty/v8/src/elements-kind.cc
index 7b1651a..19fac44 100644
--- a/src/3rdparty/v8/src/elements-kind.cc
+++ b/src/3rdparty/v8/src/elements-kind.cc
@@ -42,7 +42,7 @@ const char* ElementsKindToString(ElementsKind kind) {
 
 
 void PrintElementsKind(FILE* out, ElementsKind kind) {
-  PrintF(out, "%s", ElementsKindToString(kind));
+  FPrintF(out, "%s", ElementsKindToString(kind));
 }
 
 
diff --git a/src/3rdparty/v8/src/frames.cc b/src/3rdparty/v8/src/frames.cc
index 3b60fb5..6342852 100644
--- a/src/3rdparty/v8/src/frames.cc
+++ b/src/3rdparty/v8/src/frames.cc
@@ -761,7 +761,7 @@ void JavaScriptFrame::PrintTop(FILE* file,
   while (!it.done()) {
     if (it.frame()->is_java_script()) {
       JavaScriptFrame* frame = it.frame();
-      if (frame->IsConstructor()) PrintF(file, "new ");
+      if (frame->IsConstructor()) FPrintF(file, "new ");
       // function name
       Object* maybe_fun = frame->function();
       if (maybe_fun->IsJSFunction()) {
@@ -787,12 +787,12 @@ void JavaScriptFrame::PrintTop(FILE* file,
               SmartArrayPointer<char> c_script_name =
                   script_name->ToCString(DISALLOW_NULLS,
                                          ROBUST_STRING_TRAVERSAL);
-              PrintF(file, " at %s:%d", *c_script_name, line);
+              FPrintF(file, " at %s:%d", *c_script_name, line);
             } else {
-              PrintF(file, " at <unknown>:%d", line);
+              FPrintF(file, " at <unknown>:%d", line);
             }
           } else {
-            PrintF(file, " at <unknown>:<unknown>");
+            FPrintF(file, " at <unknown>:<unknown>");
           }
         }
       } else {
@@ -803,14 +803,14 @@ void JavaScriptFrame::PrintTop(FILE* file,
         // function arguments
         // (we are intentionally only printing the actually
         // supplied parameters, not all parameters required)
-        PrintF(file, "(this=");
+        FPrintF(file, "(this=");
         frame->receiver()->ShortPrint(file);
         const int length = frame->ComputeParametersCount();
         for (int i = 0; i < length; i++) {
-          PrintF(file, ", ");
+          FPrintF(file, ", ");
           frame->GetParameter(i)->ShortPrint(file);
         }
-        PrintF(file, ")");
+        FPrintF(file, ")");
       }
       break;
     }
diff --git a/src/3rdparty/v8/src/objects-printer.cc b/src/3rdparty/v8/src/objects-printer.cc
index b1118de..6e87c7a 100644
--- a/src/3rdparty/v8/src/objects-printer.cc
+++ b/src/3rdparty/v8/src/objects-printer.cc
@@ -57,12 +57,12 @@ void MaybeObject::Print(FILE* out) {
 
 void MaybeObject::PrintLn(FILE* out) {
   Print(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void HeapObject::PrintHeader(FILE* out, const char* id) {
-  PrintF(out, "%p: [%s]\n", reinterpret_cast<void*>(this), id);
+  FPrintF(out, "%p: [%s]\n", reinterpret_cast<void*>(this), id);
 }
 
 
@@ -124,7 +124,7 @@ void HeapObject::HeapObjectPrint(FILE* out) {
       ExternalDoubleArray::cast(this)->ExternalDoubleArrayPrint(out);
       break;
     case FILLER_TYPE:
-      PrintF(out, "filler");
+      FPrintF(out, "filler");
       break;
     case JS_OBJECT_TYPE:  // fall through
     case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
@@ -151,7 +151,7 @@ void HeapObject::HeapObjectPrint(FILE* out) {
       JSBuiltinsObject::cast(this)->JSBuiltinsObjectPrint(out);
       break;
     case JS_VALUE_TYPE:
-      PrintF(out, "Value wrapper around:");
+      FPrintF(out, "Value wrapper around:");
       JSValue::cast(this)->value()->Print(out);
       break;
     case JS_DATE_TYPE:
@@ -189,7 +189,7 @@ void HeapObject::HeapObjectPrint(FILE* out) {
 #undef MAKE_STRUCT_CASE
 
     default:
-      PrintF(out, "UNKNOWN TYPE %d", map()->instance_type());
+      FPrintF(out, "UNKNOWN TYPE %d", map()->instance_type());
       UNREACHABLE();
       break;
   }
@@ -197,57 +197,57 @@ void HeapObject::HeapObjectPrint(FILE* out) {
 
 
 void ByteArray::ByteArrayPrint(FILE* out) {
-  PrintF(out, "byte array, data starts at %p", GetDataStartAddress());
+  FPrintF(out, "byte array, data starts at %p", GetDataStartAddress());
 }
 
 
 void FreeSpace::FreeSpacePrint(FILE* out) {
-  PrintF(out, "free space, size %d", Size());
+  FPrintF(out, "free space, size %d", Size());
 }
 
 
 void ExternalPixelArray::ExternalPixelArrayPrint(FILE* out) {
-  PrintF(out, "external pixel array");
+  FPrintF(out, "external pixel array");
 }
 
 
 void ExternalByteArray::ExternalByteArrayPrint(FILE* out) {
-  PrintF(out, "external byte array");
+  FPrintF(out, "external byte array");
 }
 
 
 void ExternalUnsignedByteArray::ExternalUnsignedByteArrayPrint(FILE* out) {
-  PrintF(out, "external unsigned byte array");
+  FPrintF(out, "external unsigned byte array");
 }
 
 
 void ExternalShortArray::ExternalShortArrayPrint(FILE* out) {
-  PrintF(out, "external short array");
+  FPrintF(out, "external short array");
 }
 
 
 void ExternalUnsignedShortArray::ExternalUnsignedShortArrayPrint(FILE* out) {
-  PrintF(out, "external unsigned short array");
+  FPrintF(out, "external unsigned short array");
 }
 
 
 void ExternalIntArray::ExternalIntArrayPrint(FILE* out) {
-  PrintF(out, "external int array");
+  FPrintF(out, "external int array");
 }
 
 
 void ExternalUnsignedIntArray::ExternalUnsignedIntArrayPrint(FILE* out) {
-  PrintF(out, "external unsigned int array");
+  FPrintF(out, "external unsigned int array");
 }
 
 
 void ExternalFloatArray::ExternalFloatArrayPrint(FILE* out) {
-  PrintF(out, "external float array");
+  FPrintF(out, "external float array");
 }
 
 
 void ExternalDoubleArray::ExternalDoubleArrayPrint(FILE* out) {
-  PrintF(out, "external double array");
+  FPrintF(out, "external double array");
 }
 
 
@@ -255,23 +255,23 @@ void JSObject::PrintProperties(FILE* out) {
   if (HasFastProperties()) {
     DescriptorArray* descs = map()->instance_descriptors();
     for (int i = 0; i < map()->NumberOfOwnDescriptors(); i++) {
-      PrintF(out, "   ");
+      FPrintF(out, "   ");
       descs->GetKey(i)->StringPrint(out);
-      PrintF(out, ": ");
+      FPrintF(out, ": ");
       switch (descs->GetType(i)) {
         case FIELD: {
           int index = descs->GetFieldIndex(i);
           FastPropertyAt(index)->ShortPrint(out);
-          PrintF(out, " (field at offset %d)\n", index);
+          FPrintF(out, " (field at offset %d)\n", index);
           break;
         }
         case CONSTANT_FUNCTION:
           descs->GetConstantFunction(i)->ShortPrint(out);
-          PrintF(out, " (constant function)\n");
+          FPrintF(out, " (constant function)\n");
           break;
         case CALLBACKS:
           descs->GetCallbacksObject(i)->ShortPrint(out);
-          PrintF(out, " (callback)\n");
+          FPrintF(out, " (callback)\n");
           break;
         case NORMAL:  // only in slow mode
         case HANDLER:  // only in lookup results, not in descriptors
@@ -300,9 +300,9 @@ void JSObject::PrintElements(FILE* out) {
       // Print in array notation for non-sparse arrays.
       FixedArray* p = FixedArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: ", i);
+        FPrintF(out, "   %d: ", i);
         p->get(i)->ShortPrint(out);
-        PrintF(out, "\n");
+        FPrintF(out, "\n");
       }
       break;
     }
@@ -313,11 +313,11 @@ void JSObject::PrintElements(FILE* out) {
         FixedDoubleArray* p = FixedDoubleArray::cast(elements());
         for (int i = 0; i < p->length(); i++) {
           if (p->is_the_hole(i)) {
-            PrintF(out, "   %d: <the hole>", i);
+            FPrintF(out, "   %d: <the hole>", i);
           } else {
-            PrintF(out, "   %d: %g", i, p->get_scalar(i));
+            FPrintF(out, "   %d: %g", i, p->get_scalar(i));
           }
-          PrintF(out, "\n");
+          FPrintF(out, "\n");
         }
       }
       break;
@@ -325,14 +325,14 @@ void JSObject::PrintElements(FILE* out) {
     case EXTERNAL_PIXEL_ELEMENTS: {
       ExternalPixelArray* p = ExternalPixelArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, p->get_scalar(i));
+        FPrintF(out, "   %d: %d\n", i, p->get_scalar(i));
       }
       break;
     }
     case EXTERNAL_BYTE_ELEMENTS: {
       ExternalByteArray* p = ExternalByteArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
+        FPrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
       }
       break;
     }
@@ -340,14 +340,14 @@ void JSObject::PrintElements(FILE* out) {
       ExternalUnsignedByteArray* p =
           ExternalUnsignedByteArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
+        FPrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
       }
       break;
     }
     case EXTERNAL_SHORT_ELEMENTS: {
       ExternalShortArray* p = ExternalShortArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
+        FPrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
       }
       break;
     }
@@ -355,14 +355,14 @@ void JSObject::PrintElements(FILE* out) {
       ExternalUnsignedShortArray* p =
           ExternalUnsignedShortArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
+        FPrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
       }
       break;
     }
     case EXTERNAL_INT_ELEMENTS: {
       ExternalIntArray* p = ExternalIntArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
+        FPrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
       }
       break;
     }
@@ -370,21 +370,21 @@ void JSObject::PrintElements(FILE* out) {
       ExternalUnsignedIntArray* p =
           ExternalUnsignedIntArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
+        FPrintF(out, "   %d: %d\n", i, static_cast<int>(p->get_scalar(i)));
       }
       break;
     }
     case EXTERNAL_FLOAT_ELEMENTS: {
       ExternalFloatArray* p = ExternalFloatArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "   %d: %f\n", i, p->get_scalar(i));
+        FPrintF(out, "   %d: %f\n", i, p->get_scalar(i));
       }
       break;
     }
     case EXTERNAL_DOUBLE_ELEMENTS: {
       ExternalDoubleArray* p = ExternalDoubleArray::cast(elements());
       for (int i = 0; i < p->length(); i++) {
-        PrintF(out, "  %d: %f\n", i, p->get_scalar(i));
+        FPrintF(out, "  %d: %f\n", i, p->get_scalar(i));
       }
       break;
     }
@@ -394,9 +394,9 @@ void JSObject::PrintElements(FILE* out) {
     case NON_STRICT_ARGUMENTS_ELEMENTS: {
       FixedArray* p = FixedArray::cast(elements());
       for (int i = 2; i < p->length(); i++) {
-        PrintF(out, "   %d: ", i);
+        FPrintF(out, "   %d: ", i);
         p->get(i)->ShortPrint(out);
-        PrintF(out, "\n");
+        FPrintF(out, "\n");
       }
       break;
     }
@@ -408,19 +408,19 @@ void JSObject::PrintTransitions(FILE* out) {
   if (!map()->HasTransitionArray()) return;
   TransitionArray* transitions = map()->transitions();
   for (int i = 0; i < transitions->number_of_transitions(); i++) {
-    PrintF(out, "   ");
+    FPrintF(out, "   ");
     transitions->GetKey(i)->StringPrint(out);
-    PrintF(out, ": ");
+    FPrintF(out, ": ");
     switch (transitions->GetTargetDetails(i).type()) {
       case FIELD: {
-        PrintF(out, " (transition to field)\n");
+        FPrintF(out, " (transition to field)\n");
         break;
       }
       case CONSTANT_FUNCTION:
-        PrintF(out, " (transition to constant function)\n");
+        FPrintF(out, " (transition to constant function)\n");
         break;
       case CALLBACKS:
-        PrintF(out, " (transition to callback)\n");
+        FPrintF(out, " (transition to callback)\n");
         break;
       // Values below are never in the target descriptor array.
       case NORMAL:
@@ -436,34 +436,34 @@ void JSObject::PrintTransitions(FILE* out) {
 
 
 void JSObject::JSObjectPrint(FILE* out) {
-  PrintF(out, "%p: [JSObject]\n", reinterpret_cast<void*>(this));
-  PrintF(out, " - map = %p [", reinterpret_cast<void*>(map()));
+  FPrintF(out, "%p: [JSObject]\n", reinterpret_cast<void*>(this));
+  FPrintF(out, " - map = %p [", reinterpret_cast<void*>(map()));
   // Don't call GetElementsKind, its validation code can cause the printer to
   // fail when debugging.
   PrintElementsKind(out, this->map()->elements_kind());
-  PrintF(out,
+  FPrintF(out,
          "]\n - prototype = %p\n",
          reinterpret_cast<void*>(GetPrototype()));
-  PrintF(out, " {\n");
+  FPrintF(out, " {\n");
   PrintProperties(out);
   PrintTransitions(out);
   PrintElements(out);
-  PrintF(out, " }\n");
+  FPrintF(out, " }\n");
 }
 
 
 void JSModule::JSModulePrint(FILE* out) {
   HeapObject::PrintHeader(out, "JSModule");
-  PrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
-  PrintF(out, " - context = ");
+  FPrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
+  FPrintF(out, " - context = ");
   context()->Print(out);
-  PrintF(out, " - scope_info = ");
+  FPrintF(out, " - scope_info = ");
   scope_info()->ShortPrint(out);
   PrintElementsKind(out, this->map()->elements_kind());
-  PrintF(out, " {\n");
+  FPrintF(out, " {\n");
   PrintProperties(out);
   PrintElements(out);
-  PrintF(out, " }\n");
+  FPrintF(out, " }\n");
 }
 
 
@@ -536,105 +536,105 @@ static const char* TypeToString(InstanceType type) {
 
 void Map::MapPrint(FILE* out) {
   HeapObject::PrintHeader(out, "Map");
-  PrintF(out, " - type: %s\n", TypeToString(instance_type()));
-  PrintF(out, " - instance size: %d\n", instance_size());
-  PrintF(out, " - inobject properties: %d\n", inobject_properties());
-  PrintF(out, " - elements kind: ");
+  FPrintF(out, " - type: %s\n", TypeToString(instance_type()));
+  FPrintF(out, " - instance size: %d\n", instance_size());
+  FPrintF(out, " - inobject properties: %d\n", inobject_properties());
+  FPrintF(out, " - elements kind: ");
   PrintElementsKind(out, elements_kind());
-  PrintF(out, "\n - pre-allocated property fields: %d\n",
+  FPrintF(out, "\n - pre-allocated property fields: %d\n",
       pre_allocated_property_fields());
-  PrintF(out, " - unused property fields: %d\n", unused_property_fields());
+  FPrintF(out, " - unused property fields: %d\n", unused_property_fields());
   if (is_hidden_prototype()) {
-    PrintF(out, " - hidden_prototype\n");
+    FPrintF(out, " - hidden_prototype\n");
   }
   if (has_named_interceptor()) {
-    PrintF(out, " - named_interceptor\n");
+    FPrintF(out, " - named_interceptor\n");
   }
   if (has_indexed_interceptor()) {
-    PrintF(out, " - indexed_interceptor\n");
+    FPrintF(out, " - indexed_interceptor\n");
   }
   if (is_undetectable()) {
-    PrintF(out, " - undetectable\n");
+    FPrintF(out, " - undetectable\n");
   }
   if (has_instance_call_handler()) {
-    PrintF(out, " - instance_call_handler\n");
+    FPrintF(out, " - instance_call_handler\n");
   }
   if (is_access_check_needed()) {
-    PrintF(out, " - access_check_needed\n");
+    FPrintF(out, " - access_check_needed\n");
   }
-  PrintF(out, " - back pointer: ");
+  FPrintF(out, " - back pointer: ");
   GetBackPointer()->ShortPrint(out);
-  PrintF(out, "\n - instance descriptors %i #%i: ",
+  FPrintF(out, "\n - instance descriptors %i #%i: ",
          owns_descriptors(),
          NumberOfOwnDescriptors());
   instance_descriptors()->ShortPrint(out);
   if (HasTransitionArray()) {
-    PrintF(out, "\n - transitions: ");
+    FPrintF(out, "\n - transitions: ");
     transitions()->ShortPrint(out);
   }
-  PrintF(out, "\n - prototype: ");
+  FPrintF(out, "\n - prototype: ");
   prototype()->ShortPrint(out);
-  PrintF(out, "\n - constructor: ");
+  FPrintF(out, "\n - constructor: ");
   constructor()->ShortPrint(out);
-  PrintF(out, "\n - code cache: ");
+  FPrintF(out, "\n - code cache: ");
   code_cache()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void CodeCache::CodeCachePrint(FILE* out) {
   HeapObject::PrintHeader(out, "CodeCache");
-  PrintF(out, "\n - default_cache: ");
+  FPrintF(out, "\n - default_cache: ");
   default_cache()->ShortPrint(out);
-  PrintF(out, "\n - normal_type_cache: ");
+  FPrintF(out, "\n - normal_type_cache: ");
   normal_type_cache()->ShortPrint(out);
 }
 
 
 void PolymorphicCodeCache::PolymorphicCodeCachePrint(FILE* out) {
   HeapObject::PrintHeader(out, "PolymorphicCodeCache");
-  PrintF(out, "\n - cache: ");
+  FPrintF(out, "\n - cache: ");
   cache()->ShortPrint(out);
 }
 
 
 void TypeFeedbackInfo::TypeFeedbackInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "TypeFeedbackInfo");
-  PrintF(out, " - ic_total_count: %d, ic_with_type_info_count: %d\n",
+  FPrintF(out, " - ic_total_count: %d, ic_with_type_info_count: %d\n",
          ic_total_count(), ic_with_type_info_count());
-  PrintF(out, " - type_feedback_cells: ");
+  FPrintF(out, " - type_feedback_cells: ");
   type_feedback_cells()->FixedArrayPrint(out);
 }
 
 
 void AliasedArgumentsEntry::AliasedArgumentsEntryPrint(FILE* out) {
   HeapObject::PrintHeader(out, "AliasedArgumentsEntry");
-  PrintF(out, "\n - aliased_context_slot: %d", aliased_context_slot());
+  FPrintF(out, "\n - aliased_context_slot: %d", aliased_context_slot());
 }
 
 
 void FixedArray::FixedArrayPrint(FILE* out) {
   HeapObject::PrintHeader(out, "FixedArray");
-  PrintF(out, " - length: %d", length());
+  FPrintF(out, " - length: %d", length());
   for (int i = 0; i < length(); i++) {
-    PrintF(out, "\n  [%d]: ", i);
+    FPrintF(out, "\n  [%d]: ", i);
     get(i)->ShortPrint(out);
   }
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void FixedDoubleArray::FixedDoubleArrayPrint(FILE* out) {
   HeapObject::PrintHeader(out, "FixedDoubleArray");
-  PrintF(out, " - length: %d", length());
+  FPrintF(out, " - length: %d", length());
   for (int i = 0; i < length(); i++) {
     if (is_the_hole(i)) {
-      PrintF(out, "\n  [%d]: <the hole>", i);
+      FPrintF(out, "\n  [%d]: <the hole>", i);
     } else {
-      PrintF(out, "\n  [%d]: %g", i, get_scalar(i));
+      FPrintF(out, "\n  [%d]: %g", i, get_scalar(i));
     }
   }
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
@@ -646,29 +646,29 @@ void JSValue::JSValuePrint(FILE* out) {
 
 void JSMessageObject::JSMessageObjectPrint(FILE* out) {
   HeapObject::PrintHeader(out, "JSMessageObject");
-  PrintF(out, " - type: ");
+  FPrintF(out, " - type: ");
   type()->ShortPrint(out);
-  PrintF(out, "\n - arguments: ");
+  FPrintF(out, "\n - arguments: ");
   arguments()->ShortPrint(out);
-  PrintF(out, "\n - start_position: %d", start_position());
-  PrintF(out, "\n - end_position: %d", end_position());
-  PrintF(out, "\n - script: ");
+  FPrintF(out, "\n - start_position: %d", start_position());
+  FPrintF(out, "\n - end_position: %d", end_position());
+  FPrintF(out, "\n - script: ");
   script()->ShortPrint(out);
-  PrintF(out, "\n - stack_trace: ");
+  FPrintF(out, "\n - stack_trace: ");
   stack_trace()->ShortPrint(out);
-  PrintF(out, "\n - stack_frames: ");
+  FPrintF(out, "\n - stack_frames: ");
   stack_frames()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void String::StringPrint(FILE* out) {
   if (StringShape(this).IsSymbol()) {
-    PrintF(out, "#");
+    FPrintF(out, "#");
   } else if (StringShape(this).IsCons()) {
-    PrintF(out, "c\"");
+    FPrintF(out, "c\"");
   } else {
-    PrintF(out, "\"");
+    FPrintF(out, "\"");
   }
 
   const char truncated_epilogue[] = "...<truncated>";
@@ -679,13 +679,13 @@ void String::StringPrint(FILE* out) {
     }
   }
   for (int i = 0; i < len; i++) {
-    PrintF(out, "%c", Get(i));
+    FPrintF(out, "%c", Get(i));
   }
   if (len != length()) {
-    PrintF(out, "%s", truncated_epilogue);
+    FPrintF(out, "%s", truncated_epilogue);
   }
 
-  if (!StringShape(this).IsSymbol()) PrintF(out, "\"");
+  if (!StringShape(this).IsSymbol()) FPrintF(out, "\"");
 }
 
 
@@ -710,13 +710,13 @@ static const char* const weekdays[] = {
 
 void JSDate::JSDatePrint(FILE* out) {
   HeapObject::PrintHeader(out, "JSDate");
-  PrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
-  PrintF(out, " - value = ");
+  FPrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
+  FPrintF(out, " - value = ");
   value()->Print(out);
   if (!year()->IsSmi()) {
-    PrintF(out, " - time = NaN\n");
+    FPrintF(out, " - time = NaN\n");
   } else {
-    PrintF(out, " - time = %s %04d/%02d/%02d %02d:%02d:%02d\n",
+    FPrintF(out, " - time = %s %04d/%02d/%02d %02d:%02d:%02d\n",
            weekdays[weekday()->IsSmi() ? Smi::cast(weekday())->value() + 1 : 0],
            year()->IsSmi() ? Smi::cast(year())->value() : -1,
            month()->IsSmi() ? Smi::cast(month())->value() : -1,
@@ -730,74 +730,74 @@ void JSDate::JSDatePrint(FILE* out) {
 
 void JSProxy::JSProxyPrint(FILE* out) {
   HeapObject::PrintHeader(out, "JSProxy");
-  PrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
-  PrintF(out, " - handler = ");
+  FPrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
+  FPrintF(out, " - handler = ");
   handler()->Print(out);
-  PrintF(out, " - hash = ");
+  FPrintF(out, " - hash = ");
   hash()->Print(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void JSFunctionProxy::JSFunctionProxyPrint(FILE* out) {
   HeapObject::PrintHeader(out, "JSFunctionProxy");
-  PrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
-  PrintF(out, " - handler = ");
+  FPrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
+  FPrintF(out, " - handler = ");
   handler()->Print(out);
-  PrintF(out, " - call_trap = ");
+  FPrintF(out, " - call_trap = ");
   call_trap()->Print(out);
-  PrintF(out, " - construct_trap = ");
+  FPrintF(out, " - construct_trap = ");
   construct_trap()->Print(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void JSWeakMap::JSWeakMapPrint(FILE* out) {
   HeapObject::PrintHeader(out, "JSWeakMap");
-  PrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
-  PrintF(out, " - table = ");
+  FPrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
+  FPrintF(out, " - table = ");
   table()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void JSFunction::JSFunctionPrint(FILE* out) {
   HeapObject::PrintHeader(out, "Function");
-  PrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
-  PrintF(out, " - initial_map = ");
+  FPrintF(out, " - map = 0x%p\n", reinterpret_cast<void*>(map()));
+  FPrintF(out, " - initial_map = ");
   if (has_initial_map()) {
     initial_map()->ShortPrint(out);
   }
-  PrintF(out, "\n - shared_info = ");
+  FPrintF(out, "\n - shared_info = ");
   shared()->ShortPrint(out);
-  PrintF(out, "\n   - name = ");
+  FPrintF(out, "\n   - name = ");
   shared()->name()->Print(out);
-  PrintF(out, "\n - context = ");
+  FPrintF(out, "\n - context = ");
   unchecked_context()->ShortPrint(out);
-  PrintF(out, "\n - literals = ");
+  FPrintF(out, "\n - literals = ");
   literals()->ShortPrint(out);
-  PrintF(out, "\n - code = ");
+  FPrintF(out, "\n - code = ");
   code()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 
   PrintProperties(out);
   PrintElements(out);
 
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void SharedFunctionInfo::SharedFunctionInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "SharedFunctionInfo");
-  PrintF(out, " - name: ");
+  FPrintF(out, " - name: ");
   name()->ShortPrint(out);
-  PrintF(out, "\n - expected_nof_properties: %d", expected_nof_properties());
-  PrintF(out, "\n - instance class name = ");
+  FPrintF(out, "\n - expected_nof_properties: %d", expected_nof_properties());
+  FPrintF(out, "\n - instance class name = ");
   instance_class_name()->Print(out);
-  PrintF(out, "\n - code = ");
+  FPrintF(out, "\n - code = ");
   code()->ShortPrint(out);
   if (HasSourceCode()) {
-    PrintF(out, "\n - source code = ");
+    FPrintF(out, "\n - source code = ");
     String* source = String::cast(Script::cast(script())->source());
     int start = start_position();
     int length = end_position() - start;
@@ -805,46 +805,46 @@ void SharedFunctionInfo::SharedFunctionInfoPrint(FILE* out) {
         source->ToCString(DISALLOW_NULLS,
                           FAST_STRING_TRAVERSAL,
                           start, length, NULL);
-    PrintF(out, "%s", *source_string);
+    FPrintF(out, "%s", *source_string);
   }
   // Script files are often large, hard to read.
-  // PrintF(out, "\n - script =");
+  // FPrintF(out, "\n - script =");
   // script()->Print(out);
-  PrintF(out, "\n - function token position = %d", function_token_position());
-  PrintF(out, "\n - start position = %d", start_position());
-  PrintF(out, "\n - end position = %d", end_position());
-  PrintF(out, "\n - is expression = %d", is_expression());
-  PrintF(out, "\n - debug info = ");
+  FPrintF(out, "\n - function token position = %d", function_token_position());
+  FPrintF(out, "\n - start position = %d", start_position());
+  FPrintF(out, "\n - end position = %d", end_position());
+  FPrintF(out, "\n - is expression = %d", is_expression());
+  FPrintF(out, "\n - debug info = ");
   debug_info()->ShortPrint(out);
-  PrintF(out, "\n - length = %d", length());
-  PrintF(out, "\n - has_only_simple_this_property_assignments = %d",
+  FPrintF(out, "\n - length = %d", length());
+  FPrintF(out, "\n - has_only_simple_this_property_assignments = %d",
          has_only_simple_this_property_assignments());
-  PrintF(out, "\n - this_property_assignments = ");
+  FPrintF(out, "\n - this_property_assignments = ");
   this_property_assignments()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void JSGlobalProxy::JSGlobalProxyPrint(FILE* out) {
-  PrintF(out, "global_proxy ");
+  FPrintF(out, "global_proxy ");
   JSObjectPrint(out);
-  PrintF(out, "native context : ");
+  FPrintF(out, "native context : ");
   native_context()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void JSGlobalObject::JSGlobalObjectPrint(FILE* out) {
-  PrintF(out, "global ");
+  FPrintF(out, "global ");
   JSObjectPrint(out);
-  PrintF(out, "native context : ");
+  FPrintF(out, "native context : ");
   native_context()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void JSBuiltinsObject::JSBuiltinsObjectPrint(FILE* out) {
-  PrintF(out, "builtins ");
+  FPrintF(out, "builtins ");
   JSObjectPrint(out);
 }
 
@@ -865,223 +865,223 @@ void Code::CodePrint(FILE* out) {
 
 
 void Foreign::ForeignPrint(FILE* out) {
-  PrintF(out, "foreign address : %p", foreign_address());
+  FPrintF(out, "foreign address : %p", foreign_address());
 }
 
 
 void AccessorInfo::AccessorInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "AccessorInfo");
-  PrintF(out, "\n - getter: ");
+  FPrintF(out, "\n - getter: ");
   getter()->ShortPrint(out);
-  PrintF(out, "\n - setter: ");
+  FPrintF(out, "\n - setter: ");
   setter()->ShortPrint(out);
-  PrintF(out, "\n - name: ");
+  FPrintF(out, "\n - name: ");
   name()->ShortPrint(out);
-  PrintF(out, "\n - data: ");
+  FPrintF(out, "\n - data: ");
   data()->ShortPrint(out);
-  PrintF(out, "\n - flag: ");
+  FPrintF(out, "\n - flag: ");
   flag()->ShortPrint(out);
 }
 
 
 void AccessorPair::AccessorPairPrint(FILE* out) {
   HeapObject::PrintHeader(out, "AccessorPair");
-  PrintF(out, "\n - getter: ");
+  FPrintF(out, "\n - getter: ");
   getter()->ShortPrint(out);
-  PrintF(out, "\n - setter: ");
+  FPrintF(out, "\n - setter: ");
   setter()->ShortPrint(out);
 }
 
 
 void AccessCheckInfo::AccessCheckInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "AccessCheckInfo");
-  PrintF(out, "\n - named_callback: ");
+  FPrintF(out, "\n - named_callback: ");
   named_callback()->ShortPrint(out);
-  PrintF(out, "\n - indexed_callback: ");
+  FPrintF(out, "\n - indexed_callback: ");
   indexed_callback()->ShortPrint(out);
-  PrintF(out, "\n - data: ");
+  FPrintF(out, "\n - data: ");
   data()->ShortPrint(out);
 }
 
 
 void InterceptorInfo::InterceptorInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "InterceptorInfo");
-  PrintF(out, "\n - getter: ");
+  FPrintF(out, "\n - getter: ");
   getter()->ShortPrint(out);
-  PrintF(out, "\n - setter: ");
+  FPrintF(out, "\n - setter: ");
   setter()->ShortPrint(out);
-  PrintF(out, "\n - query: ");
+  FPrintF(out, "\n - query: ");
   query()->ShortPrint(out);
-  PrintF(out, "\n - deleter: ");
+  FPrintF(out, "\n - deleter: ");
   deleter()->ShortPrint(out);
-  PrintF(out, "\n - enumerator: ");
+  FPrintF(out, "\n - enumerator: ");
   enumerator()->ShortPrint(out);
-  PrintF(out, "\n - data: ");
+  FPrintF(out, "\n - data: ");
   data()->ShortPrint(out);
 }
 
 
 void CallHandlerInfo::CallHandlerInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "CallHandlerInfo");
-  PrintF(out, "\n - callback: ");
+  FPrintF(out, "\n - callback: ");
   callback()->ShortPrint(out);
-  PrintF(out, "\n - data: ");
+  FPrintF(out, "\n - data: ");
   data()->ShortPrint(out);
-  PrintF(out, "\n - call_stub_cache: ");
+  FPrintF(out, "\n - call_stub_cache: ");
 }
 
 
 void FunctionTemplateInfo::FunctionTemplateInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "FunctionTemplateInfo");
-  PrintF(out, "\n - class name: ");
+  FPrintF(out, "\n - class name: ");
   class_name()->ShortPrint(out);
-  PrintF(out, "\n - tag: ");
+  FPrintF(out, "\n - tag: ");
   tag()->ShortPrint(out);
-  PrintF(out, "\n - property_list: ");
+  FPrintF(out, "\n - property_list: ");
   property_list()->ShortPrint(out);
-  PrintF(out, "\n - serial_number: ");
+  FPrintF(out, "\n - serial_number: ");
   serial_number()->ShortPrint(out);
-  PrintF(out, "\n - call_code: ");
+  FPrintF(out, "\n - call_code: ");
   call_code()->ShortPrint(out);
-  PrintF(out, "\n - property_accessors: ");
+  FPrintF(out, "\n - property_accessors: ");
   property_accessors()->ShortPrint(out);
-  PrintF(out, "\n - prototype_template: ");
+  FPrintF(out, "\n - prototype_template: ");
   prototype_template()->ShortPrint(out);
-  PrintF(out, "\n - parent_template: ");
+  FPrintF(out, "\n - parent_template: ");
   parent_template()->ShortPrint(out);
-  PrintF(out, "\n - named_property_handler: ");
+  FPrintF(out, "\n - named_property_handler: ");
   named_property_handler()->ShortPrint(out);
-  PrintF(out, "\n - indexed_property_handler: ");
+  FPrintF(out, "\n - indexed_property_handler: ");
   indexed_property_handler()->ShortPrint(out);
-  PrintF(out, "\n - instance_template: ");
+  FPrintF(out, "\n - instance_template: ");
   instance_template()->ShortPrint(out);
-  PrintF(out, "\n - signature: ");
+  FPrintF(out, "\n - signature: ");
   signature()->ShortPrint(out);
-  PrintF(out, "\n - access_check_info: ");
+  FPrintF(out, "\n - access_check_info: ");
   access_check_info()->ShortPrint(out);
-  PrintF(out, "\n - hidden_prototype: %s",
+  FPrintF(out, "\n - hidden_prototype: %s",
          hidden_prototype() ? "true" : "false");
-  PrintF(out, "\n - undetectable: %s", undetectable() ? "true" : "false");
-  PrintF(out, "\n - need_access_check: %s",
+  FPrintF(out, "\n - undetectable: %s", undetectable() ? "true" : "false");
+  FPrintF(out, "\n - need_access_check: %s",
          needs_access_check() ? "true" : "false");
 }
 
 
 void ObjectTemplateInfo::ObjectTemplateInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "ObjectTemplateInfo");
-  PrintF(out, " - tag: ");
+  FPrintF(out, " - tag: ");
   tag()->ShortPrint(out);
-  PrintF(out, "\n - property_list: ");
+  FPrintF(out, "\n - property_list: ");
   property_list()->ShortPrint(out);
-  PrintF(out, "\n - constructor: ");
+  FPrintF(out, "\n - constructor: ");
   constructor()->ShortPrint(out);
-  PrintF(out, "\n - internal_field_count: ");
+  FPrintF(out, "\n - internal_field_count: ");
   internal_field_count()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void SignatureInfo::SignatureInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "SignatureInfo");
-  PrintF(out, "\n - receiver: ");
+  FPrintF(out, "\n - receiver: ");
   receiver()->ShortPrint(out);
-  PrintF(out, "\n - args: ");
+  FPrintF(out, "\n - args: ");
   args()->ShortPrint(out);
 }
 
 
 void TypeSwitchInfo::TypeSwitchInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "TypeSwitchInfo");
-  PrintF(out, "\n - types: ");
+  FPrintF(out, "\n - types: ");
   types()->ShortPrint(out);
 }
 
 
 void Script::ScriptPrint(FILE* out) {
   HeapObject::PrintHeader(out, "Script");
-  PrintF(out, "\n - source: ");
+  FPrintF(out, "\n - source: ");
   source()->ShortPrint(out);
-  PrintF(out, "\n - name: ");
+  FPrintF(out, "\n - name: ");
   name()->ShortPrint(out);
-  PrintF(out, "\n - line_offset: ");
+  FPrintF(out, "\n - line_offset: ");
   line_offset()->ShortPrint(out);
-  PrintF(out, "\n - column_offset: ");
+  FPrintF(out, "\n - column_offset: ");
   column_offset()->ShortPrint(out);
-  PrintF(out, "\n - type: ");
+  FPrintF(out, "\n - type: ");
   type()->ShortPrint(out);
-  PrintF(out, "\n - id: ");
+  FPrintF(out, "\n - id: ");
   id()->ShortPrint(out);
-  PrintF(out, "\n - data: ");
+  FPrintF(out, "\n - data: ");
   data()->ShortPrint(out);
-  PrintF(out, "\n - context data: ");
+  FPrintF(out, "\n - context data: ");
   context_data()->ShortPrint(out);
-  PrintF(out, "\n - wrapper: ");
+  FPrintF(out, "\n - wrapper: ");
   wrapper()->ShortPrint(out);
-  PrintF(out, "\n - compilation type: ");
+  FPrintF(out, "\n - compilation type: ");
   compilation_type()->ShortPrint(out);
-  PrintF(out, "\n - line ends: ");
+  FPrintF(out, "\n - line ends: ");
   line_ends()->ShortPrint(out);
-  PrintF(out, "\n - eval from shared: ");
+  FPrintF(out, "\n - eval from shared: ");
   eval_from_shared()->ShortPrint(out);
-  PrintF(out, "\n - eval from instructions offset: ");
+  FPrintF(out, "\n - eval from instructions offset: ");
   eval_from_instructions_offset()->ShortPrint(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 void DebugInfo::DebugInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "DebugInfo");
-  PrintF(out, "\n - shared: ");
+  FPrintF(out, "\n - shared: ");
   shared()->ShortPrint(out);
-  PrintF(out, "\n - original_code: ");
+  FPrintF(out, "\n - original_code: ");
   original_code()->ShortPrint(out);
-  PrintF(out, "\n - code: ");
+  FPrintF(out, "\n - code: ");
   code()->ShortPrint(out);
-  PrintF(out, "\n - break_points: ");
+  FPrintF(out, "\n - break_points: ");
   break_points()->Print(out);
 }
 
 
 void BreakPointInfo::BreakPointInfoPrint(FILE* out) {
   HeapObject::PrintHeader(out, "BreakPointInfo");
-  PrintF(out, "\n - code_position: %d", code_position()->value());
-  PrintF(out, "\n - source_position: %d", source_position()->value());
-  PrintF(out, "\n - statement_position: %d", statement_position()->value());
-  PrintF(out, "\n - break_point_objects: ");
+  FPrintF(out, "\n - code_position: %d", code_position()->value());
+  FPrintF(out, "\n - source_position: %d", source_position()->value());
+  FPrintF(out, "\n - statement_position: %d", statement_position()->value());
+  FPrintF(out, "\n - break_point_objects: ");
   break_point_objects()->ShortPrint(out);
 }
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 
 void DescriptorArray::PrintDescriptors(FILE* out) {
-  PrintF(out, "Descriptor array  %d\n", number_of_descriptors());
+  FPrintF(out, "Descriptor array  %d\n", number_of_descriptors());
   for (int i = 0; i < number_of_descriptors(); i++) {
-    PrintF(out, " %d: ", i);
+    FPrintF(out, " %d: ", i);
     Descriptor desc;
     Get(i, &desc);
     desc.Print(out);
   }
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
 void TransitionArray::PrintTransitions(FILE* out) {
-  PrintF(out, "Transition array  %d\n", number_of_transitions());
+  FPrintF(out, "Transition array  %d\n", number_of_transitions());
   for (int i = 0; i < number_of_transitions(); i++) {
-    PrintF(out, " %d: ", i);
+    FPrintF(out, " %d: ", i);
     GetKey(i)->StringPrint(out);
-    PrintF(out, ": ");
+    FPrintF(out, ": ");
     switch (GetTargetDetails(i).type()) {
       case FIELD: {
-        PrintF(out, " (transition to field)\n");
+        FPrintF(out, " (transition to field)\n");
         break;
       }
       case CONSTANT_FUNCTION:
-        PrintF(out, " (transition to constant function)\n");
+        FPrintF(out, " (transition to constant function)\n");
         break;
       case CALLBACKS:
-        PrintF(out, " (transition to callback)\n");
+        FPrintF(out, " (transition to callback)\n");
         break;
       // Values below are never in the target descriptor array.
       case NORMAL:
@@ -1093,7 +1093,7 @@ void TransitionArray::PrintTransitions(FILE* out) {
         break;
     }
   }
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 
 
diff --git a/src/3rdparty/v8/src/objects.cc b/src/3rdparty/v8/src/objects.cc
index 5fa4473..4273eff 100644
--- a/src/3rdparty/v8/src/objects.cc
+++ b/src/3rdparty/v8/src/objects.cc
@@ -815,7 +815,7 @@ void Object::ShortPrint(StringStream* accumulator) {
 
 
 void Smi::SmiPrint(FILE* out) {
-  PrintF(out, "%d", value());
+  FPrintF(out, "%d", value());
 }
 
 
@@ -830,7 +830,7 @@ void Failure::FailurePrint(StringStream* accumulator) {
 
 
 void Failure::FailurePrint(FILE* out) {
-  PrintF(out, "Failure(%p)", reinterpret_cast<void*>(value()));
+  FPrintF(out, "Failure(%p)", reinterpret_cast<void*>(value()));
 }
 
 
@@ -1168,19 +1168,19 @@ void JSObject::PrintElementsTransition(
     FILE* file, ElementsKind from_kind, FixedArrayBase* from_elements,
     ElementsKind to_kind, FixedArrayBase* to_elements) {
   if (from_kind != to_kind) {
-    PrintF(file, "elements transition [");
+    FPrintF(file, "elements transition [");
     PrintElementsKind(file, from_kind);
-    PrintF(file, " -> ");
+    FPrintF(file, " -> ");
     PrintElementsKind(file, to_kind);
-    PrintF(file, "] in ");
+    FPrintF(file, "] in ");
     JavaScriptFrame::PrintTop(file, false, true);
-    PrintF(file, " for ");
+    FPrintF(file, " for ");
     ShortPrint(file);
-    PrintF(file, " from ");
+    FPrintF(file, " from ");
     from_elements->ShortPrint(file);
-    PrintF(file, " to ");
+    FPrintF(file, " to ");
     to_elements->ShortPrint(file);
-    PrintF(file, "\n");
+    FPrintF(file, "\n");
   }
 }
 
@@ -1454,7 +1454,7 @@ Object* HeapNumber::HeapNumberToBoolean() {
 
 
 void HeapNumber::HeapNumberPrint(FILE* out) {
-  PrintF(out, "%.16g", Number());
+  FPrintF(out, "%.16g", Number());
 }
 
 
@@ -8210,7 +8210,7 @@ void JSFunction::SetInstanceClassName(String* name) {
 
 void JSFunction::PrintName(FILE* out) {
   SmartArrayPointer<char> name = shared()->DebugName()->ToCString();
-  PrintF(out, "%s", *name);
+  FPrintF(out, "%s", *name);
 }
 
 
@@ -8973,20 +8973,20 @@ Code* Code::GetCodeAgeStub(Age age, MarkingParity parity) {
 void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
   disasm::NameConverter converter;
   int deopt_count = DeoptCount();
-  PrintF(out, "Deoptimization Input Data (deopt points = %d)\n", deopt_count);
+  FPrintF(out, "Deoptimization Input Data (deopt points = %d)\n", deopt_count);
   if (0 == deopt_count) return;
 
-  PrintF(out, "%6s  %6s  %6s %6s %12s\n", "index", "ast id", "argc", "pc",
+  FPrintF(out, "%6s  %6s  %6s %6s %12s\n", "index", "ast id", "argc", "pc",
          FLAG_print_code_verbose ? "commands" : "");
   for (int i = 0; i < deopt_count; i++) {
-    PrintF(out, "%6d  %6d  %6d %6d",
+    FPrintF(out, "%6d  %6d  %6d %6d",
            i,
            AstId(i).ToInt(),
            ArgumentsStackHeight(i)->value(),
            Pc(i)->value());
 
     if (!FLAG_print_code_verbose) {
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
       continue;
     }
     // Print details of the frame translation.
@@ -8997,7 +8997,7 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
     ASSERT(Translation::BEGIN == opcode);
     int frame_count = iterator.Next();
     int jsframe_count = iterator.Next();
-    PrintF(out, "  %s {frame count=%d, js frame count=%d}\n",
+    FPrintF(out, "  %s {frame count=%d, js frame count=%d}\n",
            Translation::StringFor(opcode),
            frame_count,
            jsframe_count);
@@ -9005,7 +9005,7 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
     while (iterator.HasNext() &&
            Translation::BEGIN !=
            (opcode = static_cast<Translation::Opcode>(iterator.Next()))) {
-      PrintF(out, "%24s    %s ", "", Translation::StringFor(opcode));
+      FPrintF(out, "%24s    %s ", "", Translation::StringFor(opcode));
 
       switch (opcode) {
         case Translation::BEGIN:
@@ -9016,14 +9016,14 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
           int ast_id = iterator.Next();
           int function_id = iterator.Next();
           unsigned height = iterator.Next();
-          PrintF(out, "{ast_id=%d, function=", ast_id);
+          FPrintF(out, "{ast_id=%d, function=", ast_id);
           if (function_id != Translation::kSelfLiteralId) {
             Object* function = LiteralArray()->get(function_id);
             JSFunction::cast(function)->PrintName(out);
           } else {
-            PrintF(out, "<self>");
+            FPrintF(out, "<self>");
           }
-          PrintF(out, ", height=%u}", height);
+          FPrintF(out, ", height=%u}", height);
           break;
         }
 
@@ -9033,9 +9033,9 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
           JSFunction* function =
               JSFunction::cast(LiteralArray()->get(function_id));
           unsigned height = iterator.Next();
-          PrintF(out, "{function=");
+          FPrintF(out, "{function=");
           function->PrintName(out);
-          PrintF(out, ", height=%u}", height);
+          FPrintF(out, ", height=%u}", height);
           break;
         }
 
@@ -9044,9 +9044,9 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
           int function_id = iterator.Next();
           JSFunction* function =
               JSFunction::cast(LiteralArray()->get(function_id));
-          PrintF(out, "{function=");
+          FPrintF(out, "{function=");
           function->PrintName(out);
-          PrintF(out, "}");
+          FPrintF(out, "}");
           break;
         }
 
@@ -9055,19 +9055,19 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
 
         case Translation::REGISTER: {
           int reg_code = iterator.Next();
-            PrintF(out, "{input=%s}", converter.NameOfCPURegister(reg_code));
+            FPrintF(out, "{input=%s}", converter.NameOfCPURegister(reg_code));
           break;
         }
 
         case Translation::INT32_REGISTER: {
           int reg_code = iterator.Next();
-          PrintF(out, "{input=%s}", converter.NameOfCPURegister(reg_code));
+          FPrintF(out, "{input=%s}", converter.NameOfCPURegister(reg_code));
           break;
         }
 
         case Translation::UINT32_REGISTER: {
           int reg_code = iterator.Next();
-          PrintF(out,
+          FPrintF(out,
                  "{input=%s (unsigned)}",
                  converter.NameOfCPURegister(reg_code));
           break;
@@ -9075,52 +9075,52 @@ void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
 
         case Translation::DOUBLE_REGISTER: {
           int reg_code = iterator.Next();
-          PrintF(out, "{input=%s}",
+          FPrintF(out, "{input=%s}",
                  DoubleRegister::AllocationIndexToString(reg_code));
           break;
         }
 
         case Translation::STACK_SLOT: {
           int input_slot_index = iterator.Next();
-          PrintF(out, "{input=%d}", input_slot_index);
+          FPrintF(out, "{input=%d}", input_slot_index);
           break;
         }
 
         case Translation::INT32_STACK_SLOT: {
           int input_slot_index = iterator.Next();
-          PrintF(out, "{input=%d}", input_slot_index);
+          FPrintF(out, "{input=%d}", input_slot_index);
           break;
         }
 
         case Translation::UINT32_STACK_SLOT: {
           int input_slot_index = iterator.Next();
-          PrintF(out, "{input=%d (unsigned)}", input_slot_index);
+          FPrintF(out, "{input=%d (unsigned)}", input_slot_index);
           break;
         }
 
         case Translation::DOUBLE_STACK_SLOT: {
           int input_slot_index = iterator.Next();
-          PrintF(out, "{input=%d}", input_slot_index);
+          FPrintF(out, "{input=%d}", input_slot_index);
           break;
         }
 
         case Translation::LITERAL: {
           unsigned literal_index = iterator.Next();
-          PrintF(out, "{literal_id=%u}", literal_index);
+          FPrintF(out, "{literal_id=%u}", literal_index);
           break;
         }
 
         case Translation::ARGUMENTS_OBJECT:
           break;
       }
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
     }
   }
 }
 
 
 void DeoptimizationOutputData::DeoptimizationOutputDataPrint(FILE* out) {
-  PrintF(out, "Deoptimization Output Data (deopt points = %d)\n",
+  FPrintF(out, "Deoptimization Output Data (deopt points = %d)\n",
          this->DeoptPoints());
   if (this->DeoptPoints() == 0) return;
 
@@ -9207,43 +9207,43 @@ void Code::PrintExtraICState(FILE* out, Kind kind, ExtraICState extra) {
       break;
   }
   if (name != NULL) {
-    PrintF(out, "extra_ic_state = %s\n", name);
+    FPrintF(out, "extra_ic_state = %s\n", name);
   } else {
-    PrintF(out, "extra_ic_state = %d\n", extra);
+    FPrintF(out, "extra_ic_state = %d\n", extra);
   }
 }
 
 
 void Code::Disassemble(const char* name, FILE* out) {
-  PrintF(out, "kind = %s\n", Kind2String(kind()));
+  FPrintF(out, "kind = %s\n", Kind2String(kind()));
   if (is_inline_cache_stub()) {
-    PrintF(out, "ic_state = %s\n", ICState2String(ic_state()));
+    FPrintF(out, "ic_state = %s\n", ICState2String(ic_state()));
     PrintExtraICState(out, kind(), extra_ic_state());
     if (ic_state() == MONOMORPHIC) {
-      PrintF(out, "type = %s\n", StubType2String(type()));
+      FPrintF(out, "type = %s\n", StubType2String(type()));
     }
     if (is_call_stub() || is_keyed_call_stub()) {
-      PrintF(out, "argc = %d\n", arguments_count());
+      FPrintF(out, "argc = %d\n", arguments_count());
     }
     if (is_compare_ic_stub()) {
       CompareIC::State state = CompareIC::ComputeState(this);
-      PrintF(out, "compare_state = %s\n", CompareIC::GetStateName(state));
+      FPrintF(out, "compare_state = %s\n", CompareIC::GetStateName(state));
     }
     if (is_compare_ic_stub() && major_key() == CodeStub::CompareIC) {
       Token::Value op = CompareIC::ComputeOperation(this);
-      PrintF(out, "compare_operation = %s\n", Token::Name(op));
+      FPrintF(out, "compare_operation = %s\n", Token::Name(op));
     }
   }
   if ((name != NULL) && (name[0] != '\0')) {
-    PrintF(out, "name = %s\n", name);
+    FPrintF(out, "name = %s\n", name);
   }
   if (kind() == OPTIMIZED_FUNCTION) {
-    PrintF(out, "stack_slots = %d\n", stack_slots());
+    FPrintF(out, "stack_slots = %d\n", stack_slots());
   }
 
-  PrintF(out, "Instructions (size = %d)\n", instruction_size());
+  FPrintF(out, "Instructions (size = %d)\n", instruction_size());
   Disassembler::Decode(out, this);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 
   if (kind() == FUNCTION) {
     DeoptimizationOutputData* data =
@@ -9258,24 +9258,24 @@ void Code::Disassemble(const char* name, FILE* out) {
 
   if (kind() == OPTIMIZED_FUNCTION) {
     SafepointTable table(this);
-    PrintF(out, "Safepoints (size = %u)\n", table.size());
+    FPrintF(out, "Safepoints (size = %u)\n", table.size());
     for (unsigned i = 0; i < table.length(); i++) {
       unsigned pc_offset = table.GetPcOffset(i);
-      PrintF(out, "%p  %4d  ", (instruction_start() + pc_offset), pc_offset);
+      FPrintF(out, "%p  %4d  ", (instruction_start() + pc_offset), pc_offset);
       table.PrintEntry(i);
-      PrintF(out, " (sp -> fp)");
+      FPrintF(out, " (sp -> fp)");
       SafepointEntry entry = table.GetEntry(i);
       if (entry.deoptimization_index() != Safepoint::kNoDeoptimizationIndex) {
-        PrintF(out, "  %6d", entry.deoptimization_index());
+        FPrintF(out, "  %6d", entry.deoptimization_index());
       } else {
-        PrintF(out, "  <none>");
+        FPrintF(out, "  <none>");
       }
       if (entry.argument_count() > 0) {
-        PrintF(out, " argc: %d", entry.argument_count());
+        FPrintF(out, " argc: %d", entry.argument_count());
       }
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
     }
-    PrintF(out, "\n");
+    FPrintF(out, "\n");
     // Just print if type feedback info is ever used for optimized code.
     ASSERT(type_feedback_info()->IsUndefined());
   } else if (kind() == FUNCTION) {
@@ -9286,25 +9286,25 @@ void Code::Disassemble(const char* name, FILE* out) {
       unsigned* address =
           reinterpret_cast<unsigned*>(instruction_start() + offset);
       unsigned length = address[0];
-      PrintF(out, "Stack checks (size = %u)\n", length);
-      PrintF(out, "ast_id  pc_offset\n");
+      FPrintF(out, "Stack checks (size = %u)\n", length);
+      FPrintF(out, "ast_id  pc_offset\n");
       for (unsigned i = 0; i < length; ++i) {
         unsigned index = (2 * i) + 1;
-        PrintF(out, "%6u  %9u\n", address[index], address[index + 1]);
+        FPrintF(out, "%6u  %9u\n", address[index], address[index + 1]);
       }
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
     }
 #ifdef OBJECT_PRINT
     if (!type_feedback_info()->IsUndefined()) {
       TypeFeedbackInfo::cast(type_feedback_info())->TypeFeedbackInfoPrint(out);
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
     }
 #endif
   }
 
   PrintF("RelocInfo (size = %d)\n", relocation_size());
   for (RelocIterator it(this); !it.done(); it.next()) it.rinfo()->Print(out);
-  PrintF(out, "\n");
+  FPrintF(out, "\n");
 }
 #endif  // ENABLE_DISASSEMBLER
 
@@ -10862,15 +10862,15 @@ void Dictionary<Shape, Key>::Print(FILE* out) {
   for (int i = 0; i < capacity; i++) {
     Object* k = HashTable<Shape, Key>::KeyAt(i);
     if (HashTable<Shape, Key>::IsKey(k)) {
-      PrintF(out, " ");
+      FPrintF(out, " ");
       if (k->IsString()) {
         String::cast(k)->StringPrint(out);
       } else {
         k->ShortPrint(out);
       }
-      PrintF(out, ": ");
+      FPrintF(out, ": ");
       ValueAt(i)->ShortPrint(out);
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
     }
   }
 }
diff --git a/src/3rdparty/v8/src/property.cc b/src/3rdparty/v8/src/property.cc
index 05342ee..d05ef2b 100644
--- a/src/3rdparty/v8/src/property.cc
+++ b/src/3rdparty/v8/src/property.cc
@@ -43,57 +43,57 @@ void LookupResult::Iterate(ObjectVisitor* visitor) {
 #ifdef OBJECT_PRINT
 void LookupResult::Print(FILE* out) {
   if (!IsFound()) {
-    PrintF(out, "Not Found\n");
+    FPrintF(out, "Not Found\n");
     return;
   }
 
-  PrintF(out, "LookupResult:\n");
-  PrintF(out, " -cacheable = %s\n", IsCacheable() ? "true" : "false");
-  PrintF(out, " -attributes = %x\n", GetAttributes());
+  FPrintF(out, "LookupResult:\n");
+  FPrintF(out, " -cacheable = %s\n", IsCacheable() ? "true" : "false");
+  FPrintF(out, " -attributes = %x\n", GetAttributes());
   switch (type()) {
     case NORMAL:
-      PrintF(out, " -type = normal\n");
-      PrintF(out, " -entry = %d", GetDictionaryEntry());
+      FPrintF(out, " -type = normal\n");
+      FPrintF(out, " -entry = %d", GetDictionaryEntry());
       break;
     case CONSTANT_FUNCTION:
-      PrintF(out, " -type = constant function\n");
-      PrintF(out, " -function:\n");
+      FPrintF(out, " -type = constant function\n");
+      FPrintF(out, " -function:\n");
       GetConstantFunction()->Print(out);
-      PrintF(out, "\n");
+      FPrintF(out, "\n");
       break;
     case FIELD:
-      PrintF(out, " -type = field\n");
-      PrintF(out, " -index = %d", GetFieldIndex());
-      PrintF(out, "\n");
+      FPrintF(out, " -type = field\n");
+      FPrintF(out, " -index = %d", GetFieldIndex());
+      FPrintF(out, "\n");
       break;
     case CALLBACKS:
-      PrintF(out, " -type = call backs\n");
-      PrintF(out, " -callback object:\n");
+      FPrintF(out, " -type = call backs\n");
+      FPrintF(out, " -callback object:\n");
       GetCallbackObject()->Print(out);
       break;
     case HANDLER:
-      PrintF(out, " -type = lookup proxy\n");
+      FPrintF(out, " -type = lookup proxy\n");
       break;
     case INTERCEPTOR:
-      PrintF(out, " -type = lookup interceptor\n");
+      FPrintF(out, " -type = lookup interceptor\n");
       break;
     case TRANSITION:
       switch (GetTransitionDetails().type()) {
         case FIELD:
-          PrintF(out, " -type = map transition\n");
-          PrintF(out, " -map:\n");
+          FPrintF(out, " -type = map transition\n");
+          FPrintF(out, " -map:\n");
           GetTransitionMap()->Print(out);
-          PrintF(out, "\n");
+          FPrintF(out, "\n");
           return;
         case CONSTANT_FUNCTION:
-          PrintF(out, " -type = constant property transition\n");
-          PrintF(out, " -map:\n");
+          FPrintF(out, " -type = constant property transition\n");
+          FPrintF(out, " -map:\n");
           GetTransitionMap()->Print(out);
-          PrintF(out, "\n");
+          FPrintF(out, "\n");
           return;
         case CALLBACKS:
-          PrintF(out, " -type = callbacks transition\n");
-          PrintF(out, " -callback object:\n");
+          FPrintF(out, " -type = callbacks transition\n");
+          FPrintF(out, " -callback object:\n");
           GetCallbackObject()->Print(out);
           return;
         default:
@@ -108,11 +108,11 @@ void LookupResult::Print(FILE* out) {
 
 
 void Descriptor::Print(FILE* out) {
-  PrintF(out, "Descriptor ");
+  FPrintF(out, "Descriptor ");
   GetKey()->ShortPrint(out);
-  PrintF(out, " @ ");
+  FPrintF(out, " @ ");
   GetValue()->ShortPrint(out);
-  PrintF(out, " %d\n", GetDetails().descriptor_index());
+  FPrintF(out, " %d\n", GetDetails().descriptor_index());
 }
 
 
diff --git a/src/3rdparty/v8/src/string-stream.cc b/src/3rdparty/v8/src/string-stream.cc
index 30519b5..cffd7b0 100644
--- a/src/3rdparty/v8/src/string-stream.cc
+++ b/src/3rdparty/v8/src/string-stream.cc
@@ -274,10 +274,10 @@ void StringStream::OutputToFile(FILE* out) {
   for (unsigned next; (next = position + 2048) < length_; position = next) {
     char save = buffer_[next];
     buffer_[next] = '\0';
-    internal::PrintF(out, "%s", &buffer_[position]);
+    internal::FPrintF(out, "%s", &buffer_[position]);
     buffer_[next] = save;
   }
-  internal::PrintF(out, "%s", &buffer_[position]);
+  internal::FPrintF(out, "%s", &buffer_[position]);
 }
 
 
diff --git a/src/3rdparty/v8/src/v8utils.cc b/src/3rdparty/v8/src/v8utils.cc
index 627169e..56c00c1 100644
--- a/src/3rdparty/v8/src/v8utils.cc
+++ b/src/3rdparty/v8/src/v8utils.cc
@@ -45,7 +45,7 @@ void PrintF(const char* format, ...) {
 }
 
 
-void PrintF(FILE* out, const char* format, ...) {
+void FPrintF(FILE* out, const char* format, ...) {
   va_list arguments;
   va_start(arguments, format);
   OS::VFPrint(out, format, arguments);
diff --git a/src/3rdparty/v8/src/v8utils.h b/src/3rdparty/v8/src/v8utils.h
index 9072b4e..cb018e6 100644
--- a/src/3rdparty/v8/src/v8utils.h
+++ b/src/3rdparty/v8/src/v8utils.h
@@ -55,7 +55,7 @@ namespace internal {
 
 // Our version of printf().
 void PRINTF_CHECKING PrintF(const char* format, ...);
-void FPRINTF_CHECKING PrintF(FILE* out, const char* format, ...);
+void FPRINTF_CHECKING FPrintF(FILE* out, const char* format, ...);
 
 // Prepends the current process ID to the output.
 void PRINTF_CHECKING PrintPID(const char* format, ...);