2011-04-07 09:51:25 +00:00
|
|
|
// Copyright 2011 the V8 project authors. All rights reserved.
|
2010-03-24 15:29:41 +00:00
|
|
|
// 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.
|
|
|
|
|
2010-03-26 11:34:00 +00:00
|
|
|
#include "v8.h"
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
#include "ast.h"
|
|
|
|
#include "compiler.h"
|
|
|
|
#include "ic.h"
|
|
|
|
#include "macro-assembler.h"
|
|
|
|
#include "stub-cache.h"
|
2010-03-25 12:44:15 +00:00
|
|
|
#include "type-info.h"
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
#include "ic-inl.h"
|
2010-03-24 15:29:41 +00:00
|
|
|
#include "objects-inl.h"
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
|
|
|
|
|
2010-03-25 12:44:15 +00:00
|
|
|
TypeInfo TypeInfo::TypeFromValue(Handle<Object> value) {
|
|
|
|
TypeInfo info;
|
2010-03-24 15:29:41 +00:00
|
|
|
if (value->IsSmi()) {
|
2010-03-25 12:44:15 +00:00
|
|
|
info = TypeInfo::Smi();
|
2010-03-24 15:29:41 +00:00
|
|
|
} else if (value->IsHeapNumber()) {
|
2010-03-25 12:44:15 +00:00
|
|
|
info = TypeInfo::IsInt32Double(HeapNumber::cast(*value)->value())
|
|
|
|
? TypeInfo::Integer32()
|
|
|
|
: TypeInfo::Double();
|
2010-03-29 11:48:57 +00:00
|
|
|
} else if (value->IsString()) {
|
|
|
|
info = TypeInfo::String();
|
2010-03-24 15:29:41 +00:00
|
|
|
} else {
|
2010-03-25 12:44:15 +00:00
|
|
|
info = TypeInfo::Unknown();
|
2010-03-24 15:29:41 +00:00
|
|
|
}
|
|
|
|
return info;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-18 16:54:48 +00:00
|
|
|
STATIC_ASSERT(DEFAULT_STRING_STUB == Code::kNoExtraICState);
|
|
|
|
|
|
|
|
|
2011-01-13 14:16:08 +00:00
|
|
|
TypeFeedbackOracle::TypeFeedbackOracle(Handle<Code> code,
|
|
|
|
Handle<Context> global_context) {
|
|
|
|
global_context_ = global_context;
|
2011-03-07 16:09:56 +00:00
|
|
|
PopulateMap(code);
|
|
|
|
ASSERT(reinterpret_cast<Address>(*dictionary_.location()) != kHandleZapValue);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> TypeFeedbackOracle::GetInfo(unsigned ast_id) {
|
|
|
|
int entry = dictionary_->FindEntry(ast_id);
|
2011-03-07 16:09:56 +00:00
|
|
|
return entry != NumberDictionary::kNotFound
|
|
|
|
? Handle<Object>(dictionary_->ValueAt(entry))
|
2011-03-18 20:35:07 +00:00
|
|
|
: Isolate::Current()->factory()->undefined_value();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool TypeFeedbackOracle::LoadIsMonomorphic(Property* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> map_or_code(GetInfo(expr->id()));
|
2011-03-09 15:01:16 +00:00
|
|
|
if (map_or_code->IsMap()) return true;
|
|
|
|
if (map_or_code->IsCode()) {
|
|
|
|
Handle<Code> code(Code::cast(*map_or_code));
|
|
|
|
return code->kind() == Code::KEYED_EXTERNAL_ARRAY_LOAD_IC &&
|
|
|
|
code->FindFirstMap() != NULL;
|
|
|
|
}
|
|
|
|
return false;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-07 09:51:25 +00:00
|
|
|
bool TypeFeedbackOracle::StoreIsMonomorphic(Expression* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> map_or_code(GetInfo(expr->id()));
|
2011-03-09 15:01:16 +00:00
|
|
|
if (map_or_code->IsMap()) return true;
|
|
|
|
if (map_or_code->IsCode()) {
|
|
|
|
Handle<Code> code(Code::cast(*map_or_code));
|
|
|
|
return code->kind() == Code::KEYED_EXTERNAL_ARRAY_STORE_IC &&
|
|
|
|
code->FindFirstMap() != NULL;
|
|
|
|
}
|
|
|
|
return false;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool TypeFeedbackOracle::CallIsMonomorphic(Call* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> value = GetInfo(expr->id());
|
2011-01-13 14:16:08 +00:00
|
|
|
return value->IsMap() || value->IsSmi();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
Handle<Map> TypeFeedbackOracle::LoadMonomorphicReceiverType(Property* expr) {
|
|
|
|
ASSERT(LoadIsMonomorphic(expr));
|
2011-03-09 15:01:16 +00:00
|
|
|
Handle<Object> map_or_code(
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<HeapObject>::cast(GetInfo(expr->id())));
|
2011-03-09 15:01:16 +00:00
|
|
|
if (map_or_code->IsCode()) {
|
|
|
|
Handle<Code> code(Code::cast(*map_or_code));
|
|
|
|
return Handle<Map>(code->FindFirstMap());
|
|
|
|
}
|
|
|
|
return Handle<Map>(Map::cast(*map_or_code));
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-07 09:51:25 +00:00
|
|
|
Handle<Map> TypeFeedbackOracle::StoreMonomorphicReceiverType(Expression* expr) {
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(StoreIsMonomorphic(expr));
|
2011-03-09 15:01:16 +00:00
|
|
|
Handle<HeapObject> map_or_code(
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<HeapObject>::cast(GetInfo(expr->id())));
|
2011-03-09 15:01:16 +00:00
|
|
|
if (map_or_code->IsCode()) {
|
|
|
|
Handle<Code> code(Code::cast(*map_or_code));
|
|
|
|
return Handle<Map>(code->FindFirstMap());
|
|
|
|
}
|
|
|
|
return Handle<Map>(Map::cast(*map_or_code));
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ZoneMapList* TypeFeedbackOracle::LoadReceiverTypes(Property* expr,
|
|
|
|
Handle<String> name) {
|
|
|
|
Code::Flags flags = Code::ComputeMonomorphicFlags(Code::LOAD_IC, NORMAL);
|
2011-04-27 15:02:59 +00:00
|
|
|
return CollectReceiverTypes(expr->id(), name, flags);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ZoneMapList* TypeFeedbackOracle::StoreReceiverTypes(Assignment* expr,
|
|
|
|
Handle<String> name) {
|
|
|
|
Code::Flags flags = Code::ComputeMonomorphicFlags(Code::STORE_IC, NORMAL);
|
2011-04-27 15:02:59 +00:00
|
|
|
return CollectReceiverTypes(expr->id(), name, flags);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
ZoneMapList* TypeFeedbackOracle::CallReceiverTypes(Call* expr,
|
|
|
|
Handle<String> name) {
|
|
|
|
int arity = expr->arguments()->length();
|
2011-01-18 16:54:48 +00:00
|
|
|
// Note: these flags won't let us get maps from stubs with
|
|
|
|
// non-default extra ic state in the megamorphic case. In the more
|
|
|
|
// important monomorphic case the map is obtained directly, so it's
|
|
|
|
// not a problem until we decide to emit more polymorphic code.
|
|
|
|
Code::Flags flags = Code::ComputeMonomorphicFlags(Code::CALL_IC,
|
|
|
|
NORMAL,
|
|
|
|
Code::kNoExtraICState,
|
|
|
|
OWN_MAP,
|
|
|
|
NOT_IN_LOOP,
|
|
|
|
arity);
|
2011-04-27 15:02:59 +00:00
|
|
|
return CollectReceiverTypes(expr->id(), name, flags);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-13 14:16:08 +00:00
|
|
|
CheckType TypeFeedbackOracle::GetCallCheckType(Call* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> value = GetInfo(expr->id());
|
2011-01-13 14:16:08 +00:00
|
|
|
if (!value->IsSmi()) return RECEIVER_MAP_CHECK;
|
|
|
|
CheckType check = static_cast<CheckType>(Smi::cast(*value)->value());
|
|
|
|
ASSERT(check != RECEIVER_MAP_CHECK);
|
|
|
|
return check;
|
|
|
|
}
|
|
|
|
|
2011-03-09 15:01:16 +00:00
|
|
|
ExternalArrayType TypeFeedbackOracle::GetKeyedLoadExternalArrayType(
|
|
|
|
Property* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> stub = GetInfo(expr->id());
|
2011-03-09 15:01:16 +00:00
|
|
|
ASSERT(stub->IsCode());
|
|
|
|
return Code::cast(*stub)->external_array_type();
|
|
|
|
}
|
|
|
|
|
|
|
|
ExternalArrayType TypeFeedbackOracle::GetKeyedStoreExternalArrayType(
|
2011-04-07 09:51:25 +00:00
|
|
|
Expression* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> stub = GetInfo(expr->id());
|
2011-03-09 15:01:16 +00:00
|
|
|
ASSERT(stub->IsCode());
|
|
|
|
return Code::cast(*stub)->external_array_type();
|
|
|
|
}
|
2011-01-13 14:16:08 +00:00
|
|
|
|
|
|
|
Handle<JSObject> TypeFeedbackOracle::GetPrototypeForPrimitiveCheck(
|
|
|
|
CheckType check) {
|
|
|
|
JSFunction* function = NULL;
|
|
|
|
switch (check) {
|
|
|
|
case RECEIVER_MAP_CHECK:
|
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
|
|
|
case STRING_CHECK:
|
|
|
|
function = global_context_->string_function();
|
|
|
|
break;
|
|
|
|
case NUMBER_CHECK:
|
|
|
|
function = global_context_->number_function();
|
|
|
|
break;
|
|
|
|
case BOOLEAN_CHECK:
|
|
|
|
function = global_context_->boolean_function();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ASSERT(function != NULL);
|
|
|
|
return Handle<JSObject>(JSObject::cast(function->instance_prototype()));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
bool TypeFeedbackOracle::LoadIsBuiltin(Property* expr, Builtins::Name id) {
|
2011-04-27 15:02:59 +00:00
|
|
|
return *GetInfo(expr->id()) ==
|
2011-03-18 20:35:07 +00:00
|
|
|
Isolate::Current()->builtins()->builtin(id);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-27 14:04:07 +00:00
|
|
|
TypeInfo TypeFeedbackOracle::CompareType(CompareOperation* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> object = GetInfo(expr->id());
|
2010-12-07 11:31:57 +00:00
|
|
|
TypeInfo unknown = TypeInfo::Unknown();
|
|
|
|
if (!object->IsCode()) return unknown;
|
|
|
|
Handle<Code> code = Handle<Code>::cast(object);
|
|
|
|
if (!code->is_compare_ic_stub()) return unknown;
|
|
|
|
|
|
|
|
CompareIC::State state = static_cast<CompareIC::State>(code->compare_state());
|
|
|
|
switch (state) {
|
|
|
|
case CompareIC::UNINITIALIZED:
|
2010-12-15 13:56:41 +00:00
|
|
|
// Uninitialized means never executed.
|
|
|
|
// TODO(fschneider): Introduce a separate value for never-executed ICs.
|
|
|
|
return unknown;
|
2010-12-07 11:31:57 +00:00
|
|
|
case CompareIC::SMIS:
|
|
|
|
return TypeInfo::Smi();
|
|
|
|
case CompareIC::HEAP_NUMBERS:
|
|
|
|
return TypeInfo::Number();
|
|
|
|
case CompareIC::OBJECTS:
|
|
|
|
// TODO(kasperl): We really need a type for JS objects here.
|
|
|
|
return TypeInfo::NonPrimitive();
|
|
|
|
case CompareIC::GENERIC:
|
|
|
|
default:
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-28 17:49:55 +00:00
|
|
|
TypeInfo TypeFeedbackOracle::UnaryType(UnaryOperation* expr) {
|
2011-05-09 14:58:06 +00:00
|
|
|
Handle<Object> object = GetInfo(expr->id());
|
2011-04-28 17:49:55 +00:00
|
|
|
TypeInfo unknown = TypeInfo::Unknown();
|
|
|
|
if (!object->IsCode()) return unknown;
|
|
|
|
Handle<Code> code = Handle<Code>::cast(object);
|
|
|
|
ASSERT(code->is_type_recording_unary_op_stub());
|
|
|
|
TRUnaryOpIC::TypeInfo type = static_cast<TRUnaryOpIC::TypeInfo>(
|
|
|
|
code->type_recording_unary_op_type());
|
|
|
|
switch (type) {
|
|
|
|
case TRUnaryOpIC::SMI:
|
|
|
|
return TypeInfo::Smi();
|
|
|
|
case TRUnaryOpIC::HEAP_NUMBER:
|
|
|
|
return TypeInfo::Double();
|
|
|
|
default:
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-27 14:04:07 +00:00
|
|
|
TypeInfo TypeFeedbackOracle::BinaryType(BinaryOperation* expr) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> object = GetInfo(expr->id());
|
2010-12-07 11:31:57 +00:00
|
|
|
TypeInfo unknown = TypeInfo::Unknown();
|
|
|
|
if (!object->IsCode()) return unknown;
|
|
|
|
Handle<Code> code = Handle<Code>::cast(object);
|
2011-04-11 09:39:21 +00:00
|
|
|
if (code->is_type_recording_binary_op_stub()) {
|
2010-12-07 11:31:57 +00:00
|
|
|
TRBinaryOpIC::TypeInfo type = static_cast<TRBinaryOpIC::TypeInfo>(
|
|
|
|
code->type_recording_binary_op_type());
|
|
|
|
TRBinaryOpIC::TypeInfo result_type = static_cast<TRBinaryOpIC::TypeInfo>(
|
|
|
|
code->type_recording_binary_op_result_type());
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case TRBinaryOpIC::UNINITIALIZED:
|
2010-12-15 13:56:41 +00:00
|
|
|
// Uninitialized means never executed.
|
|
|
|
// TODO(fschneider): Introduce a separate value for never-executed ICs
|
|
|
|
return unknown;
|
2010-12-07 11:31:57 +00:00
|
|
|
case TRBinaryOpIC::SMI:
|
|
|
|
switch (result_type) {
|
|
|
|
case TRBinaryOpIC::UNINITIALIZED:
|
|
|
|
case TRBinaryOpIC::SMI:
|
|
|
|
return TypeInfo::Smi();
|
|
|
|
case TRBinaryOpIC::INT32:
|
|
|
|
return TypeInfo::Integer32();
|
|
|
|
case TRBinaryOpIC::HEAP_NUMBER:
|
|
|
|
return TypeInfo::Double();
|
|
|
|
default:
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
case TRBinaryOpIC::INT32:
|
|
|
|
if (expr->op() == Token::DIV ||
|
|
|
|
result_type == TRBinaryOpIC::HEAP_NUMBER) {
|
|
|
|
return TypeInfo::Double();
|
|
|
|
}
|
|
|
|
return TypeInfo::Integer32();
|
|
|
|
case TRBinaryOpIC::HEAP_NUMBER:
|
|
|
|
return TypeInfo::Double();
|
2011-04-15 06:39:36 +00:00
|
|
|
case TRBinaryOpIC::BOTH_STRING:
|
|
|
|
return TypeInfo::String();
|
2010-12-07 11:31:57 +00:00
|
|
|
case TRBinaryOpIC::STRING:
|
|
|
|
case TRBinaryOpIC::GENERIC:
|
|
|
|
return unknown;
|
|
|
|
default:
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
|
2011-01-13 14:16:08 +00:00
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
TypeInfo TypeFeedbackOracle::SwitchType(CaseClause* clause) {
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> object = GetInfo(clause->CompareId());
|
2010-12-07 11:31:57 +00:00
|
|
|
TypeInfo unknown = TypeInfo::Unknown();
|
|
|
|
if (!object->IsCode()) return unknown;
|
|
|
|
Handle<Code> code = Handle<Code>::cast(object);
|
|
|
|
if (!code->is_compare_ic_stub()) return unknown;
|
|
|
|
|
|
|
|
CompareIC::State state = static_cast<CompareIC::State>(code->compare_state());
|
|
|
|
switch (state) {
|
|
|
|
case CompareIC::UNINITIALIZED:
|
2010-12-15 13:56:41 +00:00
|
|
|
// Uninitialized means never executed.
|
|
|
|
// TODO(fschneider): Introduce a separate value for never-executed ICs.
|
|
|
|
return unknown;
|
2010-12-07 11:31:57 +00:00
|
|
|
case CompareIC::SMIS:
|
|
|
|
return TypeInfo::Smi();
|
|
|
|
case CompareIC::HEAP_NUMBERS:
|
|
|
|
return TypeInfo::Number();
|
|
|
|
case CompareIC::OBJECTS:
|
|
|
|
// TODO(kasperl): We really need a type for JS objects here.
|
|
|
|
return TypeInfo::NonPrimitive();
|
|
|
|
case CompareIC::GENERIC:
|
|
|
|
default:
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-29 09:21:18 +00:00
|
|
|
TypeInfo TypeFeedbackOracle::IncrementType(CountOperation* expr) {
|
|
|
|
Handle<Object> object = GetInfo(expr->CountId());
|
|
|
|
TypeInfo unknown = TypeInfo::Unknown();
|
|
|
|
if (!object->IsCode()) return unknown;
|
|
|
|
Handle<Code> code = Handle<Code>::cast(object);
|
|
|
|
if (!code->is_type_recording_binary_op_stub()) return unknown;
|
|
|
|
|
|
|
|
TRBinaryOpIC::TypeInfo type = static_cast<TRBinaryOpIC::TypeInfo>(
|
|
|
|
code->type_recording_binary_op_type());
|
|
|
|
switch (type) {
|
|
|
|
case TRBinaryOpIC::UNINITIALIZED:
|
|
|
|
case TRBinaryOpIC::SMI:
|
|
|
|
return TypeInfo::Smi();
|
|
|
|
case TRBinaryOpIC::INT32:
|
|
|
|
return TypeInfo::Integer32();
|
|
|
|
case TRBinaryOpIC::HEAP_NUMBER:
|
|
|
|
return TypeInfo::Double();
|
|
|
|
case TRBinaryOpIC::BOTH_STRING:
|
|
|
|
case TRBinaryOpIC::STRING:
|
|
|
|
case TRBinaryOpIC::GENERIC:
|
|
|
|
return unknown;
|
|
|
|
default:
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
return unknown;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-27 15:02:59 +00:00
|
|
|
ZoneMapList* TypeFeedbackOracle::CollectReceiverTypes(unsigned ast_id,
|
2010-12-07 11:31:57 +00:00
|
|
|
Handle<String> name,
|
|
|
|
Code::Flags flags) {
|
2011-03-18 20:35:07 +00:00
|
|
|
Isolate* isolate = Isolate::Current();
|
2011-04-27 15:02:59 +00:00
|
|
|
Handle<Object> object = GetInfo(ast_id);
|
2011-01-13 14:16:08 +00:00
|
|
|
if (object->IsUndefined() || object->IsSmi()) return NULL;
|
2010-12-07 11:31:57 +00:00
|
|
|
|
2011-03-23 13:40:07 +00:00
|
|
|
if (*object == isolate->builtins()->builtin(Builtins::kStoreIC_GlobalProxy)) {
|
2010-12-07 11:31:57 +00:00
|
|
|
// TODO(fschneider): We could collect the maps and signal that
|
|
|
|
// we need a generic store (or load) here.
|
|
|
|
ASSERT(Handle<Code>::cast(object)->ic_state() == MEGAMORPHIC);
|
|
|
|
return NULL;
|
|
|
|
} else if (object->IsMap()) {
|
|
|
|
ZoneMapList* types = new ZoneMapList(1);
|
|
|
|
types->Add(Handle<Map>::cast(object));
|
|
|
|
return types;
|
|
|
|
} else if (Handle<Code>::cast(object)->ic_state() == MEGAMORPHIC) {
|
|
|
|
ZoneMapList* types = new ZoneMapList(4);
|
|
|
|
ASSERT(object->IsCode());
|
2011-03-18 20:35:07 +00:00
|
|
|
isolate->stub_cache()->CollectMatchingMaps(types, *name, flags);
|
2010-12-07 11:31:57 +00:00
|
|
|
return types->length() > 0 ? types : NULL;
|
|
|
|
} else {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-27 15:02:59 +00:00
|
|
|
void TypeFeedbackOracle::SetInfo(unsigned ast_id, Object* target) {
|
|
|
|
ASSERT(dictionary_->FindEntry(ast_id) == NumberDictionary::kNotFound);
|
|
|
|
MaybeObject* maybe_result = dictionary_->AtNumberPut(ast_id, target);
|
2011-03-30 15:56:29 +00:00
|
|
|
USE(maybe_result);
|
2011-03-30 16:04:37 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
Object* result;
|
2011-03-30 15:31:16 +00:00
|
|
|
// Dictionary has been allocated with sufficient size for all elements.
|
|
|
|
ASSERT(maybe_result->ToObject(&result));
|
|
|
|
ASSERT(*dictionary_ == result);
|
2011-03-30 16:04:37 +00:00
|
|
|
#endif
|
2011-03-30 15:31:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
void TypeFeedbackOracle::PopulateMap(Handle<Code> code) {
|
2011-03-18 20:35:07 +00:00
|
|
|
Isolate* isolate = Isolate::Current();
|
|
|
|
HandleScope scope(isolate);
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
const int kInitialCapacity = 16;
|
|
|
|
List<int> code_positions(kInitialCapacity);
|
2011-04-27 15:02:59 +00:00
|
|
|
List<unsigned> ast_ids(kInitialCapacity);
|
|
|
|
CollectIds(*code, &code_positions, &ast_ids);
|
2010-12-07 11:31:57 +00:00
|
|
|
|
2011-03-07 16:09:56 +00:00
|
|
|
ASSERT(dictionary_.is_null()); // Only initialize once.
|
2011-03-18 20:35:07 +00:00
|
|
|
dictionary_ = isolate->factory()->NewNumberDictionary(
|
|
|
|
code_positions.length());
|
2011-03-07 16:09:56 +00:00
|
|
|
|
2011-04-27 15:02:59 +00:00
|
|
|
const int length = code_positions.length();
|
|
|
|
ASSERT(ast_ids.length() == length);
|
2010-12-07 11:31:57 +00:00
|
|
|
for (int i = 0; i < length; i++) {
|
2011-03-30 17:19:44 +00:00
|
|
|
AssertNoAllocation no_allocation;
|
2010-12-07 11:31:57 +00:00
|
|
|
RelocInfo info(code->instruction_start() + code_positions[i],
|
|
|
|
RelocInfo::CODE_TARGET, 0);
|
2011-03-30 15:31:16 +00:00
|
|
|
Code* target = Code::GetCodeFromTargetAddress(info.target_address());
|
2011-04-27 15:02:59 +00:00
|
|
|
unsigned id = ast_ids[i];
|
2010-12-07 11:31:57 +00:00
|
|
|
InlineCacheState state = target->ic_state();
|
|
|
|
Code::Kind kind = target->kind();
|
2011-03-30 15:31:16 +00:00
|
|
|
|
2011-04-11 09:39:21 +00:00
|
|
|
if (kind == Code::TYPE_RECORDING_BINARY_OP_IC ||
|
2010-12-07 11:31:57 +00:00
|
|
|
kind == Code::COMPARE_IC) {
|
2011-04-27 15:02:59 +00:00
|
|
|
SetInfo(id, target);
|
2010-12-07 11:31:57 +00:00
|
|
|
} else if (state == MONOMORPHIC) {
|
2011-03-09 15:01:16 +00:00
|
|
|
if (kind == Code::KEYED_EXTERNAL_ARRAY_LOAD_IC ||
|
|
|
|
kind == Code::KEYED_EXTERNAL_ARRAY_STORE_IC) {
|
2011-04-27 15:02:59 +00:00
|
|
|
SetInfo(id, target);
|
|
|
|
} else if (kind != Code::CALL_IC ||
|
|
|
|
target->check_type() == RECEIVER_MAP_CHECK) {
|
2011-03-18 20:35:07 +00:00
|
|
|
Map* map = target->FindFirstMap();
|
|
|
|
if (map == NULL) {
|
2011-04-27 15:02:59 +00:00
|
|
|
SetInfo(id, target);
|
2011-01-13 14:16:08 +00:00
|
|
|
} else {
|
2011-04-27 15:02:59 +00:00
|
|
|
SetInfo(id, map);
|
2011-01-13 14:16:08 +00:00
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
} else {
|
2011-01-13 14:16:08 +00:00
|
|
|
ASSERT(target->kind() == Code::CALL_IC);
|
|
|
|
CheckType check = target->check_type();
|
|
|
|
ASSERT(check != RECEIVER_MAP_CHECK);
|
2011-04-27 15:02:59 +00:00
|
|
|
SetInfo(id, Smi::FromInt(check));
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
} else if (state == MEGAMORPHIC) {
|
2011-04-27 15:02:59 +00:00
|
|
|
SetInfo(id, target);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
2011-03-07 16:09:56 +00:00
|
|
|
// Allocate handle in the parent scope.
|
|
|
|
dictionary_ = scope.CloseAndEscape(dictionary_);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-27 15:02:59 +00:00
|
|
|
void TypeFeedbackOracle::CollectIds(Code* code,
|
|
|
|
List<int>* code_positions,
|
|
|
|
List<unsigned>* ast_ids) {
|
2010-12-07 11:31:57 +00:00
|
|
|
AssertNoAllocation no_allocation;
|
2011-04-27 15:02:59 +00:00
|
|
|
int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET_WITH_ID);
|
2010-12-07 11:31:57 +00:00
|
|
|
for (RelocIterator it(code, mask); !it.done(); it.next()) {
|
|
|
|
RelocInfo* info = it.rinfo();
|
2011-04-27 15:02:59 +00:00
|
|
|
ASSERT(RelocInfo::IsCodeTarget(info->rmode()));
|
|
|
|
Code* target = Code::GetCodeFromTargetAddress(info->target_address());
|
|
|
|
if (target->is_inline_cache_stub()) {
|
|
|
|
InlineCacheState state = target->ic_state();
|
|
|
|
Code::Kind kind = target->kind();
|
|
|
|
if (kind == Code::TYPE_RECORDING_BINARY_OP_IC) {
|
|
|
|
if (target->type_recording_binary_op_type() ==
|
|
|
|
TRBinaryOpIC::GENERIC) {
|
|
|
|
continue;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
2011-04-27 15:02:59 +00:00
|
|
|
} else if (kind == Code::COMPARE_IC) {
|
|
|
|
if (target->compare_state() == CompareIC::GENERIC) continue;
|
|
|
|
} else {
|
|
|
|
if (state != MONOMORPHIC && state != MEGAMORPHIC) continue;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
2011-04-27 15:02:59 +00:00
|
|
|
code_positions->Add(
|
|
|
|
static_cast<int>(info->pc() - code->instruction_start()));
|
|
|
|
ASSERT(ast_ids->length() == 0 ||
|
|
|
|
(*ast_ids)[ast_ids->length()-1] !=
|
|
|
|
static_cast<unsigned>(info->data()));
|
|
|
|
ast_ids->Add(static_cast<unsigned>(info->data()));
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-03-24 15:29:41 +00:00
|
|
|
} } // namespace v8::internal
|