}
-void StoreGlobalStub::InitializeInterfaceDescriptor(
- Isolate* isolate,
- CodeStubInterfaceDescriptor* descriptor) {
- static Register registers[] = { r1, r2, r0 };
- descriptor->register_param_count_ = 3;
- descriptor->register_params_ = registers;
- descriptor->deoptimization_handler_ =
- FUNCTION_ADDR(StoreIC_MissFromStubFailure);
-}
-
-
#define __ ACCESS_MASM(masm)
static void EmitIdenticalObjectComparison(MacroAssembler* masm,
ASSERT(destination->IsStackSlot());
__ str(source_register, cgen_->ToMemOperand(destination));
}
+
} else if (source->IsStackSlot()) {
MemOperand source_operand = cgen_->ToMemOperand(source);
if (destination->IsRegister()) {
} else {
__ LoadObject(dst, cgen_->ToHandle(constant_source));
}
- } else if (source->IsDoubleRegister()) {
- DwVfpRegister result = cgen_->ToDoubleRegister(destination);
- double v = cgen_->ToDouble(constant_source);
- __ Vmov(result, v, ip);
} else {
ASSERT(destination->IsStackSlot());
ASSERT(!in_cycle_); // Constant moves happen after all cycles are gone.
if (is_monomorphic_) {
target_ = oracle->GetCallNewTarget(this);
Object* value = allocation_info_cell_->value();
- ASSERT(!value->IsTheHole());
if (value->IsSmi()) {
elements_kind_ = static_cast<ElementsKind>(Smi::cast(value)->value());
}
IfBuilder if_true(this);
if_true.If<HBranch>(GetParameter(0), stub->GetTypes());
if_true.Then();
- if_true.Return(graph()->GetConstant1());
+ if_true.Return(graph()->GetConstant1());
if_true.Else();
if_true.End();
return graph()->GetConstant0();
}
-template <>
-HValue* CodeStubGraphBuilder<StoreGlobalStub>::BuildCodeInitializedStub() {
- StoreGlobalStub* stub = casted_stub();
- Handle<Object> hole(isolate()->heap()->the_hole_value(), isolate());
- Handle<Object> placeholer_value(Smi::FromInt(0), isolate());
- Handle<PropertyCell> placeholder_cell =
- isolate()->factory()->NewPropertyCell(placeholer_value);
-
- HParameter* receiver = GetParameter(0);
- HParameter* value = GetParameter(2);
-
- if (stub->is_constant()) {
- // Assume every store to a constant value changes it.
- current_block()->FinishExitWithDeoptimization(HDeoptimize::kUseAll);
- set_current_block(NULL);
- } else {
- HValue* cell = Add<HConstant>(placeholder_cell, Representation::Tagged());
- // Check that the map of the global has not changed.
- AddInstruction(HCheckMaps::New(receiver,
- Handle<Map>(isolate()->heap()->meta_map()),
- zone()));
-
- // Load the payload of the global parameter cell. A hole indicates that the
- // property has been deleted and that the store must be handled by the
- // runtime.
- HObjectAccess access(HObjectAccess::ForCellPayload(isolate()));
- HValue* cell_contents = Add<HLoadNamedField>(cell, access);
- IfBuilder builder(this);
- HValue* hole_value = Add<HConstant>(hole, Representation::Tagged());
- builder.If<HCompareObjectEqAndBranch>(cell_contents, hole_value);
- builder.Then();
- builder.Deopt();
- builder.Else();
- Add<HStoreNamedField>(cell, access, value);
- builder.End();
- }
- return value;
-}
-
-
-Handle<Code> StoreGlobalStub::GenerateCode() {
- return DoGenerateCode(this);
-}
-
-
} } // namespace v8::internal
}
-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 = Isolate::Current();
Factory* factory = isolate->factory();
V(ArrayConstructor) \
V(InternalArrayConstructor) \
V(ProfileEntryHook) \
- V(StoreGlobal) \
/* IC Handler stubs */ \
V(LoadField) \
V(KeyedLoadField)
// Retrieve the code for the stub. Generate the code if needed.
Handle<Code> GetCode(Isolate* isolate);
- // Retrieve the code for the stub, make and return a copy of the code.
- Handle<Code> GetCodeCopyFromTemplate(Isolate* isolate);
static Major MajorKeyFromKey(uint32_t key) {
return static_cast<Major>(MajorKeyBits::decode(key));
}
int MinorKey() { return slots_; }
};
-class StoreGlobalStub : public HydrogenCodeStub {
- public:
- StoreGlobalStub(StrictModeFlag strict_mode, bool is_constant) {
- bit_field_ = StrictModeBits::encode(strict_mode) |
- IsConstantBits::encode(is_constant);
- }
-
- virtual Handle<Code> GenerateCode();
-
- virtual void InitializeInterfaceDescriptor(
- Isolate* isolate,
- CodeStubInterfaceDescriptor* descriptor);
-
- virtual Code::Kind GetCodeKind() const { return Code::STORE_IC; }
- virtual InlineCacheState GetICState() { return MONOMORPHIC; }
- virtual Code::ExtraICState GetExtraICState() { return bit_field_; }
-
- bool is_constant() {
- return IsConstantBits::decode(bit_field_);
- }
- void set_is_constant(bool value) {
- bit_field_ = IsConstantBits::update(bit_field_, value);
- }
-
- Representation representation() {
- return Representation::FromKind(RepresentationBits::decode(bit_field_));
- }
- void set_representation(Representation r) {
- bit_field_ = RepresentationBits::update(bit_field_, r.kind());
- }
-
- private:
- virtual int NotMissMinorKey() { return GetExtraICState(); }
- Major MajorKey() { return StoreGlobal; }
-
- class StrictModeBits: public BitField<StrictModeFlag, 0, 1> {};
- class IsConstantBits: public BitField<bool, 1, 1> {};
- class RepresentationBits: public BitField<Representation::Kind, 2, 8> {};
-
- int bit_field_;
-
- DISALLOW_COPY_AND_ASSIGN(StoreGlobalStub);
-};
-
class FastCloneShallowArrayStub : public HydrogenCodeStub {
public:
SKIP_WRITE_BARRIER);
cell->set_value(value);
cell->set_type(Type::None());
- cell->SetValueInferType(value);
return result;
}
V(map_field_string, "%map") \
V(elements_field_string, "%elements") \
V(length_field_string, "%length") \
- V(cell_value_string, "%cell_value") \
V(function_class_string, "Function") \
V(properties_field_symbol, "%properties") \
V(payload_field_symbol, "%payload") \
has_double_value_(false),
is_internalized_string_(false),
is_not_in_new_space_(true),
- is_cell_(false),
boolean_value_(handle->BooleanValue()) {
if (handle_->IsHeapObject()) {
Heap* heap = Handle<HeapObject>::cast(handle)->GetHeap();
type_from_value_ = HType::TypeFromValue(handle_);
is_internalized_string_ = handle_->IsInternalizedString();
}
-
- is_cell_ = !handle_.is_null() &&
- (handle_->IsCell() || handle_->IsPropertyCell());
Initialize(r);
}
HType type,
bool is_internalize_string,
bool is_not_in_new_space,
- bool is_cell,
bool boolean_value)
: handle_(handle),
unique_id_(unique_id),
has_double_value_(false),
is_internalized_string_(is_internalize_string),
is_not_in_new_space_(is_not_in_new_space),
- is_cell_(is_cell),
boolean_value_(boolean_value),
type_from_value_(type) {
ASSERT(!handle.is_null());
has_double_value_(true),
is_internalized_string_(false),
is_not_in_new_space_(is_not_in_new_space),
- is_cell_(false),
boolean_value_(integer_value != 0),
int32_value_(integer_value),
double_value_(FastI2D(integer_value)) {
has_double_value_(true),
is_internalized_string_(false),
is_not_in_new_space_(is_not_in_new_space),
- is_cell_(false),
boolean_value_(double_value != 0 && !std::isnan(double_value)),
int32_value_(DoubleToInt32(double_value)),
double_value_(double_value) {
}
set_representation(r);
SetFlag(kUseGVN);
-}
-
-
-bool HConstant::EmitAtUses() {
- ASSERT(IsLinked());
- if (block()->graph()->has_osr_loop_entry()) {
- return block()->graph()->IsStandardConstant(this);
+ if (representation().IsInteger32()) {
+ ClearGVNFlag(kDependsOnOsrEntries);
}
- if (IsCell()) return false;
- if (representation().IsDouble()) return false;
- return true;
}
type_from_value_,
is_internalized_string_,
is_not_in_new_space_,
- is_cell_,
boolean_value_);
}
}
-HObjectAccess HObjectAccess::ForCellPayload(Isolate* isolate) {
- return HObjectAccess(
- kInobject, Cell::kValueOffset,
- Handle<String>(isolate->heap()->cell_value_string()));
-}
-
-
void HObjectAccess::SetGVNFlags(HValue *instr, bool is_store) {
// set the appropriate GVN flags for a given load or store instruction
if (is_store) {
HType type,
bool is_internalized_string,
bool is_not_in_new_space,
- bool is_cell,
bool boolean_value);
Handle<Object> handle() {
unique_id_ == UniqueValueId(heap->empty_string());
}
- bool IsCell() const {
- return is_cell_;
- }
-
virtual Representation RequiredInputRepresentation(int index) {
return Representation::None();
}
return Representation::Tagged();
}
- virtual bool EmitAtUses();
+ virtual bool EmitAtUses() { return !representation().IsDouble(); }
virtual void PrintDataTo(StringStream* stream);
virtual HType CalculateInferredType();
bool IsInteger() { return handle()->IsSmi(); }
bool has_double_value_ : 1;
bool is_internalized_string_ : 1; // TODO(yangguo): make this part of HType.
bool is_not_in_new_space_ : 1;
- bool is_cell_ : 1;
bool boolean_value_ : 1;
int32_t int32_value_;
double double_value_;
HInnerAllocatedObject::cast(object)->base_object(),
new_space_dominator);
}
- if (object->IsConstant() && HConstant::cast(object)->IsCell()) {
- return false;
- }
if (object != new_space_dominator) return true;
if (object->IsAllocateObject()) return false;
if (object->IsAllocate()) {
static HObjectAccess ForField(Handle<Map> map,
LookupResult *lookup, Handle<String> name = Handle<String>::null());
- // Create an access for the payload of a Cell or JSGlobalPropertyCell.
- static HObjectAccess ForCellPayload(Isolate* isolate);
-
void PrintTo(StringStream* stream);
inline bool Equals(HObjectAccess that) const {
-// Copyright 2013 the V8 project authors. All rights reserved.
+// 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:
htype, \
false, \
true, \
- false, \
boolean_value); \
constant->InsertAfter(GetConstantUndefined()); \
constant_##name##_.set(constant); \
}
-bool HGraph::IsStandardConstant(HConstant* constant) {
- if (constant == GetConstantUndefined()) return true;
- if (constant == GetConstant0()) return true;
- if (constant == GetConstant1()) return true;
- if (constant == GetConstantMinus1()) return true;
- if (constant == GetConstantTrue()) return true;
- if (constant == GetConstantFalse()) return true;
- if (constant == GetConstantHole()) return true;
- if (constant == GetConstantNull()) return true;
- return false;
-}
-
-
HGraphBuilder::IfBuilder::IfBuilder(HGraphBuilder* builder, int position)
: builder_(builder),
position_(position),
}
-void HOptimizedGraphBuilder::AddSoftDeoptimize(SoftDeoptimizeMode mode) {
+void HOptimizedGraphBuilder::AddSoftDeoptimize() {
isolate()->counters()->soft_deopts_requested()->Increment();
- if (FLAG_always_opt && mode == CAN_OMIT_SOFT_DEOPT) return;
+ if (FLAG_always_opt) return;
if (current_block()->IsDeoptimizing()) return;
Add<HSoftDeoptimize>();
isolate()->counters()->soft_deopts_inserted()->Increment();
if (type == kUseCell) {
Handle<GlobalObject> global(current_info()->global_object());
Handle<PropertyCell> cell(global->GetPropertyCell(&lookup));
- if (cell->type()->IsConstant()) {
- cell->AddDependentCompilationInfo(top_info());
- Handle<Object> constant_object = cell->type()->AsConstant();
- if (constant_object->IsConsString()) {
- constant_object =
- FlattenGetString(Handle<String>::cast(constant_object));
- }
- HConstant* constant = new(zone()) HConstant(constant_object);
- return ast_context()->ReturnInstruction(constant, expr->id());
- } else {
- HLoadGlobalCell* instr =
- new(zone()) HLoadGlobalCell(cell, lookup.GetPropertyDetails());
- return ast_context()->ReturnInstruction(instr, expr->id());
- }
+ HLoadGlobalCell* instr =
+ new(zone()) HLoadGlobalCell(cell, lookup.GetPropertyDetails());
+ return ast_context()->ReturnInstruction(instr, expr->id());
} else {
HValue* context = environment()->LookupContext();
HGlobalObject* global_object = new(zone()) HGlobalObject(context);
if (type == kUseCell) {
Handle<GlobalObject> global(current_info()->global_object());
Handle<PropertyCell> cell(global->GetPropertyCell(&lookup));
- if (cell->type()->IsConstant()) {
- IfBuilder builder(this);
- HValue* constant = Add<HConstant>(cell->type()->AsConstant());
- if (cell->type()->AsConstant()->IsNumber()) {
- builder.IfCompare(value, constant, Token::EQ);
- } else {
- builder.If<HCompareObjectEqAndBranch>(value, constant);
- }
- builder.Then();
- builder.Else();
- AddSoftDeoptimize(MUST_EMIT_SOFT_DEOPT);
- builder.End();
- }
- HInstruction* instr =
- Add<HStoreGlobalCell>(value, cell, lookup.GetPropertyDetails());
+ HInstruction* instr = Add<HStoreGlobalCell>(value, cell,
+ lookup.GetPropertyDetails());
instr->set_position(position);
if (instr->HasObservableSideEffects()) {
AddSimulate(ast_id, REMOVABLE_SIMULATE);
HConstant* GetConstantNull();
HConstant* GetInvalidContext();
- bool IsStandardConstant(HConstant* constant);
-
HBasicBlock* CreateBasicBlock();
HArgumentsObject* GetArgumentsObject() const {
return arguments_object_.get();
bool inline_bailout() { return inline_bailout_; }
- enum SoftDeoptimizeMode {
- MUST_EMIT_SOFT_DEOPT,
- CAN_OMIT_SOFT_DEOPT
- };
-
- void AddSoftDeoptimize(SoftDeoptimizeMode mode = CAN_OMIT_SOFT_DEOPT);
+ void AddSoftDeoptimize();
void Bailout(const char* reason);
}
-void StoreGlobalStub::InitializeInterfaceDescriptor(
- Isolate* isolate,
- CodeStubInterfaceDescriptor* descriptor) {
- static Register registers[] = { edx, ecx, eax };
- descriptor->register_param_count_ = 3;
- descriptor->register_params_ = registers;
- descriptor->deoptimization_handler_ =
- FUNCTION_ADDR(StoreIC_MissFromStubFailure);
-}
-
-
#define __ ACCESS_MASM(masm)
Immediate ToSmiImmediate(LOperand* op) const {
return Immediate(Smi::FromInt(ToInteger32(LConstantOperand::cast(op))));
}
- double ToDouble(LConstantOperand* op) const;
// Support for non-sse2 (x87) floating point stack handling.
// These functions maintain the depth of the stack (either 0 or 1)
XMMRegister ToDoubleRegister(int index) const;
int ToInteger32(LConstantOperand* op) const;
+ double ToDouble(LConstantOperand* op) const;
Operand BuildFastArrayOperand(LOperand* elements_pointer,
LOperand* key,
Representation key_representation,
} else {
__ LoadObject(dst, cgen_->ToHandle(constant_source));
}
- } else if (destination->IsDoubleRegister()) {
- double v = cgen_->ToDouble(constant_source);
- uint64_t int_val = BitCast<uint64_t, double>(v);
- int32_t lower = static_cast<int32_t>(int_val);
- int32_t upper = static_cast<int32_t>(int_val >> kBitsPerInt);
- if (CpuFeatures::IsSupported(SSE2)) {
- CpuFeatureScope scope(cgen_->masm(), SSE2);
- XMMRegister dst = cgen_->ToDoubleRegister(destination);
- if (int_val == 0) {
- __ xorps(dst, dst);
- } else {
- __ push(Immediate(upper));
- __ push(Immediate(lower));
- __ movdbl(dst, Operand(esp, 0));
- __ add(esp, Immediate(kDoubleSize));
- }
- } else {
- __ push(Immediate(upper));
- __ push(Immediate(lower));
- if (cgen_->X87StackNonEmpty()) {
- cgen_->PopX87();
- }
- cgen_->PushX87DoubleOperand(MemOperand(esp, 0));
- __ add(esp, Immediate(kDoubleSize));
- }
} else {
ASSERT(destination->IsStackSlot());
Operand dst = cgen_->ToOperand(destination);
ASSERT(!lookup->IsHandler());
Handle<Code> code = ComputeStoreMonomorphic(
- lookup, strict_mode, receiver, name, value);
+ lookup, strict_mode, receiver, name);
if (code.is_null()) {
Handle<Code> stub = strict_mode == kStrictMode
? generic_stub_strict() : generic_stub();
Handle<Code> StoreIC::ComputeStoreMonomorphic(LookupResult* lookup,
StrictModeFlag strict_mode,
Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value) {
+ Handle<String> name) {
Handle<JSObject> holder(lookup->holder());
switch (lookup->type()) {
case FIELD:
Handle<PropertyCell> cell(
global->GetPropertyCell(lookup), isolate());
return isolate()->stub_cache()->ComputeStoreGlobal(
- name, global, cell, value, strict_mode);
+ name, global, cell, strict_mode);
}
ASSERT(holder.is_identical_to(receiver));
return isolate()->stub_cache()->ComputeStoreNormal(strict_mode);
Handle<Code> KeyedStoreIC::ComputeStoreMonomorphic(LookupResult* lookup,
StrictModeFlag strict_mode,
Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value) {
+ Handle<String> name) {
// If the property has a non-field type allowing map transitions
// where there is extra room in the object, we leave the IC in its
// current state.
}
-RUNTIME_FUNCTION(MaybeObject*, StoreIC_MissFromStubFailure) {
- HandleScope scope(isolate);
- ASSERT(args.length() == 3);
- StoreIC ic(IC::EXTRA_CALL_FRAME, isolate);
- IC::State state = IC::StateFrom(ic.target(), args[0], args[1]);
- Code::ExtraICState extra_ic_state = ic.target()->extra_ic_state();
- return ic.Store(state,
- Code::GetStrictMode(extra_ic_state),
- args.at<Object>(0),
- args.at<String>(1),
- args.at<Object>(2));
-}
-
-
RUNTIME_FUNCTION(MaybeObject*, StoreIC_ArrayLength) {
SealHandleScope shs(isolate);
virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup,
StrictModeFlag strict_mode,
Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value);
+ Handle<String> name);
private:
void set_target(Code* code) {
virtual Handle<Code> ComputeStoreMonomorphic(LookupResult* lookup,
StrictModeFlag strict_mode,
Handle<JSObject> receiver,
- Handle<String> name,
- Handle<Object> value);
+ Handle<String> name);
virtual void UpdateMegamorphicCache(Map* map, Name* name, Code* code) { }
virtual Handle<Code> megamorphic_stub() {
DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedLoadIC_MissFromStubFailure);
DECLARE_RUNTIME_FUNCTION(MaybeObject*, KeyedStoreIC_MissFromStubFailure);
-DECLARE_RUNTIME_FUNCTION(MaybeObject*, StoreIC_MissFromStubFailure);
DECLARE_RUNTIME_FUNCTION(MaybeObject*, CompareNilIC_Miss);
DECLARE_RUNTIME_FUNCTION(MaybeObject*, ToBooleanIC_Miss);
kind() == BINARY_OP_IC ||
kind() == COMPARE_IC ||
kind() == COMPARE_NIL_IC ||
- kind() == STORE_IC ||
kind() == LOAD_IC ||
kind() == KEYED_LOAD_IC ||
kind() == TO_BOOLEAN_IC);
if (IsGlobalObject()) {
PropertyCell* cell = PropertyCell::cast(
property_dictionary()->ValueAt(result->GetDictionaryEntry()));
- cell->SetValueInferType(value);
+ cell->set_value(value);
} else {
property_dictionary()->ValueAtPut(result->GetDictionaryEntry(), value);
}
if (IsGlobalObject()) {
PropertyCell* cell =
PropertyCell::cast(property_dictionary()->ValueAt(entry));
- cell->SetValueInferType(value);
+ cell->set_value(value);
// Please note we have to update the property details.
property_dictionary()->DetailsAtPut(entry, details);
} else {
set_map(new_map);
}
PropertyCell* cell = PropertyCell::cast(dictionary->ValueAt(entry));
- cell->SetValueInferType(cell->GetHeap()->the_hole_value());
+ cell->set_value(cell->GetHeap()->the_hole_value());
dictionary->DetailsAtPut(entry, details.AsDeleted());
} else {
Object* deleted = dictionary->DeleteProperty(entry, mode);
int entry = dict->FindEntry(name);
if (entry != NameDictionary::kNotFound) {
store_value = dict->ValueAt(entry);
- PropertyCell::cast(store_value)->SetValueInferType(value);
+ PropertyCell::cast(store_value)->set_value(value);
// Assign an enumeration index to the property and update
// SetNextEnumerationIndex.
int index = dict->NextEnumerationIndex();
heap->AllocatePropertyCell(value);
if (!maybe_store_value->ToObject(&store_value)) return maybe_store_value;
}
- PropertyCell::cast(store_value)->SetValueInferType(value);
+ PropertyCell::cast(store_value)->set_value(value);
}
PropertyDetails details = PropertyDetails(attributes, NORMAL, 0);
Object* result;
}
-Type* PropertyCell::UpdateType(Object* value) {
- Isolate* isolate = GetIsolate();
- Handle<Object> value_handle(value, isolate);
- Handle<Type> old_type(type(), isolate);
- Handle<Type> new_type((value->IsSmi() || value->IsUndefined())
- ? Type::Constant(value_handle, isolate)
- : Type::Any(), isolate);
-
- if (new_type->Is(old_type)) {
- return *old_type;
- }
-
- dependent_code()->DeoptimizeDependentCodeGroup(
- isolate, DependentCode::kPropertyCellChangedGroup);
-
- if (old_type->Is(Type::None()) || old_type->Is(Type::Undefined())) {
- return *new_type;
- }
-
- return Type::Any();
-}
-
-
-void PropertyCell::SetValueInferType(Object* value,
- WriteBarrierMode ignored) {
- set_value(value, ignored);
- if (!Type::Any()->Is(type())) {
- set_type(UpdateType(value));
- }
-}
-
-
void PropertyCell::AddDependentCompilationInfo(CompilationInfo* info) {
Handle<DependentCode> dep(dependent_code());
Handle<DependentCode> codes =
// property.
DECL_ACCESSORS(dependent_code, DependentCode)
- // Sets the value of the cell and updates the type field to be the union
- // of the cell's current type and the value's type. If the change causes
- // a change of the type of the cell's contents, code dependent on the cell
- // will be deoptimized.
- void SetValueInferType(Object* value,
- WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
-
// Casting.
static inline PropertyCell* cast(Object* obj);
void AddDependentCode(Handle<Code> code);
- Type* UpdateType(Object* value);
-
private:
DECL_ACCESSORS(type_raw, Object)
DISALLOW_IMPLICIT_CONSTRUCTORS(PropertyCell);
} else if (lookup.IsNormal()) {
if (global->GetNormalizedProperty(&lookup)->IsTheHole() ||
!lookup.IsReadOnly()) {
- HandleScope scope(isolate);
global->SetNormalizedProperty(&lookup, *value);
}
} else {
Handle<Code> StubCache::ComputeStoreGlobal(Handle<Name> name,
Handle<GlobalObject> receiver,
Handle<PropertyCell> cell,
- Handle<Object> value,
StrictModeFlag strict_mode) {
- Isolate* isolate = cell->GetIsolate();
- Handle<Type> union_type(cell->UpdateType(*value), isolate);
- bool is_constant = union_type->IsConstant();
- StoreGlobalStub stub(strict_mode, is_constant);
-
- Handle<Code> code = FindIC(
+ Handle<Code> stub = FindIC(
name, Handle<JSObject>::cast(receiver),
- Code::STORE_IC, Code::NORMAL, stub.GetExtraICState());
- if (!code.is_null()) return code;
-
- if (is_constant) return stub.GetCode(isolate_);
-
- // Replace the placeholder cell and global object map with the actual global
- // cell and receiver map.
- Handle<Map> cell_map(isolate_->heap()->global_property_cell_map());
- Handle<Map> meta_map(isolate_->heap()->meta_map());
- Handle<Object> receiver_map(receiver->map(), isolate_);
- code = stub.GetCodeCopyFromTemplate(isolate_);
- code->ReplaceNthObject(1, *meta_map, *receiver_map);
- code->ReplaceNthObject(1, *cell_map, *cell);
- JSObject::UpdateMapCodeCache(receiver, name, code);
+ Code::STORE_IC, Code::NORMAL, strict_mode);
+ if (!stub.is_null()) return stub;
+ StoreStubCompiler compiler(isolate_, strict_mode);
+ Handle<Code> code = compiler.CompileStoreGlobal(receiver, cell, name);
+ JSObject::UpdateMapCodeCache(receiver, name, code);
return code;
}
if (!cached_ic.is_null()) return cached_ic;
}
- Handle<Code> ic = stub.GetCodeCopyFromTemplate(isolate_);
- ic->ReplaceNthObject(1, isolate_->heap()->meta_map(), *receiver_map);
+ Handle<Code> ic = stub.GetCode(isolate_);
+
+ // For monomorphic maps, use the code as a template, copying and replacing
+ // the monomorphic map that checks the object's type.
+ ic = isolate_->factory()->CopyCode(ic);
+ ic->ReplaceFirstMap(*receiver_map);
if (!receiver_map->is_shared()) {
Map::UpdateCodeCache(receiver_map, name, ic);
Handle<Code> ComputeStoreGlobal(Handle<Name> name,
Handle<GlobalObject> object,
Handle<PropertyCell> cell,
- Handle<Object> value,
StrictModeFlag strict_mode);
Handle<Code> ComputeStoreCallback(Handle<Name> name,
-// Copyright 2013 the V8 project authors. All rights reserved.
+// 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:
}
-void StoreGlobalStub::InitializeInterfaceDescriptor(
- Isolate* isolate,
- CodeStubInterfaceDescriptor* descriptor) {
- static Register registers[] = { rdx, rcx, rax };
- descriptor->register_param_count_ = 3;
- descriptor->register_params_ = registers;
- descriptor->deoptimization_handler_ =
- FUNCTION_ADDR(StoreIC_MissFromStubFailure);
-}
-
-
#define __ ACCESS_MASM(masm)
} else {
__ LoadObject(dst, cgen_->ToHandle(constant_source));
}
- } else if (destination->IsDoubleRegister()) {
- double v = cgen_->ToDouble(constant_source);
- uint64_t int_val = BitCast<uint64_t, double>(v);
- int32_t lower = static_cast<int32_t>(int_val);
- int32_t upper = static_cast<int32_t>(int_val >> (kBitsPerInt));
- XMMRegister dst = cgen_->ToDoubleRegister(destination);
- if (int_val == 0) {
- __ xorps(dst, dst);
- } else {
- __ push(Immediate(upper));
- __ push(Immediate(lower));
- __ movsd(dst, Operand(rsp, 0));
- __ addq(rsp, Immediate(kDoubleSize));
- }
} else {
ASSERT(destination->IsStackSlot());
Operand dst = cgen_->ToOperand(destination);
function f() {
do {
do {
- for (var i = 0; i < 10000000; i++) {
+ for (i = 0; i < 10000000; i++) {
// This should run long enough to trigger OSR.
}
} while (false);
do {
do {
- for (var i = 0; i < 1; i++) { }
+ for (i = 0; i < 1; i++) { }
} while (false);
} while (false);
do {
do {
do {
- for (var i = 0; i < 10000000; i++) { }
+ for (i = 0; i < 10000000; i++) { }
} while (false);
} while (false);
} while (false);
projects / platform / upstream / v8.git / commitdiff