src/v8/src/code-stubs.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 #include "v8.h"
  29
  30 #include "bootstrapper.h"
  31 #include "code-stubs.h"
  32 #include "cpu-profiler.h"
  33 #include "stub-cache.h"
  34 #include "factory.h"
  35 #include "gdb-jit.h"
  36 #include "macro-assembler.h"
  37
  38 namespace v8 {
  39 namespace internal {
  40
  41
  42 CodeStubInterfaceDescriptor::CodeStubInterfaceDescriptor()
  43     : register_param_count_(-1),
  44       stack_parameter_count_(no_reg),
  45       hint_stack_parameter_count_(-1),
  46       function_mode_(NOT_JS_FUNCTION_STUB_MODE),
  47       register_params_(NULL),
  48       deoptimization_handler_(NULL),
  49       handler_arguments_mode_(DONT_PASS_ARGUMENTS),
  50       miss_handler_(),
  51       has_miss_handler_(false) { }
  52
  53
  54 bool CodeStub::FindCodeInCache(Code** code_out, Isolate* isolate) {
  55   UnseededNumberDictionary* stubs = isolate->heap()->code_stubs();
  56   int index = stubs->FindEntry(GetKey());
  57   if (index != UnseededNumberDictionary::kNotFound) {
  58     *code_out = Code::cast(stubs->ValueAt(index));
  59     return true;
  60   }
  61   return false;
  62 }
  63
  64
  65 SmartArrayPointer<const char> CodeStub::GetName() {
  66   char buffer[100];
  67   NoAllocationStringAllocator allocator(buffer,
  68                                         static_cast<unsigned>(sizeof(buffer)));
  69   StringStream stream(&allocator);
  70   PrintName(&stream);
  71   return stream.ToCString();
  72 }
  73
  74
  75 void CodeStub::RecordCodeGeneration(Code* code, Isolate* isolate) {
  76   SmartArrayPointer<const char> name = GetName();
  77   PROFILE(isolate, CodeCreateEvent(Logger::STUB_TAG, code, name.get()));
  78   GDBJIT(AddCode(GDBJITInterface::STUB, name.get(), code));
  79   Counters* counters = isolate->counters();
  80   counters->total_stubs_code_size()->Increment(code->instruction_size());
  81 }
  82
  83
  84 Code::Kind CodeStub::GetCodeKind() const {
  85   return Code::STUB;
  86 }
  87
  88
  89 Handle<Code> CodeStub::GetCodeCopy(Isolate* isolate,
  90                                    const Code::FindAndReplacePattern& pattern) {
  91   Handle<Code> ic = GetCode(isolate);
  92   ic = isolate->factory()->CopyCode(ic);
  93   ic->FindAndReplace(pattern);
  94   RecordCodeGeneration(*ic, isolate);
  95   return ic;
  96 }
  97
  98
  99 Handle<Code> PlatformCodeStub::GenerateCode(Isolate* isolate) {
 100   Factory* factory = isolate->factory();
 101
 102   // Generate the new code.
 103   MacroAssembler masm(isolate, NULL, 256);
 104
 105   {
 106     // Update the static counter each time a new code stub is generated.
 107     isolate->counters()->code_stubs()->Increment();
 108
 109     // Generate the code for the stub.
 110     masm.set_generating_stub(true);
 111     NoCurrentFrameScope scope(&masm);
 112     Generate(&masm);
 113   }
 114
 115   // Create the code object.
 116   CodeDesc desc;
 117   masm.GetCode(&desc);
 118
 119   // Copy the generated code into a heap object.
 120   Code::Flags flags = Code::ComputeFlags(
 121       GetCodeKind(),
 122       GetICState(),
 123       GetExtraICState(),
 124       GetStubType());
 125   Handle<Code> new_object = factory->NewCode(
 126       desc, flags, masm.CodeObject(), NeedsImmovableCode());
 127   return new_object;
 128 }
 129
 130
 131 void CodeStub::VerifyPlatformFeatures(Isolate* isolate) {
 132   ASSERT(CpuFeatures::VerifyCrossCompiling());
 133 }
 134
 135
 136 Handle<Code> CodeStub::GetCode(Isolate* isolate) {
 137   Factory* factory = isolate->factory();
 138   Heap* heap = isolate->heap();
 139   Code* code;
 140   if (UseSpecialCache()
 141       ? FindCodeInSpecialCache(&code, isolate)
 142       : FindCodeInCache(&code, isolate)) {
 143     ASSERT(GetCodeKind() == code->kind());
 144     return Handle<Code>(code);
 145   }
 146
 147 #ifdef DEBUG
 148   VerifyPlatformFeatures(isolate);
 149 #endif
 150
 151   {
 152     HandleScope scope(isolate);
 153
 154     Handle<Code> new_object = GenerateCode(isolate);
 155     new_object->set_major_key(MajorKey());
 156     FinishCode(new_object);
 157     RecordCodeGeneration(*new_object, isolate);
 158
 159 #ifdef ENABLE_DISASSEMBLER
 160     if (FLAG_print_code_stubs) {
 161       CodeTracer::Scope trace_scope(isolate->GetCodeTracer());
 162       new_object->Disassemble(GetName().get(), trace_scope.file());
 163       PrintF(trace_scope.file(), "\n");
 164     }
 165 #endif
 166
 167     if (UseSpecialCache()) {
 168       AddToSpecialCache(new_object);
 169     } else {
 170       // Update the dictionary and the root in Heap.
 171       Handle<UnseededNumberDictionary> dict =
 172           factory->DictionaryAtNumberPut(
 173               Handle<UnseededNumberDictionary>(heap->code_stubs()),
 174               GetKey(),
 175               new_object);
 176       heap->public_set_code_stubs(*dict);
 177     }
 178     code = *new_object;
 179   }
 180
 181   Activate(code);
 182   ASSERT(!NeedsImmovableCode() ||
 183          heap->lo_space()->Contains(code) ||
 184          heap->code_space()->FirstPage()->Contains(code->address()));
 185   return Handle<Code>(code, isolate);
 186 }
 187
 188
 189 const char* CodeStub::MajorName(CodeStub::Major major_key,
 190                                 bool allow_unknown_keys) {
 191   switch (major_key) {
 192 #define DEF_CASE(name) case name: return #name "Stub";
 193     CODE_STUB_LIST(DEF_CASE)
 194 #undef DEF_CASE
 195     case UninitializedMajorKey: return "<UninitializedMajorKey>Stub";
 196     default:
 197       if (!allow_unknown_keys) {
 198         UNREACHABLE();
 199       }
 200       return NULL;
 201   }
 202 }
 203
 204
 205 void CodeStub::PrintBaseName(StringStream* stream) {
 206   stream->Add("%s", MajorName(MajorKey(), false));
 207 }
 208
 209
 210 void CodeStub::PrintName(StringStream* stream) {
 211   PrintBaseName(stream);
 212   PrintState(stream);
 213 }
 214
 215
 216 // static
 217 void BinaryOpICStub::GenerateAheadOfTime(Isolate* isolate) {
 218   // Generate the uninitialized versions of the stub.
 219   for (int op = Token::BIT_OR; op <= Token::MOD; ++op) {
 220     for (int mode = NO_OVERWRITE; mode <= OVERWRITE_RIGHT; ++mode) {
 221       BinaryOpICStub stub(static_cast<Token::Value>(op),
 222                           static_cast<OverwriteMode>(mode));
 223       stub.GetCode(isolate);
 224     }
 225   }
 226
 227   // Generate special versions of the stub.
 228   BinaryOpIC::State::GenerateAheadOfTime(isolate, &GenerateAheadOfTime);
 229 }
 230
 231
 232 void BinaryOpICStub::PrintState(StringStream* stream) {
 233   state_.Print(stream);
 234 }
 235
 236
 237 // static
 238 void BinaryOpICStub::GenerateAheadOfTime(Isolate* isolate,
 239                                          const BinaryOpIC::State& state) {
 240   BinaryOpICStub stub(state);
 241   stub.GetCode(isolate);
 242 }
 243
 244
 245 // static
 246 void BinaryOpICWithAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
 247   // Generate special versions of the stub.
 248   BinaryOpIC::State::GenerateAheadOfTime(isolate, &GenerateAheadOfTime);
 249 }
 250
 251
 252 void BinaryOpICWithAllocationSiteStub::PrintState(StringStream* stream) {
 253   state_.Print(stream);
 254 }
 255
 256
 257 // static
 258 void BinaryOpICWithAllocationSiteStub::GenerateAheadOfTime(
 259     Isolate* isolate, const BinaryOpIC::State& state) {
 260   if (state.CouldCreateAllocationMementos()) {
 261     BinaryOpICWithAllocationSiteStub stub(state);
 262     stub.GetCode(isolate);
 263   }
 264 }
 265
 266
 267 void StringAddStub::PrintBaseName(StringStream* stream) {
 268   stream->Add("StringAddStub");
 269   if ((flags() & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_BOTH) {
 270     stream->Add("_CheckBoth");
 271   } else if ((flags() & STRING_ADD_CHECK_LEFT) == STRING_ADD_CHECK_LEFT) {
 272     stream->Add("_CheckLeft");
 273   } else if ((flags() & STRING_ADD_CHECK_RIGHT) == STRING_ADD_CHECK_RIGHT) {
 274     stream->Add("_CheckRight");
 275   }
 276   if (pretenure_flag() == TENURED) {
 277     stream->Add("_Tenured");
 278   }
 279 }
 280
 281
 282 InlineCacheState ICCompareStub::GetICState() {
 283   CompareIC::State state = Max(left_, right_);
 284   switch (state) {
 285     case CompareIC::UNINITIALIZED:
 286       return ::v8::internal::UNINITIALIZED;
 287     case CompareIC::SMI:
 288     case CompareIC::NUMBER:
 289     case CompareIC::INTERNALIZED_STRING:
 290     case CompareIC::STRING:
 291     case CompareIC::UNIQUE_NAME:
 292     case CompareIC::OBJECT:
 293     case CompareIC::KNOWN_OBJECT:
 294       return MONOMORPHIC;
 295     case CompareIC::GENERIC:
 296       return ::v8::internal::GENERIC;
 297   }
 298   UNREACHABLE();
 299   return ::v8::internal::UNINITIALIZED;
 300 }
 301
 302
 303 void ICCompareStub::AddToSpecialCache(Handle<Code> new_object) {
 304   ASSERT(*known_map_ != NULL);
 305   Isolate* isolate = new_object->GetIsolate();
 306   Factory* factory = isolate->factory();
 307   return Map::UpdateCodeCache(known_map_,
 308                               strict() ?
 309                                   factory->strict_compare_ic_string() :
 310                                   factory->compare_ic_string(),
 311                               new_object);
 312 }
 313
 314
 315 bool ICCompareStub::FindCodeInSpecialCache(Code** code_out, Isolate* isolate) {
 316   Factory* factory = isolate->factory();
 317   Code::Flags flags = Code::ComputeFlags(
 318       GetCodeKind(),
 319       UNINITIALIZED);
 320   ASSERT(op_ == Token::EQ || op_ == Token::EQ_STRICT);
 321   Handle<Object> probe(
 322       known_map_->FindInCodeCache(
 323         strict() ?
 324             *factory->strict_compare_ic_string() :
 325             *factory->compare_ic_string(),
 326         flags),
 327       isolate);
 328   if (probe->IsCode()) {
 329     *code_out = Code::cast(*probe);
 330 #ifdef DEBUG
 331     Token::Value cached_op;
 332     ICCompareStub::DecodeMinorKey((*code_out)->stub_info(), NULL, NULL, NULL,
 333                                   &cached_op);
 334     ASSERT(op_ == cached_op);
 335 #endif
 336     return true;
 337   }
 338   return false;
 339 }
 340
 341
 342 int ICCompareStub::MinorKey() {
 343   return OpField::encode(op_ - Token::EQ) |
 344          LeftStateField::encode(left_) |
 345          RightStateField::encode(right_) |
 346          HandlerStateField::encode(state_);
 347 }
 348
 349
 350 void ICCompareStub::DecodeMinorKey(int minor_key,
 351                                    CompareIC::State* left_state,
 352                                    CompareIC::State* right_state,
 353                                    CompareIC::State* handler_state,
 354                                    Token::Value* op) {
 355   if (left_state) {
 356     *left_state =
 357         static_cast<CompareIC::State>(LeftStateField::decode(minor_key));
 358   }
 359   if (right_state) {
 360     *right_state =
 361         static_cast<CompareIC::State>(RightStateField::decode(minor_key));
 362   }
 363   if (handler_state) {
 364     *handler_state =
 365         static_cast<CompareIC::State>(HandlerStateField::decode(minor_key));
 366   }
 367   if (op) {
 368     *op = static_cast<Token::Value>(OpField::decode(minor_key) + Token::EQ);
 369   }
 370 }
 371
 372
 373 void ICCompareStub::Generate(MacroAssembler* masm) {
 374   switch (state_) {
 375     case CompareIC::UNINITIALIZED:
 376       GenerateMiss(masm);
 377       break;
 378     case CompareIC::SMI:
 379       GenerateSmis(masm);
 380       break;
 381     case CompareIC::NUMBER:
 382       GenerateNumbers(masm);
 383       break;
 384     case CompareIC::STRING:
 385       GenerateStrings(masm);
 386       break;
 387     case CompareIC::INTERNALIZED_STRING:
 388       GenerateInternalizedStrings(masm);
 389       break;
 390     case CompareIC::UNIQUE_NAME:
 391       GenerateUniqueNames(masm);
 392       break;
 393     case CompareIC::OBJECT:
 394       GenerateObjects(masm);
 395       break;
 396     case CompareIC::KNOWN_OBJECT:
 397       ASSERT(*known_map_ != NULL);
 398       GenerateKnownObjects(masm);
 399       break;
 400     case CompareIC::GENERIC:
 401       GenerateGeneric(masm);
 402       break;
 403   }
 404 }
 405
 406
 407 void CompareNilICStub::UpdateStatus(Handle<Object> object) {
 408   ASSERT(!state_.Contains(GENERIC));
 409   State old_state(state_);
 410   if (object->IsNull()) {
 411     state_.Add(NULL_TYPE);
 412   } else if (object->IsUndefined()) {
 413     state_.Add(UNDEFINED);
 414   } else if (object->IsUndetectableObject() ||
 415              object->IsOddball() ||
 416              !object->IsHeapObject()) {
 417     state_.RemoveAll();
 418     state_.Add(GENERIC);
 419   } else if (IsMonomorphic()) {
 420     state_.RemoveAll();
 421     state_.Add(GENERIC);
 422   } else {
 423     state_.Add(MONOMORPHIC_MAP);
 424   }
 425   TraceTransition(old_state, state_);
 426 }
 427
 428
 429 template<class StateType>
 430 void HydrogenCodeStub::TraceTransition(StateType from, StateType to) {
 431   // Note: Although a no-op transition is semantically OK, it is hinting at a
 432   // bug somewhere in our state transition machinery.
 433   ASSERT(from != to);
 434   if (!FLAG_trace_ic) return;
 435   char buffer[100];
 436   NoAllocationStringAllocator allocator(buffer,
 437                                         static_cast<unsigned>(sizeof(buffer)));
 438   StringStream stream(&allocator);
 439   stream.Add("[");
 440   PrintBaseName(&stream);
 441   stream.Add(": ");
 442   from.Print(&stream);
 443   stream.Add("=>");
 444   to.Print(&stream);
 445   stream.Add("]\n");
 446   stream.OutputToStdOut();
 447 }
 448
 449
 450 void CompareNilICStub::PrintBaseName(StringStream* stream) {
 451   CodeStub::PrintBaseName(stream);
 452   stream->Add((nil_value_ == kNullValue) ? "(NullValue)":
 453                                            "(UndefinedValue)");
 454 }
 455
 456
 457 void CompareNilICStub::PrintState(StringStream* stream) {
 458   state_.Print(stream);
 459 }
 460
 461
 462 void CompareNilICStub::State::Print(StringStream* stream) const {
 463   stream->Add("(");
 464   SimpleListPrinter printer(stream);
 465   if (IsEmpty()) printer.Add("None");
 466   if (Contains(UNDEFINED)) printer.Add("Undefined");
 467   if (Contains(NULL_TYPE)) printer.Add("Null");
 468   if (Contains(MONOMORPHIC_MAP)) printer.Add("MonomorphicMap");
 469   if (Contains(GENERIC)) printer.Add("Generic");
 470   stream->Add(")");
 471 }
 472
 473
 474 Type* CompareNilICStub::GetType(Zone* zone, Handle<Map> map) {
 475   if (state_.Contains(CompareNilICStub::GENERIC)) {
 476     return Type::Any(zone);
 477   }
 478
 479   Type* result = Type::None(zone);
 480   if (state_.Contains(CompareNilICStub::UNDEFINED)) {
 481     result = Type::Union(result, Type::Undefined(zone), zone);
 482   }
 483   if (state_.Contains(CompareNilICStub::NULL_TYPE)) {
 484     result = Type::Union(result, Type::Null(zone), zone);
 485   }
 486   if (state_.Contains(CompareNilICStub::MONOMORPHIC_MAP)) {
 487     Type* type =
 488         map.is_null() ? Type::Detectable(zone) : Type::Class(map, zone);
 489     result = Type::Union(result, type, zone);
 490   }
 491
 492   return result;
 493 }
 494
 495
 496 Type* CompareNilICStub::GetInputType(Zone* zone, Handle<Map> map) {
 497   Type* output_type = GetType(zone, map);
 498   Type* nil_type =
 499       nil_value_ == kNullValue ? Type::Null(zone) : Type::Undefined(zone);
 500   return Type::Union(output_type, nil_type, zone);
 501 }
 502
 503
 504 void InstanceofStub::PrintName(StringStream* stream) {
 505   const char* args = "";
 506   if (HasArgsInRegisters()) {
 507     args = "_REGS";
 508   }
 509
 510   const char* inline_check = "";
 511   if (HasCallSiteInlineCheck()) {
 512     inline_check = "_INLINE";
 513   }
 514
 515   const char* return_true_false_object = "";
 516   if (ReturnTrueFalseObject()) {
 517     return_true_false_object = "_TRUEFALSE";
 518   }
 519
 520   stream->Add("InstanceofStub%s%s%s",
 521               args,
 522               inline_check,
 523               return_true_false_object);
 524 }
 525
 526
 527 void JSEntryStub::FinishCode(Handle<Code> code) {
 528   Handle<FixedArray> handler_table =
 529       code->GetIsolate()->factory()->NewFixedArray(1, TENURED);
 530   handler_table->set(0, Smi::FromInt(handler_offset_));
 531   code->set_handler_table(*handler_table);
 532 }
 533
 534
 535 void KeyedLoadDictionaryElementPlatformStub::Generate(
 536     MacroAssembler* masm) {
 537   KeyedLoadStubCompiler::GenerateLoadDictionaryElement(masm);
 538 }
 539
 540
 541 void CreateAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
 542   CreateAllocationSiteStub stub;
 543   stub.GetCode(isolate);
 544 }
 545
 546
 547 void KeyedStoreElementStub::Generate(MacroAssembler* masm) {
 548   switch (elements_kind_) {
 549     case FAST_ELEMENTS:
 550     case FAST_HOLEY_ELEMENTS:
 551     case FAST_SMI_ELEMENTS:
 552     case FAST_HOLEY_SMI_ELEMENTS:
 553     case FAST_DOUBLE_ELEMENTS:
 554     case FAST_HOLEY_DOUBLE_ELEMENTS:
 555 #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
 556     case EXTERNAL_##TYPE##_ELEMENTS:                    \
 557     case TYPE##_ELEMENTS:
 558
 559     TYPED_ARRAYS(TYPED_ARRAY_CASE)
 560 #undef TYPED_ARRAY_CASE
 561       UNREACHABLE();
 562       break;
 563     case DICTIONARY_ELEMENTS:
 564       KeyedStoreStubCompiler::GenerateStoreDictionaryElement(masm);
 565       break;
 566     case SLOPPY_ARGUMENTS_ELEMENTS:
 567       UNREACHABLE();
 568       break;
 569   }
 570 }
 571
 572
 573 void ArgumentsAccessStub::PrintName(StringStream* stream) {
 574   stream->Add("ArgumentsAccessStub_");
 575   switch (type_) {
 576     case READ_ELEMENT: stream->Add("ReadElement"); break;
 577     case NEW_SLOPPY_FAST: stream->Add("NewSloppyFast"); break;
 578     case NEW_SLOPPY_SLOW: stream->Add("NewSloppySlow"); break;
 579     case NEW_STRICT: stream->Add("NewStrict"); break;
 580   }
 581 }
 582
 583
 584 void CallFunctionStub::PrintName(StringStream* stream) {
 585   stream->Add("CallFunctionStub_Args%d", argc_);
 586   if (RecordCallTarget()) stream->Add("_Recording");
 587 }
 588
 589
 590 void CallConstructStub::PrintName(StringStream* stream) {
 591   stream->Add("CallConstructStub");
 592   if (RecordCallTarget()) stream->Add("_Recording");
 593 }
 594
 595
 596 void ArrayConstructorStub::PrintName(StringStream* stream) {
 597   stream->Add("ArrayConstructorStub");
 598   switch (argument_count_) {
 599     case ANY: stream->Add("_Any"); break;
 600     case NONE: stream->Add("_None"); break;
 601     case ONE: stream->Add("_One"); break;
 602     case MORE_THAN_ONE: stream->Add("_More_Than_One"); break;
 603   }
 604 }
 605
 606
 607 void ArrayConstructorStubBase::BasePrintName(const char* name,
 608                                              StringStream* stream) {
 609   stream->Add(name);
 610   stream->Add("_");
 611   stream->Add(ElementsKindToString(elements_kind()));
 612   if (override_mode() == DISABLE_ALLOCATION_SITES) {
 613     stream->Add("_DISABLE_ALLOCATION_SITES");
 614   }
 615 }
 616
 617
 618 bool ToBooleanStub::UpdateStatus(Handle<Object> object) {
 619   Types old_types(types_);
 620   bool to_boolean_value = types_.UpdateStatus(object);
 621   TraceTransition(old_types, types_);
 622   return to_boolean_value;
 623 }
 624
 625
 626 void ToBooleanStub::PrintState(StringStream* stream) {
 627   types_.Print(stream);
 628 }
 629
 630
 631 void ToBooleanStub::Types::Print(StringStream* stream) const {
 632   stream->Add("(");
 633   SimpleListPrinter printer(stream);
 634   if (IsEmpty()) printer.Add("None");
 635   if (Contains(UNDEFINED)) printer.Add("Undefined");
 636   if (Contains(BOOLEAN)) printer.Add("Bool");
 637   if (Contains(NULL_TYPE)) printer.Add("Null");
 638   if (Contains(SMI)) printer.Add("Smi");
 639   if (Contains(SPEC_OBJECT)) printer.Add("SpecObject");
 640   if (Contains(STRING)) printer.Add("String");
 641   if (Contains(SYMBOL)) printer.Add("Symbol");
 642   if (Contains(HEAP_NUMBER)) printer.Add("HeapNumber");
 643   if (Contains(FLOAT32x4)) printer.Add("Float32x4");
 644   if (Contains(INT32x4)) printer.Add("Int32x4");
 645   stream->Add(")");
 646 }
 647
 648
 649 bool ToBooleanStub::Types::UpdateStatus(Handle<Object> object) {
 650   if (object->IsUndefined()) {
 651     Add(UNDEFINED);
 652     return false;
 653   } else if (object->IsBoolean()) {
 654     Add(BOOLEAN);
 655     return object->IsTrue();
 656   } else if (object->IsNull()) {
 657     Add(NULL_TYPE);
 658     return false;
 659   } else if (object->IsSmi()) {
 660     Add(SMI);
 661     return Smi::cast(*object)->value() != 0;
 662   } else if (object->IsSpecObject()) {
 663     Add(SPEC_OBJECT);
 664     return !object->IsUndetectableObject();
 665   } else if (object->IsString()) {
 666     Add(STRING);
 667     return !object->IsUndetectableObject() &&
 668         String::cast(*object)->length() != 0;
 669   } else if (object->IsSymbol()) {
 670     Add(SYMBOL);
 671     return true;
 672   } else if (object->IsFloat32x4()) {
 673     Add(FLOAT32x4);
 674     return true;
 675   } else if (object->IsInt32x4()) {
 676     Add(INT32x4);
 677     return true;
 678   } else if (object->IsHeapNumber()) {
 679     ASSERT(!object->IsUndetectableObject());
 680     Add(HEAP_NUMBER);
 681     double value = HeapNumber::cast(*object)->value();
 682     return value != 0 && !std::isnan(value);
 683   } else {
 684     // We should never see an internal object at runtime here!
 685     UNREACHABLE();
 686     return true;
 687   }
 688 }
 689
 690
 691 bool ToBooleanStub::Types::NeedsMap() const {
 692   return Contains(ToBooleanStub::SPEC_OBJECT)
 693       || Contains(ToBooleanStub::STRING)
 694       || Contains(ToBooleanStub::SYMBOL)
 695       || Contains(ToBooleanStub::FLOAT32x4)
 696       || Contains(ToBooleanStub::INT32x4)
 697       || Contains(ToBooleanStub::HEAP_NUMBER);
 698 }
 699
 700
 701 bool ToBooleanStub::Types::CanBeUndetectable() const {
 702   return Contains(ToBooleanStub::SPEC_OBJECT)
 703       || Contains(ToBooleanStub::STRING);
 704 }
 705
 706
 707 void StubFailureTrampolineStub::GenerateAheadOfTime(Isolate* isolate) {
 708   StubFailureTrampolineStub stub1(NOT_JS_FUNCTION_STUB_MODE);
 709   StubFailureTrampolineStub stub2(JS_FUNCTION_STUB_MODE);
 710   stub1.GetCode(isolate);
 711   stub2.GetCode(isolate);
 712 }
 713
 714
 715 void ProfileEntryHookStub::EntryHookTrampoline(intptr_t function,
 716                                                intptr_t stack_pointer,
 717                                                Isolate* isolate) {
 718   FunctionEntryHook entry_hook = isolate->function_entry_hook();
 719   ASSERT(entry_hook != NULL);
 720   entry_hook(function, stack_pointer);
 721 }
 722
 723
 724 static void InstallDescriptor(Isolate* isolate, HydrogenCodeStub* stub) {
 725   int major_key = stub->MajorKey();
 726   CodeStubInterfaceDescriptor* descriptor =
 727       isolate->code_stub_interface_descriptor(major_key);
 728   if (!descriptor->initialized()) {
 729     stub->InitializeInterfaceDescriptor(isolate, descriptor);
 730   }
 731 }
 732
 733
 734 void ArrayConstructorStubBase::InstallDescriptors(Isolate* isolate) {
 735   ArrayNoArgumentConstructorStub stub1(GetInitialFastElementsKind());
 736   InstallDescriptor(isolate, &stub1);
 737   ArraySingleArgumentConstructorStub stub2(GetInitialFastElementsKind());
 738   InstallDescriptor(isolate, &stub2);
 739   ArrayNArgumentsConstructorStub stub3(GetInitialFastElementsKind());
 740   InstallDescriptor(isolate, &stub3);
 741 }
 742
 743
 744 void NumberToStringStub::InstallDescriptors(Isolate* isolate) {
 745   NumberToStringStub stub;
 746   InstallDescriptor(isolate, &stub);
 747 }
 748
 749
 750 void FastNewClosureStub::InstallDescriptors(Isolate* isolate) {
 751   FastNewClosureStub stub(STRICT, false);
 752   InstallDescriptor(isolate, &stub);
 753 }
 754
 755
 756 void FastNewContextStub::InstallDescriptors(Isolate* isolate) {
 757   FastNewContextStub stub(FastNewContextStub::kMaximumSlots);
 758   InstallDescriptor(isolate, &stub);
 759 }
 760
 761
 762 // static
 763 void FastCloneShallowArrayStub::InstallDescriptors(Isolate* isolate) {
 764   FastCloneShallowArrayStub stub(FastCloneShallowArrayStub::CLONE_ELEMENTS,
 765                                  DONT_TRACK_ALLOCATION_SITE, 0);
 766   InstallDescriptor(isolate, &stub);
 767 }
 768
 769
 770 // static
 771 void BinaryOpICStub::InstallDescriptors(Isolate* isolate) {
 772   BinaryOpICStub stub(Token::ADD, NO_OVERWRITE);
 773   InstallDescriptor(isolate, &stub);
 774 }
 775
 776
 777 // static
 778 void BinaryOpWithAllocationSiteStub::InstallDescriptors(Isolate* isolate) {
 779   BinaryOpWithAllocationSiteStub stub(Token::ADD, NO_OVERWRITE);
 780   InstallDescriptor(isolate, &stub);
 781 }
 782
 783
 784 // static
 785 void StringAddStub::InstallDescriptors(Isolate* isolate) {
 786   StringAddStub stub(STRING_ADD_CHECK_NONE, NOT_TENURED);
 787   InstallDescriptor(isolate, &stub);
 788 }
 789
 790
 791 // static
 792 void RegExpConstructResultStub::InstallDescriptors(Isolate* isolate) {
 793   RegExpConstructResultStub stub;
 794   InstallDescriptor(isolate, &stub);
 795 }
 796
 797
 798 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
 799     : argument_count_(ANY) {
 800   ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 801 }
 802
 803
 804 ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate,
 805                                            int argument_count) {
 806   if (argument_count == 0) {
 807     argument_count_ = NONE;
 808   } else if (argument_count == 1) {
 809     argument_count_ = ONE;
 810   } else if (argument_count >= 2) {
 811     argument_count_ = MORE_THAN_ONE;
 812   } else {
 813     UNREACHABLE();
 814   }
 815   ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 816 }
 817
 818
 819 void InternalArrayConstructorStubBase::InstallDescriptors(Isolate* isolate) {
 820   InternalArrayNoArgumentConstructorStub stub1(FAST_ELEMENTS);
 821   InstallDescriptor(isolate, &stub1);
 822   InternalArraySingleArgumentConstructorStub stub2(FAST_ELEMENTS);
 823   InstallDescriptor(isolate, &stub2);
 824   InternalArrayNArgumentsConstructorStub stub3(FAST_ELEMENTS);
 825   InstallDescriptor(isolate, &stub3);
 826 }
 827
 828 InternalArrayConstructorStub::InternalArrayConstructorStub(
 829     Isolate* isolate) {
 830   InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
 831 }
 832
 833
 834 } }  // namespace v8::internal