[Isolates] Merge from bleeding_edge, revisions 5934-6100.

src/objects.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 555 matching lines @@
   if (IsNumber()) return context->number_function()->instance_prototype();
   if (IsString()) return context->string_function()->instance_prototype();
   if (IsBoolean()) {
     return context->boolean_function()->instance_prototype();
   } else {
     return heap->null_value();
   }
 }
 
 
-void Object::ShortPrint() {
+void Object::ShortPrint(FILE* out) {
   HeapStringAllocator allocator;
   StringStream accumulator(&allocator);
   ShortPrint(&accumulator);
-  accumulator.OutputToStdOut();
+  accumulator.OutputToFile(out);
 }
 
 
 void Object::ShortPrint(StringStream* accumulator) {
   if (IsSmi()) {
     Smi::cast(this)->SmiPrint(accumulator);
   } else if (IsFailure()) {
     Failure::cast(this)->FailurePrint(accumulator);
   } else {
     HeapObject::cast(this)->HeapObjectShortPrint(accumulator);
   }
 }
 
 
-void Smi::SmiPrint() {
-  PrintF("%d", value());
+void Smi::SmiPrint(FILE* out) {
+  PrintF(out, "%d", value());
 }
 
 
 void Smi::SmiPrint(StringStream* accumulator) {
   accumulator->Add("%d", value());
 }
 
 
 void Failure::FailurePrint(StringStream* accumulator) {
   accumulator->Add("Failure(%p)", reinterpret_cast<void*>(value()));
 }
 
 
-void Failure::FailurePrint() {
-  PrintF("Failure(%p)", reinterpret_cast<void*>(value()));
+void Failure::FailurePrint(FILE* out) {
+  PrintF(out, "Failure(%p)", reinterpret_cast<void*>(value()));
 }
 
 
 // Should a word be prefixed by 'a' or 'an' in order to read naturally in
 // English?  Returns false for non-ASCII or words that don't start with
 // a capital letter.  The a/an rule follows pronunciation in English.
 // We don't use the BBC's overcorrect "an historic occasion" though if
 // you speak a dialect you may well say "an 'istoric occasion".
 static bool AnWord(String* str) {
   if (str->length() == 0) return false;  // A nothing.
@@ skipping 535 matching lines @@
   }
   if (u.bits.exp == 0) {
     // Detect +0, and -0 for IEEE double precision floating point.
     if ((u.bits.man_low | u.bits.man_high) == 0)
       return GetHeap()->false_value();
   }
   return GetHeap()->true_value();
 }
 
 
-void HeapNumber::HeapNumberPrint() {
-  PrintF("%.16g", Number());
+void HeapNumber::HeapNumberPrint(FILE* out) {
+  PrintF(out, "%.16g", Number());
 }
 
 
 void HeapNumber::HeapNumberPrint(StringStream* accumulator) {
   // The Windows version of vsnprintf can allocate when printing a %g string
   // into a buffer that may not be big enough.  We don't want random memory
   // allocation when producing post-crash stack traces, so we print into a
   // buffer that is plenty big enough for any floating point number, then
   // print that using vsnprintf (which may truncate but never allocate if
   // there is no more space in the buffer).
@@ skipping 1978 matching lines @@
   if (convert_back_to_fast) {
     { MaybeObject* maybe_ok = TransformToFastProperties(0);
       if (!maybe_ok->ToObject(&ok)) return maybe_ok;
     }
   }
   return result;
 }
 
 MaybeObject* JSObject::DefineAccessor(String* name,
                                       bool is_getter,
-                                      JSFunction* fun,
+                                      Object* fun,
                                       PropertyAttributes attributes) {
+  ASSERT(fun->IsJSFunction() || fun->IsUndefined());
   Isolate* isolate = GetIsolate();
   // Check access rights if needed.
   if (IsAccessCheckNeeded() &&
       !isolate->MayNamedAccess(this, name, v8::ACCESS_SET)) {
     isolate->ReportFailedAccessCheck(this, v8::ACCESS_SET);
     return isolate->heap()->undefined_value();
   }
 
   if (IsJSGlobalProxy()) {
     Object* proto = GetPrototype();
@@ skipping 2376 matching lines @@
   return this;
 }
 
 
 Object* JSFunction::SetInstanceClassName(String* name) {
   shared()->set_instance_class_name(name);
   return this;
 }
 
 
-void JSFunction::PrintName() {
+void JSFunction::PrintName(FILE* out) {
   SmartPointer<char> name = shared()->DebugName()->ToCString();
-  PrintF("%s", *name);
+  PrintF(out, "%s", *name);
 }
 
 
 Context* JSFunction::GlobalContextFromLiterals(FixedArray* literals) {
   return Context::cast(literals->get(JSFunction::kLiteralGlobalContextIndex));
 }
 
 
 MaybeObject* Oddball::Initialize(const char* to_string,
                                  Object* to_number,
@@ skipping 521 matching lines @@
     RelocInfo* info = it.rinfo();
     Object* object = info->target_object();
     if (object->IsMap()) return Map::cast(object);
   }
   return NULL;
 }
 
 
 #ifdef ENABLE_DISASSEMBLER
 
-#ifdef DEBUG
+#ifdef OBJECT_PRINT
 
-void DeoptimizationInputData::DeoptimizationInputDataPrint() {
+void DeoptimizationInputData::DeoptimizationInputDataPrint(FILE* out) {
   disasm::NameConverter converter;
   int deopt_count = DeoptCount();
-  PrintF("Deoptimization Input Data (deopt points = %d)\n", deopt_count);
+  PrintF(out, "Deoptimization Input Data (deopt points = %d)\n", deopt_count);
   if (0 == deopt_count) return;
 
-  PrintF("%6s  %6s  %6s  %12s\n", "index", "ast id", "argc", "commands");
+  PrintF(out, "%6s  %6s  %6s  %12s\n", "index", "ast id", "argc", "commands");
   for (int i = 0; i < deopt_count; i++) {
     int command_count = 0;
-    PrintF("%6d  %6d  %6d",
+    PrintF(out, "%6d  %6d  %6d",
            i, AstId(i)->value(), ArgumentsStackHeight(i)->value());
     int translation_index = TranslationIndex(i)->value();
     TranslationIterator iterator(TranslationByteArray(), translation_index);
     Translation::Opcode opcode =
         static_cast<Translation::Opcode>(iterator.Next());
     ASSERT(Translation::BEGIN == opcode);
     int frame_count = iterator.Next();
     if (FLAG_print_code_verbose) {
-      PrintF("  %s {count=%d}\n", Translation::StringFor(opcode), frame_count);
+      PrintF(out, "  %s {count=%d}\n", Translation::StringFor(opcode),
+             frame_count);
     }
 
     for (int i = 0; i < frame_count; ++i) {
       opcode = static_cast<Translation::Opcode>(iterator.Next());
       ASSERT(Translation::FRAME == opcode);
       int ast_id = iterator.Next();
       int function_id = iterator.Next();
       JSFunction* function =
           JSFunction::cast(LiteralArray()->get(function_id));
       unsigned height = iterator.Next();
       if (FLAG_print_code_verbose) {
-        PrintF("%24s  %s {ast_id=%d, function=",
+        PrintF(out, "%24s  %s {ast_id=%d, function=",
                "", Translation::StringFor(opcode), ast_id);
-        function->PrintName();
-        PrintF(", height=%u}\n", height);
+        function->PrintName(out);
+        PrintF(out, ", height=%u}\n", height);
       }
 
       // Size of translation is height plus all incoming arguments including
       // receiver.
       int size = height + function->shared()->formal_parameter_count() + 1;
       command_count += size;
       for (int j = 0; j < size; ++j) {
         opcode = static_cast<Translation::Opcode>(iterator.Next());
         if (FLAG_print_code_verbose) {
-          PrintF("%24s    %s ", "", Translation::StringFor(opcode));
+          PrintF(out, "%24s    %s ", "", Translation::StringFor(opcode));
         }
 
         if (opcode == Translation::DUPLICATE) {
           opcode = static_cast<Translation::Opcode>(iterator.Next());
           if (FLAG_print_code_verbose) {
-            PrintF("%s ", Translation::StringFor(opcode));
+            PrintF(out, "%s ", Translation::StringFor(opcode));
           }
           --j;  // Two commands share the same frame index.
         }
 
         switch (opcode) {
           case Translation::BEGIN:
           case Translation::FRAME:
           case Translation::DUPLICATE:
             UNREACHABLE();
             break;
 
           case Translation::REGISTER: {
             int reg_code = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{input=%s}", converter.NameOfCPURegister(reg_code));
+              PrintF(out, "{input=%s}", converter.NameOfCPURegister(reg_code));
             }
             break;
           }
 
           case Translation::INT32_REGISTER: {
             int reg_code = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{input=%s}", converter.NameOfCPURegister(reg_code));
+              PrintF(out, "{input=%s}", converter.NameOfCPURegister(reg_code));
             }
             break;
           }
 
           case Translation::DOUBLE_REGISTER: {
             int reg_code = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{input=%s}",
+              PrintF(out, "{input=%s}",
                      DoubleRegister::AllocationIndexToString(reg_code));
             }
             break;
           }
 
           case Translation::STACK_SLOT: {
             int input_slot_index = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{input=%d}", input_slot_index);
+              PrintF(out, "{input=%d}", input_slot_index);
             }
             break;
           }
 
           case Translation::INT32_STACK_SLOT: {
             int input_slot_index = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{input=%d}", input_slot_index);
+              PrintF(out, "{input=%d}", input_slot_index);
             }
             break;
           }
 
           case Translation::DOUBLE_STACK_SLOT: {
             int input_slot_index = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{input=%d}", input_slot_index);
+              PrintF(out, "{input=%d}", input_slot_index);
             }
             break;
           }
 
           case Translation::LITERAL: {
             unsigned literal_index = iterator.Next();
             if (FLAG_print_code_verbose)  {
-              PrintF("{literal_id=%u}", literal_index);
+              PrintF(out, "{literal_id=%u}", literal_index);
             }
             break;
           }
 
           case Translation::ARGUMENTS_OBJECT:
             break;
         }
-        if (FLAG_print_code_verbose) PrintF("\n");
+        if (FLAG_print_code_verbose) PrintF(out, "\n");
       }
     }
-    if (!FLAG_print_code_verbose) PrintF("  %12d\n", command_count);
+    if (!FLAG_print_code_verbose) PrintF(out, "  %12d\n", command_count);
   }
 }
 
 
-void DeoptimizationOutputData::DeoptimizationOutputDataPrint() {
-  PrintF("Deoptimization Output Data (deopt points = %d)\n",
+void DeoptimizationOutputData::DeoptimizationOutputDataPrint(FILE* out) {
+  PrintF(out, "Deoptimization Output Data (deopt points = %d)\n",
          this->DeoptPoints());
   if (this->DeoptPoints() == 0) return;
 
   PrintF("%6s  %8s  %s\n", "ast id", "pc", "state");
   for (int i = 0; i < this->DeoptPoints(); i++) {
     int pc_and_state = this->PcAndState(i)->value();
     PrintF("%6d  %8d  %s\n",
            this->AstId(i)->value(),
            FullCodeGenerator::PcField::decode(pc_and_state),
            FullCodeGenerator::State2String(
@@ skipping 50 matching lines @@
     case INTERCEPTOR: return "INTERCEPTOR";
     case MAP_TRANSITION: return "MAP_TRANSITION";
     case CONSTANT_TRANSITION: return "CONSTANT_TRANSITION";
     case NULL_DESCRIPTOR: return "NULL_DESCRIPTOR";
   }
   UNREACHABLE();
   return NULL;
 }
 
 
-void Code::Disassemble(const char* name) {
-  PrintF("kind = %s\n", Kind2String(kind()));
+void Code::Disassemble(const char* name, FILE* out) {
+  PrintF(out, "kind = %s\n", Kind2String(kind()));
   if (is_inline_cache_stub()) {
-    PrintF("ic_state = %s\n", ICState2String(ic_state()));
-    PrintF("ic_in_loop = %d\n", ic_in_loop() == IN_LOOP);
+    PrintF(out, "ic_state = %s\n", ICState2String(ic_state()));
+    PrintF(out, "ic_in_loop = %d\n", ic_in_loop() == IN_LOOP);
     if (ic_state() == MONOMORPHIC) {
-      PrintF("type = %s\n", PropertyType2String(type()));
+      PrintF(out, "type = %s\n", PropertyType2String(type()));
     }
   }
   if ((name != NULL) && (name[0] != '\0')) {
-    PrintF("name = %s\n", name);
+    PrintF(out, "name = %s\n", name);
   }
   if (kind() == OPTIMIZED_FUNCTION) {
-    PrintF("stack_slots = %d\n", stack_slots());
+    PrintF(out, "stack_slots = %d\n", stack_slots());
   }
 
-  PrintF("Instructions (size = %d)\n", instruction_size());
-  Disassembler::Decode(NULL, this);
-  PrintF("\n");
+  PrintF(out, "Instructions (size = %d)\n", instruction_size());
+  Disassembler::Decode(out, this);
+  PrintF(out, "\n");
 
 #ifdef DEBUG
   if (kind() == FUNCTION) {
     DeoptimizationOutputData* data =
         DeoptimizationOutputData::cast(this->deoptimization_data());
-    data->DeoptimizationOutputDataPrint();
+    data->DeoptimizationOutputDataPrint(out);
   } else if (kind() == OPTIMIZED_FUNCTION) {
     DeoptimizationInputData* data =
         DeoptimizationInputData::cast(this->deoptimization_data());
-    data->DeoptimizationInputDataPrint();
+    data->DeoptimizationInputDataPrint(out);
   }
   PrintF("\n");
 #endif
 
   if (kind() == OPTIMIZED_FUNCTION) {
     SafepointTable table(this);
-    PrintF("Safepoints (size = %u)\n", table.size());
+    PrintF(out, "Safepoints (size = %u)\n", table.size());
     for (unsigned i = 0; i < table.length(); i++) {
       unsigned pc_offset = table.GetPcOffset(i);
-      PrintF("%p  %4d  ", (instruction_start() + pc_offset), pc_offset);
+      PrintF(out, "%p  %4d  ", (instruction_start() + pc_offset), pc_offset);
       table.PrintEntry(i);
-      PrintF(" (sp -> fp)");
+      PrintF(out, " (sp -> fp)");
       int deoptimization_index = table.GetDeoptimizationIndex(i);
       if (deoptimization_index != Safepoint::kNoDeoptimizationIndex) {
-        PrintF("  %6d", deoptimization_index);
+        PrintF(out, "  %6d", deoptimization_index);
       } else {
-        PrintF("  <none>");
+        PrintF(out, "  <none>");
       }
-      PrintF("\n");
+      PrintF(out, "\n");
     }
-    PrintF("\n");
+    PrintF(out, "\n");
   } else if (kind() == FUNCTION) {
     unsigned offset = stack_check_table_start();
     // If there is no stack check table, the "table start" will at or after
     // (due to alignment) the end of the instruction stream.
     if (static_cast<int>(offset) < instruction_size()) {
       unsigned* address =
           reinterpret_cast<unsigned*>(instruction_start() + offset);
       unsigned length = address[0];
-      PrintF("Stack checks (size = %u)\n", length);
-      PrintF("ast_id  pc_offset\n");
+      PrintF(out, "Stack checks (size = %u)\n", length);
+      PrintF(out, "ast_id  pc_offset\n");
       for (unsigned i = 0; i < length; ++i) {
         unsigned index = (2 * i) + 1;
-        PrintF("%6u  %9u\n", address[index], address[index + 1]);
+        PrintF(out, "%6u  %9u\n", address[index], address[index + 1]);
       }
-      PrintF("\n");
+      PrintF(out, "\n");
     }
   }
 
   PrintF("RelocInfo (size = %d)\n", relocation_size());
-  for (RelocIterator it(this); !it.done(); it.next()) it.rinfo()->Print();
-  PrintF("\n");
+  for (RelocIterator it(this); !it.done(); it.next()) it.rinfo()->Print(out);
+  PrintF(out, "\n");
 }
 #endif  // ENABLE_DISASSEMBLER
 
 
 MaybeObject* JSObject::SetFastElementsCapacityAndLength(int capacity,
                                                         int length) {
   Heap* heap = GetHeap();
   // We should never end in here with a pixel or external array.
   ASSERT(!HasPixelElements() && !HasExternalArrayElements());
 
@@ skipping 1148 matching lines @@
   return static_cast<uint32_t>(dictionary->Capacity()) >=
       (length / (2 * NumberDictionary::kEntrySize));
 }
 
 
 // Certain compilers request function template instantiation when they
 // see the definition of the other template functions in the
 // class. This requires us to have the template functions put
 // together, so even though this function belongs in objects-debug.cc,
 // we keep it here instead to satisfy certain compilers.
-#ifdef DEBUG
+#ifdef OBJECT_PRINT
 template<typename Shape, typename Key>
-void Dictionary<Shape, Key>::Print() {
+void Dictionary<Shape, Key>::Print(FILE* out) {
   int capacity = HashTable<Shape, Key>::Capacity();
   for (int i = 0; i < capacity; i++) {
     Object* k = HashTable<Shape, Key>::KeyAt(i);
     if (HashTable<Shape, Key>::IsKey(k)) {
-      PrintF(" ");
+      PrintF(out, " ");
       if (k->IsString()) {
-        String::cast(k)->StringPrint();
+        String::cast(k)->StringPrint(out);
       } else {
-        k->ShortPrint();
+        k->ShortPrint(out);
       }
-      PrintF(": ");
-      ValueAt(i)->ShortPrint();
-      PrintF("\n");
+      PrintF(out, ": ");
+      ValueAt(i)->ShortPrint(out);
+      PrintF(out, "\n");
     }
   }
 }
 #endif
 
 
 template<typename Shape, typename Key>
 void Dictionary<Shape, Key>::CopyValuesTo(FixedArray* elements) {
   int pos = 0;
   int capacity = HashTable<Shape, Key>::Capacity();
@@ skipping 2267 matching lines @@
   if (break_point_objects()->IsUndefined()) return 0;
   // Single beak point.
   if (!break_point_objects()->IsFixedArray()) return 1;
   // Multiple break points.
   return FixedArray::cast(break_point_objects())->length();
 }
 #endif
 
 
 } }  // namespace v8::internal