AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
75e6803ddc
v8/src/code-stubs.cc
bmeurer@chromium.org 100fb55555 Inline number to string conversion for string addition into BinaryOp(Stub). 
This fixes a performance regression that was caused by converting the
BinaryOpStub to a Hydrogen code stub. It also fixes a leftover TODO wrt.
the handling of Number*String or String*Number versions of the stub.

R=rossberg@chromium.org

Review URL: https://codereview.chromium.org/27674002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@17290 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2013-10-21 12:42:08 +00:00

1173 lines
41 KiB
C++
Raw Blame History

// Copyright 2012 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
// with the distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "v8.h"
#include "bootstrapper.h"
#include "code-stubs.h"
#include "cpu-profiler.h"
#include "stub-cache.h"
#include "factory.h"
#include "gdb-jit.h"
#include "macro-assembler.h"
namespace v8 {
namespace internal {
CodeStubInterfaceDescriptor::CodeStubInterfaceDescriptor()
: register_param_count_(-1),
stack_parameter_count_(no_reg),
hint_stack_parameter_count_(-1),
function_mode_(NOT_JS_FUNCTION_STUB_MODE),
register_params_(NULL),
deoptimization_handler_(NULL),
miss_handler_(),
has_miss_handler_(false) { }
bool CodeStub::FindCodeInCache(Code** code_out, Isolate* isolate) {
UnseededNumberDictionary* stubs = isolate->heap()->code_stubs();
int index = stubs->FindEntry(GetKey());
if (index != UnseededNumberDictionary::kNotFound) {
*code_out = Code::cast(stubs->ValueAt(index));
return true;
}
return false;
}
SmartArrayPointer<const char> CodeStub::GetName() {
char buffer[100];
NoAllocationStringAllocator allocator(buffer,
static_cast<unsigned>(sizeof(buffer)));
StringStream stream(&allocator);
PrintName(&stream);
return stream.ToCString();
}
void CodeStub::RecordCodeGeneration(Code* code, Isolate* isolate) {
SmartArrayPointer<const char> name = GetName();
PROFILE(isolate, CodeCreateEvent(Logger::STUB_TAG, code, *name));
GDBJIT(AddCode(GDBJITInterface::STUB, *name, code));
Counters* counters = isolate->counters();
counters->total_stubs_code_size()->Increment(code->instruction_size());
}
Code::Kind CodeStub::GetCodeKind() const {
return Code::STUB;
}
Handle<Code> CodeStub::GetCodeCopyFromTemplate(Isolate* isolate) {
Handle<Code> ic = GetCode(isolate);
ic = isolate->factory()->CopyCode(ic);
RecordCodeGeneration(*ic, isolate);
return ic;
}
Handle<Code> PlatformCodeStub::GenerateCode(Isolate* isolate) {
Factory* factory = isolate->factory();
// Generate the new code.
MacroAssembler masm(isolate, NULL, 256);
{
// Update the static counter each time a new code stub is generated.
isolate->counters()->code_stubs()->Increment();
// Nested stubs are not allowed for leaves.
AllowStubCallsScope allow_scope(&masm, false);
// Generate the code for the stub.
masm.set_generating_stub(true);
NoCurrentFrameScope scope(&masm);
Generate(&masm);
}
// Create the code object.
CodeDesc desc;
masm.GetCode(&desc);
// Copy the generated code into a heap object.
Code::Flags flags = Code::ComputeFlags(
GetCodeKind(),
GetICState(),
GetExtraICState(),
GetStubType(),
GetStubFlags());
Handle<Code> new_object = factory->NewCode(
desc, flags, masm.CodeObject(), NeedsImmovableCode());
return new_object;
}
void CodeStub::VerifyPlatformFeatures(Isolate* isolate) {
ASSERT(CpuFeatures::VerifyCrossCompiling());
}
Handle<Code> CodeStub::GetCode(Isolate* isolate) {
Factory* factory = isolate->factory();
Heap* heap = isolate->heap();
Code* code;
if (UseSpecialCache()
? FindCodeInSpecialCache(&code, isolate)
: FindCodeInCache(&code, isolate)) {
ASSERT(IsPregenerated(isolate) == code->is_pregenerated());
ASSERT(GetCodeKind() == code->kind());
return Handle<Code>(code);
}
#ifdef DEBUG
VerifyPlatformFeatures(isolate);
#endif
{
HandleScope scope(isolate);
Handle<Code> new_object = GenerateCode(isolate);
new_object->set_major_key(MajorKey());
FinishCode(new_object);
RecordCodeGeneration(*new_object, isolate);
#ifdef ENABLE_DISASSEMBLER
if (FLAG_print_code_stubs) {
new_object->Disassemble(*GetName());
PrintF("\n");
}
#endif
if (UseSpecialCache()) {
AddToSpecialCache(new_object);
} else {
// Update the dictionary and the root in Heap.
Handle<UnseededNumberDictionary> dict =
factory->DictionaryAtNumberPut(
Handle<UnseededNumberDictionary>(heap->code_stubs()),
GetKey(),
new_object);
heap->public_set_code_stubs(*dict);
}
code = *new_object;
}
Activate(code);
ASSERT(!NeedsImmovableCode() ||
heap->lo_space()->Contains(code) ||
heap->code_space()->FirstPage()->Contains(code->address()));
return Handle<Code>(code, isolate);
}
const char* CodeStub::MajorName(CodeStub::Major major_key,
bool allow_unknown_keys) {
switch (major_key) {
#define DEF_CASE(name) case name: return #name "Stub";
CODE_STUB_LIST(DEF_CASE)
#undef DEF_CASE
default:
if (!allow_unknown_keys) {
UNREACHABLE();
}
return NULL;
}
}
void CodeStub::PrintBaseName(StringStream* stream) {
stream->Add("%s", MajorName(MajorKey(), false));
}
void CodeStub::PrintName(StringStream* stream) {
PrintBaseName(stream);
PrintState(stream);
}
void BinaryOpStub::PrintBaseName(StringStream* stream) {
const char* op_name = Token::Name(op_);
const char* ovr = "";
if (mode_ == OVERWRITE_LEFT) ovr = "_ReuseLeft";
if (mode_ == OVERWRITE_RIGHT) ovr = "_ReuseRight";
stream->Add("BinaryOpStub_%s%s", op_name, ovr);
}
void BinaryOpStub::PrintState(StringStream* stream) {
stream->Add("(");
stream->Add(StateToName(left_state_));
stream->Add("*");
if (fixed_right_arg_.has_value) {
stream->Add("%d", fixed_right_arg_.value);
} else {
stream->Add(StateToName(right_state_));
}
stream->Add("->");
stream->Add(StateToName(result_state_));
stream->Add(")");
}
Maybe<Handle<Object> > BinaryOpStub::Result(Handle<Object> left,
Handle<Object> right,
Isolate* isolate) {
Handle<JSBuiltinsObject> builtins(isolate->js_builtins_object());
Builtins::JavaScript func = BinaryOpIC::TokenToJSBuiltin(op_);
Object* builtin = builtins->javascript_builtin(func);
Handle<JSFunction> builtin_function =
Handle<JSFunction>(JSFunction::cast(builtin), isolate);
bool caught_exception;
Handle<Object> result = Execution::Call(isolate, builtin_function, left,
1, &right, &caught_exception);
return Maybe<Handle<Object> >(!caught_exception, result);
}
void BinaryOpStub::Initialize() {
fixed_right_arg_.has_value = false;
left_state_ = right_state_ = result_state_ = NONE;
}
void BinaryOpStub::Generate(Token::Value op,
State left,
State right,
State result,
OverwriteMode mode,
Isolate* isolate) {
BinaryOpStub stub(INITIALIZED);
stub.op_ = op;
stub.left_state_ = left;
stub.right_state_ = right;
stub.result_state_ = result;
stub.mode_ = mode;
stub.GetCode(isolate);
}
void BinaryOpStub::Generate(Token::Value op,
State left,
int right,
State result,
OverwriteMode mode,
Isolate* isolate) {
BinaryOpStub stub(INITIALIZED);
stub.op_ = op;
stub.left_state_ = left;
stub.fixed_right_arg_.has_value = true;
stub.fixed_right_arg_.value = right;
stub.right_state_ = SMI;
stub.result_state_ = result;
stub.mode_ = mode;
stub.GetCode(isolate);
}
void BinaryOpStub::GenerateAheadOfTime(Isolate* isolate) {
Token::Value binop[] = {Token::SUB, Token::MOD, Token::DIV, Token::MUL,
Token::ADD, Token::SAR, Token::BIT_OR, Token::BIT_AND,
Token::BIT_XOR, Token::SHL, Token::SHR};
for (unsigned i = 0; i < ARRAY_SIZE(binop); i++) {
BinaryOpStub stub(UNINITIALIZED);
stub.op_ = binop[i];
stub.GetCode(isolate);
}
// TODO(olivf) We should investigate why adding stubs to the snapshot is so
// expensive at runtime. When solved we should be able to add most binops to
// the snapshot instead of hand-picking them.
// Generated list of commonly used stubs
Generate(Token::ADD, INT32, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::ADD, INT32, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, INT32, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, INT32, INT32, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, INT32, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, INT32, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, INT32, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::ADD, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::ADD, INT32, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::ADD, NUMBER, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, NUMBER, INT32, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, NUMBER, INT32, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::ADD, NUMBER, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, NUMBER, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, NUMBER, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::ADD, NUMBER, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, NUMBER, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, NUMBER, SMI, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::ADD, SMI, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::ADD, SMI, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, SMI, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, SMI, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::ADD, SMI, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, SMI, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::ADD, SMI, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::ADD, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, INT32, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, INT32, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_AND, INT32, INT32, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, INT32, INT32, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, INT32, INT32, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, INT32, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, INT32, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_AND, INT32, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, NUMBER, INT32, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, NUMBER, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, NUMBER, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, SMI, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, SMI, INT32, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, SMI, NUMBER, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_AND, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_AND, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_AND, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, INT32, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, INT32, INT32, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, INT32, INT32, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_OR, INT32, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, INT32, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_OR, INT32, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, NUMBER, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_OR, NUMBER, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, NUMBER, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, NUMBER, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_OR, NUMBER, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, SMI, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, SMI, INT32, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, SMI, INT32, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_OR, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_OR, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_XOR, INT32, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, INT32, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_XOR, INT32, INT32, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_XOR, INT32, INT32, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, INT32, INT32, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_XOR, INT32, NUMBER, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, INT32, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_XOR, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::BIT_XOR, NUMBER, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, NUMBER, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, NUMBER, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, SMI, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, SMI, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_XOR, SMI, INT32, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_XOR, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::BIT_XOR, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::BIT_XOR, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::DIV, INT32, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::DIV, INT32, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, INT32, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, INT32, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::DIV, INT32, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, NUMBER, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, NUMBER, INT32, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, NUMBER, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, NUMBER, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, NUMBER, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::DIV, NUMBER, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, NUMBER, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, SMI, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::DIV, SMI, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, SMI, INT32, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, SMI, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, SMI, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, SMI, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::DIV, SMI, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::DIV, SMI, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, SMI, SMI, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::DIV, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::DIV, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::DIV, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::MOD, NUMBER, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MOD, SMI, 16, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::MOD, SMI, 2, SMI, NO_OVERWRITE, isolate);
Generate(Token::MOD, SMI, 2048, SMI, NO_OVERWRITE, isolate);
Generate(Token::MOD, SMI, 32, SMI, NO_OVERWRITE, isolate);
Generate(Token::MOD, SMI, 4, SMI, NO_OVERWRITE, isolate);
Generate(Token::MOD, SMI, 4, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::MOD, SMI, 8, SMI, NO_OVERWRITE, isolate);
Generate(Token::MOD, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::MOD, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, INT32, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::MUL, INT32, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, INT32, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, INT32, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::MUL, INT32, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, INT32, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, NUMBER, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, NUMBER, INT32, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, NUMBER, INT32, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::MUL, NUMBER, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, NUMBER, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, NUMBER, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, NUMBER, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, NUMBER, SMI, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::MUL, SMI, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::MUL, SMI, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, SMI, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, SMI, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, SMI, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, SMI, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::MUL, SMI, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::MUL, SMI, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::MUL, SMI, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::MUL, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::MUL, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SAR, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::SAR, INT32, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SAR, INT32, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SAR, NUMBER, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SAR, NUMBER, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SAR, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::SAR, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SHL, INT32, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::SHL, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::SHL, INT32, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SHL, INT32, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SHL, NUMBER, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SHL, SMI, SMI, INT32, NO_OVERWRITE, isolate);
Generate(Token::SHL, SMI, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::SHL, SMI, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::SHL, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SHL, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::SHL, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SHR, INT32, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SHR, INT32, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::SHR, INT32, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SHR, NUMBER, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SHR, NUMBER, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::SHR, NUMBER, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::SHR, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SHR, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::SHR, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
Generate(Token::SUB, INT32, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::SUB, INT32, INT32, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, INT32, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::SUB, INT32, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::SUB, INT32, SMI, INT32, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, INT32, SMI, INT32, OVERWRITE_RIGHT, isolate);
Generate(Token::SUB, NUMBER, INT32, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::SUB, NUMBER, INT32, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, NUMBER, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::SUB, NUMBER, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, NUMBER, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::SUB, NUMBER, SMI, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::SUB, NUMBER, SMI, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, NUMBER, SMI, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::SUB, SMI, INT32, INT32, NO_OVERWRITE, isolate);
Generate(Token::SUB, SMI, NUMBER, NUMBER, NO_OVERWRITE, isolate);
Generate(Token::SUB, SMI, NUMBER, NUMBER, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, SMI, NUMBER, NUMBER, OVERWRITE_RIGHT, isolate);
Generate(Token::SUB, SMI, SMI, SMI, NO_OVERWRITE, isolate);
Generate(Token::SUB, SMI, SMI, SMI, OVERWRITE_LEFT, isolate);
Generate(Token::SUB, SMI, SMI, SMI, OVERWRITE_RIGHT, isolate);
}
bool BinaryOpStub::can_encode_arg_value(int32_t value) const {
return op_ == Token::MOD && value > 0 && IsPowerOf2(value) &&
FixedRightArgValueBits::is_valid(WhichPowerOf2(value));
}
int BinaryOpStub::encode_arg_value(int32_t value) const {
ASSERT(can_encode_arg_value(value));
return WhichPowerOf2(value);
}
int32_t BinaryOpStub::decode_arg_value(int value) const {
return 1 << value;
}
int BinaryOpStub::encode_token(Token::Value op) const {
ASSERT(op >= FIRST_TOKEN && op <= LAST_TOKEN);
return op - FIRST_TOKEN;
}
Token::Value BinaryOpStub::decode_token(int op) const {
int res = op + FIRST_TOKEN;
ASSERT(res >= FIRST_TOKEN && res <= LAST_TOKEN);
return static_cast<Token::Value>(res);
}
const char* BinaryOpStub::StateToName(State state) {
switch (state) {
case NONE:
return "None";
case SMI:
return "Smi";
case INT32:
return "Int32";
case NUMBER:
return "Number";
case STRING:
return "String";
case GENERIC:
return "Generic";
}
return "";
}
void BinaryOpStub::UpdateStatus(Handle<Object> left,
Handle<Object> right,
Maybe<Handle<Object> > result) {
int old_state = GetExtraICState();
UpdateStatus(left, &left_state_);
UpdateStatus(right, &right_state_);
int32_t value;
bool new_has_fixed_right_arg =
right->ToInt32(&value) && can_encode_arg_value(value) &&
(left_state_ == SMI || left_state_ == INT32) &&
(result_state_ == NONE || !fixed_right_arg_.has_value);
fixed_right_arg_ = Maybe<int32_t>(new_has_fixed_right_arg, value);
if (result.has_value) UpdateStatus(result.value, &result_state_);
State max_input = Max(left_state_, right_state_);
if (!has_int_result() && op_ != Token::SHR &&
max_input <= NUMBER && max_input > result_state_) {
result_state_ = max_input;
}
ASSERT(result_state_ <= (has_int_result() ? INT32 : NUMBER) ||
op_ == Token::ADD);
if (old_state == GetExtraICState()) {
// Tagged operations can lead to non-truncating HChanges
if (left->IsUndefined() || left->IsBoolean()) {
left_state_ = GENERIC;
} else if (right->IsUndefined() || right->IsBoolean()) {
right_state_ = GENERIC;
} else {
// Since the fpu is to precise, we might bail out on numbers which
// actually would truncate with 64 bit precision.
ASSERT(!CpuFeatures::IsSupported(SSE2) &&
result_state_ <= INT32);
result_state_ = NUMBER;
}
}
}
void BinaryOpStub::UpdateStatus(Handle<Object> object,
State* state) {
bool is_truncating = (op_ == Token::BIT_AND || op_ == Token::BIT_OR ||
op_ == Token::BIT_XOR || op_ == Token::SAR ||
op_ == Token::SHL || op_ == Token::SHR);
v8::internal::TypeInfo type = v8::internal::TypeInfo::FromValue(object);
if (object->IsBoolean() && is_truncating) {
// Booleans are converted by truncating by HChange.
type = TypeInfo::Integer32();
}
if (object->IsUndefined()) {
// Undefined will be automatically truncated for us by HChange.
type = is_truncating ? TypeInfo::Integer32() : TypeInfo::Double();
}
State int_state = SmiValuesAre32Bits() ? NUMBER : INT32;
State new_state = NONE;
if (type.IsSmi()) {
new_state = SMI;
} else if (type.IsInteger32()) {
new_state = int_state;
} else if (type.IsNumber()) {
new_state = NUMBER;
} else if (object->IsString() && operation() == Token::ADD) {
new_state = STRING;
} else {
new_state = GENERIC;
}
if ((new_state <= NUMBER && *state > NUMBER) ||
(new_state > NUMBER && *state <= NUMBER && *state != NONE)) {
new_state = GENERIC;
}
*state = Max(*state, new_state);
}
Handle<Type> BinaryOpStub::StateToType(State state,
Isolate* isolate) {
Handle<Type> t = handle(Type::None(), isolate);
switch (state) {
case NUMBER:
t = handle(Type::Union(t, handle(Type::Double(), isolate)), isolate);
// Fall through.
case INT32:
t = handle(Type::Union(t, handle(Type::Signed32(), isolate)), isolate);
// Fall through.
case SMI:
t = handle(Type::Union(t, handle(Type::Smi(), isolate)), isolate);
break;
case STRING:
t = handle(Type::Union(t, handle(Type::String(), isolate)), isolate);
break;
case GENERIC:
return handle(Type::Any(), isolate);
break;
case NONE:
break;
}
return t;
}
Handle<Type> BinaryOpStub::GetLeftType(Isolate* isolate) const {
return StateToType(left_state_, isolate);
}
Handle<Type> BinaryOpStub::GetRightType(Isolate* isolate) const {
return StateToType(right_state_, isolate);
}
Handle<Type> BinaryOpStub::GetResultType(Isolate* isolate) const {
if (HasSideEffects(isolate)) return StateToType(NONE, isolate);
if (result_state_ == GENERIC && op_ == Token::ADD) {
return handle(Type::Union(handle(Type::Number(), isolate),
handle(Type::String(), isolate)), isolate);
}
ASSERT(result_state_ != GENERIC);
if (result_state_ == NUMBER && op_ == Token::SHR) {
return handle(Type::Unsigned32(), isolate);
}
return StateToType(result_state_, isolate);
}
InlineCacheState ICCompareStub::GetICState() {
CompareIC::State state = Max(left_, right_);
switch (state) {
case CompareIC::UNINITIALIZED:
return ::v8::internal::UNINITIALIZED;
case CompareIC::SMI:
case CompareIC::NUMBER:
case CompareIC::INTERNALIZED_STRING:
case CompareIC::STRING:
case CompareIC::UNIQUE_NAME:
case CompareIC::OBJECT:
case CompareIC::KNOWN_OBJECT:
return MONOMORPHIC;
case CompareIC::GENERIC:
return ::v8::internal::GENERIC;
}
UNREACHABLE();
return ::v8::internal::UNINITIALIZED;
}
void ICCompareStub::AddToSpecialCache(Handle<Code> new_object) {
ASSERT(*known_map_ != NULL);
Isolate* isolate = new_object->GetIsolate();
Factory* factory = isolate->factory();
return Map::UpdateCodeCache(known_map_,
strict() ?
factory->strict_compare_ic_string() :
factory->compare_ic_string(),
new_object);
}
bool ICCompareStub::FindCodeInSpecialCache(Code** code_out, Isolate* isolate) {
Factory* factory = isolate->factory();
Code::Flags flags = Code::ComputeFlags(
GetCodeKind(),
UNINITIALIZED);
ASSERT(op_ == Token::EQ || op_ == Token::EQ_STRICT);
Handle<Object> probe(
known_map_->FindInCodeCache(
strict() ?
*factory->strict_compare_ic_string() :
*factory->compare_ic_string(),
flags),
isolate);
if (probe->IsCode()) {
*code_out = Code::cast(*probe);
#ifdef DEBUG
Token::Value cached_op;
ICCompareStub::DecodeMinorKey((*code_out)->stub_info(), NULL, NULL, NULL,
&cached_op);
ASSERT(op_ == cached_op);
#endif
return true;
}
return false;
}
int ICCompareStub::MinorKey() {
return OpField::encode(op_ - Token::EQ) |
LeftStateField::encode(left_) |
RightStateField::encode(right_) |
HandlerStateField::encode(state_);
}
void ICCompareStub::DecodeMinorKey(int minor_key,
CompareIC::State* left_state,
CompareIC::State* right_state,
CompareIC::State* handler_state,
Token::Value* op) {
if (left_state) {
*left_state =
static_cast<CompareIC::State>(LeftStateField::decode(minor_key));
}
if (right_state) {
*right_state =
static_cast<CompareIC::State>(RightStateField::decode(minor_key));
}
if (handler_state) {
*handler_state =
static_cast<CompareIC::State>(HandlerStateField::decode(minor_key));
}
if (op) {
*op = static_cast<Token::Value>(OpField::decode(minor_key) + Token::EQ);
}
}
void ICCompareStub::Generate(MacroAssembler* masm) {
switch (state_) {
case CompareIC::UNINITIALIZED:
GenerateMiss(masm);
break;
case CompareIC::SMI:
GenerateSmis(masm);
break;
case CompareIC::NUMBER:
GenerateNumbers(masm);
break;
case CompareIC::STRING:
GenerateStrings(masm);
break;
case CompareIC::INTERNALIZED_STRING:
GenerateInternalizedStrings(masm);
break;
case CompareIC::UNIQUE_NAME:
GenerateUniqueNames(masm);
break;
case CompareIC::OBJECT:
GenerateObjects(masm);
break;
case CompareIC::KNOWN_OBJECT:
ASSERT(*known_map_ != NULL);
GenerateKnownObjects(masm);
break;
case CompareIC::GENERIC:
GenerateGeneric(masm);
break;
}
}
void CompareNilICStub::UpdateStatus(Handle<Object> object) {
ASSERT(!state_.Contains(GENERIC));
State old_state(state_);
if (object->IsNull()) {
state_.Add(NULL_TYPE);
} else if (object->IsUndefined()) {
state_.Add(UNDEFINED);
} else if (object->IsUndetectableObject() ||
object->IsOddball() ||
!object->IsHeapObject()) {
state_.RemoveAll();
state_.Add(GENERIC);
} else if (IsMonomorphic()) {
state_.RemoveAll();
state_.Add(GENERIC);
} else {
state_.Add(MONOMORPHIC_MAP);
}
TraceTransition(old_state, state_);
}
template<class StateType>
void HydrogenCodeStub::TraceTransition(StateType from, StateType to) {
// Note: Although a no-op transition is semantically OK, it is hinting at a
// bug somewhere in our state transition machinery.
ASSERT(from != to);
#ifdef DEBUG
if (!FLAG_trace_ic) return;
char buffer[100];
NoAllocationStringAllocator allocator(buffer,
static_cast<unsigned>(sizeof(buffer)));
StringStream stream(&allocator);
stream.Add("[");
PrintBaseName(&stream);
stream.Add(": ");
from.Print(&stream);
stream.Add("=>");
to.Print(&stream);
stream.Add("]\n");
stream.OutputToStdOut();
#endif
}
void CompareNilICStub::PrintBaseName(StringStream* stream) {
CodeStub::PrintBaseName(stream);
stream->Add((nil_value_ == kNullValue) ? "(NullValue)":
"(UndefinedValue)");
}
void CompareNilICStub::PrintState(StringStream* stream) {
state_.Print(stream);
}
void CompareNilICStub::State::Print(StringStream* stream) const {
stream->Add("(");
SimpleListPrinter printer(stream);
if (IsEmpty()) printer.Add("None");
if (Contains(UNDEFINED)) printer.Add("Undefined");
if (Contains(NULL_TYPE)) printer.Add("Null");
if (Contains(MONOMORPHIC_MAP)) printer.Add("MonomorphicMap");
if (Contains(GENERIC)) printer.Add("Generic");
stream->Add(")");
}
Handle<Type> CompareNilICStub::GetType(
Isolate* isolate,
Handle<Map> map) {
if (state_.Contains(CompareNilICStub::GENERIC)) {
return handle(Type::Any(), isolate);
}
Handle<Type> result(Type::None(), isolate);
if (state_.Contains(CompareNilICStub::UNDEFINED)) {
result = handle(Type::Union(result, handle(Type::Undefined(), isolate)),
isolate);
}
if (state_.Contains(CompareNilICStub::NULL_TYPE)) {
result = handle(Type::Union(result, handle(Type::Null(), isolate)),
isolate);
}
if (state_.Contains(CompareNilICStub::MONOMORPHIC_MAP)) {
Type* type = map.is_null() ? Type::Detectable() : Type::Class(map);
result = handle(Type::Union(result, handle(type, isolate)), isolate);
}
return result;
}
Handle<Type> CompareNilICStub::GetInputType(
Isolate* isolate,
Handle<Map> map) {
Handle<Type> output_type = GetType(isolate, map);
Handle<Type> nil_type = handle(nil_value_ == kNullValue
? Type::Null() : Type::Undefined(), isolate);
return handle(Type::Union(output_type, nil_type), isolate);
}
void InstanceofStub::PrintName(StringStream* stream) {
const char* args = "";
if (HasArgsInRegisters()) {
args = "_REGS";
}
const char* inline_check = "";
if (HasCallSiteInlineCheck()) {
inline_check = "_INLINE";
}
const char* return_true_false_object = "";
if (ReturnTrueFalseObject()) {
return_true_false_object = "_TRUEFALSE";
}
stream->Add("InstanceofStub%s%s%s",
args,
inline_check,
return_true_false_object);
}
void JSEntryStub::FinishCode(Handle<Code> code) {
Handle<FixedArray> handler_table =
code->GetIsolate()->factory()->NewFixedArray(1, TENURED);
handler_table->set(0, Smi::FromInt(handler_offset_));
code->set_handler_table(*handler_table);
}
void KeyedLoadDictionaryElementStub::Generate(MacroAssembler* masm) {
KeyedLoadStubCompiler::GenerateLoadDictionaryElement(masm);
}
void CreateAllocationSiteStub::GenerateAheadOfTime(Isolate* isolate) {
CreateAllocationSiteStub stub;
stub.GetCode(isolate)->set_is_pregenerated(true);
}
void KeyedStoreElementStub::Generate(MacroAssembler* masm) {
switch (elements_kind_) {
case FAST_ELEMENTS:
case FAST_HOLEY_ELEMENTS:
case FAST_SMI_ELEMENTS:
case FAST_HOLEY_SMI_ELEMENTS:
case FAST_DOUBLE_ELEMENTS:
case FAST_HOLEY_DOUBLE_ELEMENTS:
case EXTERNAL_BYTE_ELEMENTS:
case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
case EXTERNAL_SHORT_ELEMENTS:
case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
case EXTERNAL_INT_ELEMENTS:
case EXTERNAL_UNSIGNED_INT_ELEMENTS:
case EXTERNAL_FLOAT_ELEMENTS:
case EXTERNAL_DOUBLE_ELEMENTS:
case EXTERNAL_PIXEL_ELEMENTS:
UNREACHABLE();
break;
case DICTIONARY_ELEMENTS:
KeyedStoreStubCompiler::GenerateStoreDictionaryElement(masm);
break;
case NON_STRICT_ARGUMENTS_ELEMENTS:
UNREACHABLE();
break;
}
}
void ArgumentsAccessStub::PrintName(StringStream* stream) {
stream->Add("ArgumentsAccessStub_");
switch (type_) {
case READ_ELEMENT: stream->Add("ReadElement"); break;
case NEW_NON_STRICT_FAST: stream->Add("NewNonStrictFast"); break;
case NEW_NON_STRICT_SLOW: stream->Add("NewNonStrictSlow"); break;
case NEW_STRICT: stream->Add("NewStrict"); break;
}
}
void CallFunctionStub::PrintName(StringStream* stream) {
stream->Add("CallFunctionStub_Args%d", argc_);
if (ReceiverMightBeImplicit()) stream->Add("_Implicit");
if (RecordCallTarget()) stream->Add("_Recording");
}
void CallConstructStub::PrintName(StringStream* stream) {
stream->Add("CallConstructStub");
if (RecordCallTarget()) stream->Add("_Recording");
}
bool ToBooleanStub::UpdateStatus(Handle<Object> object) {
Types old_types(types_);
bool to_boolean_value = types_.UpdateStatus(object);
TraceTransition(old_types, types_);
return to_boolean_value;
}
void ToBooleanStub::PrintState(StringStream* stream) {
types_.Print(stream);
}
void ToBooleanStub::Types::Print(StringStream* stream) const {
stream->Add("(");
SimpleListPrinter printer(stream);
if (IsEmpty()) printer.Add("None");
if (Contains(UNDEFINED)) printer.Add("Undefined");
if (Contains(BOOLEAN)) printer.Add("Bool");
if (Contains(NULL_TYPE)) printer.Add("Null");
if (Contains(SMI)) printer.Add("Smi");
if (Contains(SPEC_OBJECT)) printer.Add("SpecObject");
if (Contains(STRING)) printer.Add("String");
if (Contains(SYMBOL)) printer.Add("Symbol");
if (Contains(HEAP_NUMBER)) printer.Add("HeapNumber");
stream->Add(")");
}
bool ToBooleanStub::Types::UpdateStatus(Handle<Object> object) {
if (object->IsUndefined()) {
Add(UNDEFINED);
return false;
} else if (object->IsBoolean()) {
Add(BOOLEAN);
return object->IsTrue();
} else if (object->IsNull()) {
Add(NULL_TYPE);
return false;
} else if (object->IsSmi()) {
Add(SMI);
return Smi::cast(*object)->value() != 0;
} else if (object->IsSpecObject()) {
Add(SPEC_OBJECT);
return !object->IsUndetectableObject();
} else if (object->IsString()) {
Add(STRING);
return !object->IsUndetectableObject() &&
String::cast(*object)->length() != 0;
} else if (object->IsSymbol()) {
Add(SYMBOL);
return true;
} else if (object->IsHeapNumber()) {
ASSERT(!object->IsUndetectableObject());
Add(HEAP_NUMBER);
double value = HeapNumber::cast(*object)->value();
return value != 0 && !std::isnan(value);
} else {
// We should never see an internal object at runtime here!
UNREACHABLE();
return true;
}
}
bool ToBooleanStub::Types::NeedsMap() const {
return Contains(ToBooleanStub::SPEC_OBJECT)
|| Contains(ToBooleanStub::STRING)
|| Contains(ToBooleanStub::SYMBOL)
|| Contains(ToBooleanStub::HEAP_NUMBER);
}
bool ToBooleanStub::Types::CanBeUndetectable() const {
return Contains(ToBooleanStub::SPEC_OBJECT)
|| Contains(ToBooleanStub::STRING);
}
void StubFailureTrampolineStub::GenerateAheadOfTime(Isolate* isolate) {
StubFailureTrampolineStub stub1(NOT_JS_FUNCTION_STUB_MODE);
StubFailureTrampolineStub stub2(JS_FUNCTION_STUB_MODE);
stub1.GetCode(isolate)->set_is_pregenerated(true);
stub2.GetCode(isolate)->set_is_pregenerated(true);
}
void ProfileEntryHookStub::EntryHookTrampoline(intptr_t function,
intptr_t stack_pointer,
Isolate* isolate) {
FunctionEntryHook entry_hook = isolate->function_entry_hook();
ASSERT(entry_hook != NULL);
entry_hook(function, stack_pointer);
}
static void InstallDescriptor(Isolate* isolate, HydrogenCodeStub* stub) {
int major_key = stub->MajorKey();
CodeStubInterfaceDescriptor* descriptor =
isolate->code_stub_interface_descriptor(major_key);
if (!descriptor->initialized()) {
stub->InitializeInterfaceDescriptor(isolate, descriptor);
}
}
void ArrayConstructorStubBase::InstallDescriptors(Isolate* isolate) {
ArrayNoArgumentConstructorStub stub1(GetInitialFastElementsKind());
InstallDescriptor(isolate, &stub1);
ArraySingleArgumentConstructorStub stub2(GetInitialFastElementsKind());
InstallDescriptor(isolate, &stub2);
ArrayNArgumentsConstructorStub stub3(GetInitialFastElementsKind());
InstallDescriptor(isolate, &stub3);
}
void NumberToStringStub::InstallDescriptors(Isolate* isolate) {
NumberToStringStub stub;
InstallDescriptor(isolate, &stub);
}
void FastNewClosureStub::InstallDescriptors(Isolate* isolate) {
FastNewClosureStub stub(STRICT_MODE, false);
InstallDescriptor(isolate, &stub);
}
ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate)
: argument_count_(ANY) {
ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
}
ArrayConstructorStub::ArrayConstructorStub(Isolate* isolate,
int argument_count) {
if (argument_count == 0) {
argument_count_ = NONE;
} else if (argument_count == 1) {
argument_count_ = ONE;
} else if (argument_count >= 2) {
argument_count_ = MORE_THAN_ONE;
} else {
UNREACHABLE();
}
ArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
}
void InternalArrayConstructorStubBase::InstallDescriptors(Isolate* isolate) {
InternalArrayNoArgumentConstructorStub stub1(FAST_ELEMENTS);
InstallDescriptor(isolate, &stub1);
InternalArraySingleArgumentConstructorStub stub2(FAST_ELEMENTS);
InstallDescriptor(isolate, &stub2);
InternalArrayNArgumentsConstructorStub stub3(FAST_ELEMENTS);
InstallDescriptor(isolate, &stub3);
}
InternalArrayConstructorStub::InternalArrayConstructorStub(
Isolate* isolate) {
InternalArrayConstructorStubBase::GenerateStubsAheadOfTime(isolate);
}
} } // namespace v8::internal
Reference in New Issue View Git Blame Copy Permalink