Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/ic/handler-compiler.h b/src/ic/handler-compiler.h
index bed6577..fe59210 100644
--- a/src/ic/handler-compiler.h
+++ b/src/ic/handler-compiler.h
@@ -14,6 +14,7 @@
class CallOptimization;
enum PrototypeCheckType { CHECK_ALL_MAPS, SKIP_RECEIVER };
+enum ReturnHolder { RETURN_HOLDER, DONT_RETURN_ANYTHING };
class PropertyHandlerCompiler : public PropertyAccessCompiler {
public:
@@ -21,17 +22,16 @@
CacheHolderFlag cache_holder, Code::StubType type);
protected:
- PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind,
- Handle<HeapType> type, Handle<JSObject> holder,
- CacheHolderFlag cache_holder)
+ PropertyHandlerCompiler(Isolate* isolate, Code::Kind kind, Handle<Map> map,
+ Handle<JSObject> holder, CacheHolderFlag cache_holder)
: PropertyAccessCompiler(isolate, kind, cache_holder),
- type_(type),
+ map_(map),
holder_(holder) {}
virtual ~PropertyHandlerCompiler() {}
virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
- Label* miss) {
+ Label* miss, ReturnHolder return_what) {
UNREACHABLE();
return receiver();
}
@@ -54,11 +54,13 @@
void DiscardVectorAndSlot();
// TODO(verwaest): Make non-static.
- static void GenerateFastApiCall(MacroAssembler* masm,
- const CallOptimization& optimization,
- Handle<Map> receiver_map, Register receiver,
- Register scratch, bool is_store, int argc,
- Register* values);
+ static void GenerateApiAccessorCall(MacroAssembler* masm,
+ const CallOptimization& optimization,
+ Handle<Map> receiver_map,
+ Register receiver, Register scratch,
+ bool is_store, Register store_parameter,
+ Register accessor_holder,
+ int accessor_index);
// Helper function used to check that the dictionary doesn't contain
// the property. This function may return false negatives, so miss_label
@@ -94,26 +96,26 @@
Register CheckPrototypes(Register object_reg, Register holder_reg,
Register scratch1, Register scratch2,
Handle<Name> name, Label* miss,
- PrototypeCheckType check = CHECK_ALL_MAPS);
+ PrototypeCheckType check, ReturnHolder return_what);
Handle<Code> GetCode(Code::Kind kind, Code::StubType type, Handle<Name> name);
- void set_type_for_object(Handle<Object> object);
void set_holder(Handle<JSObject> holder) { holder_ = holder; }
- Handle<HeapType> type() const { return type_; }
+ Handle<Map> map() const { return map_; }
+ void set_map(Handle<Map> map) { map_ = map; }
Handle<JSObject> holder() const { return holder_; }
private:
- Handle<HeapType> type_;
+ Handle<Map> map_;
Handle<JSObject> holder_;
};
class NamedLoadHandlerCompiler : public PropertyHandlerCompiler {
public:
- NamedLoadHandlerCompiler(Isolate* isolate, Handle<HeapType> type,
+ NamedLoadHandlerCompiler(Isolate* isolate, Handle<Map> map,
Handle<JSObject> holder,
CacheHolderFlag cache_holder)
- : PropertyHandlerCompiler(isolate, Code::LOAD_IC, type, holder,
+ : PropertyHandlerCompiler(isolate, Code::LOAD_IC, map, holder,
cache_holder) {}
virtual ~NamedLoadHandlerCompiler() {}
@@ -124,7 +126,8 @@
Handle<ExecutableAccessorInfo> callback);
Handle<Code> CompileLoadCallback(Handle<Name> name,
- const CallOptimization& call_optimization);
+ const CallOptimization& call_optimization,
+ int accessor_index);
Handle<Code> CompileLoadConstant(Handle<Name> name, int constant_index);
@@ -133,23 +136,24 @@
// inlined.
Handle<Code> CompileLoadInterceptor(LookupIterator* it);
- Handle<Code> CompileLoadViaGetter(Handle<Name> name,
- Handle<JSFunction> getter);
+ Handle<Code> CompileLoadViaGetter(Handle<Name> name, int accessor_index,
+ int expected_arguments);
Handle<Code> CompileLoadGlobal(Handle<PropertyCell> cell, Handle<Name> name,
bool is_configurable);
// Static interface
static Handle<Code> ComputeLoadNonexistent(Handle<Name> name,
- Handle<HeapType> type);
+ Handle<Map> map);
- static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<HeapType> type,
- Register receiver,
- Handle<JSFunction> getter);
+ static void GenerateLoadViaGetter(MacroAssembler* masm, Handle<Map> map,
+ Register receiver, Register holder,
+ int accessor_index, int expected_arguments,
+ Register scratch);
static void GenerateLoadViaGetterForDeopt(MacroAssembler* masm) {
- GenerateLoadViaGetter(masm, Handle<HeapType>::null(), no_reg,
- Handle<JSFunction>());
+ GenerateLoadViaGetter(masm, Handle<Map>::null(), no_reg, no_reg, -1, -1,
+ no_reg);
}
static void GenerateLoadFunctionPrototype(MacroAssembler* masm,
@@ -163,14 +167,13 @@
// PushInterceptorArguments and read by LoadPropertyWithInterceptorOnly and
// LoadWithInterceptor.
static const int kInterceptorArgsNameIndex = 0;
- static const int kInterceptorArgsInfoIndex = 1;
- static const int kInterceptorArgsThisIndex = 2;
- static const int kInterceptorArgsHolderIndex = 3;
- static const int kInterceptorArgsLength = 4;
+ static const int kInterceptorArgsThisIndex = 1;
+ static const int kInterceptorArgsHolderIndex = 2;
+ static const int kInterceptorArgsLength = 3;
protected:
virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
- Label* miss);
+ Label* miss, ReturnHolder return_what);
virtual void FrontendFooter(Handle<Name> name, Label* miss);
@@ -210,9 +213,9 @@
class NamedStoreHandlerCompiler : public PropertyHandlerCompiler {
public:
- explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<HeapType> type,
+ explicit NamedStoreHandlerCompiler(Isolate* isolate, Handle<Map> map,
Handle<JSObject> holder)
- : PropertyHandlerCompiler(isolate, Code::STORE_IC, type, holder,
+ : PropertyHandlerCompiler(isolate, Code::STORE_IC, map, holder,
kCacheOnReceiver) {}
virtual ~NamedStoreHandlerCompiler() {}
@@ -223,38 +226,46 @@
Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name,
Handle<ExecutableAccessorInfo> callback);
Handle<Code> CompileStoreCallback(Handle<JSObject> object, Handle<Name> name,
- const CallOptimization& call_optimization);
+ const CallOptimization& call_optimization,
+ int accessor_index);
Handle<Code> CompileStoreViaSetter(Handle<JSObject> object, Handle<Name> name,
- Handle<JSFunction> setter);
+ int accessor_index,
+ int expected_arguments);
Handle<Code> CompileStoreInterceptor(Handle<Name> name);
- static void GenerateStoreViaSetter(MacroAssembler* masm,
- Handle<HeapType> type, Register receiver,
- Handle<JSFunction> setter);
+ static void GenerateStoreViaSetter(MacroAssembler* masm, Handle<Map> map,
+ Register receiver, Register holder,
+ int accessor_index, int expected_arguments,
+ Register scratch);
static void GenerateStoreViaSetterForDeopt(MacroAssembler* masm) {
- GenerateStoreViaSetter(masm, Handle<HeapType>::null(), no_reg,
- Handle<JSFunction>());
+ GenerateStoreViaSetter(masm, Handle<Map>::null(), no_reg, no_reg, -1, -1,
+ no_reg);
}
static void GenerateSlow(MacroAssembler* masm);
protected:
virtual Register FrontendHeader(Register object_reg, Handle<Name> name,
- Label* miss);
+ Label* miss, ReturnHolder return_what);
virtual void FrontendFooter(Handle<Name> name, Label* miss);
void GenerateRestoreName(Label* label, Handle<Name> name);
+ // Pop the vector and slot into appropriate registers, moving the map in
+ // the process. (This is an accomodation for register pressure on ia32).
+ void RearrangeVectorAndSlot(Register current_map, Register destination_map);
+
private:
void GenerateRestoreName(Handle<Name> name);
- void GenerateRestoreMap(Handle<Map> transition, Register scratch,
- Label* miss);
+ void GenerateRestoreMap(Handle<Map> transition, Register map_reg,
+ Register scratch, Label* miss);
void GenerateConstantCheck(Register map_reg, int descriptor,
Register value_reg, Register scratch,
Label* miss_label);
+ bool RequiresFieldTypeChecks(HeapType* field_type) const;
void GenerateFieldTypeChecks(HeapType* field_type, Register value_reg,
Label* miss_label);
@@ -278,17 +289,18 @@
public:
explicit ElementHandlerCompiler(Isolate* isolate)
: PropertyHandlerCompiler(isolate, Code::KEYED_LOAD_IC,
- Handle<HeapType>::null(),
- Handle<JSObject>::null(), kCacheOnReceiver) {}
+ Handle<Map>::null(), Handle<JSObject>::null(),
+ kCacheOnReceiver) {}
virtual ~ElementHandlerCompiler() {}
void CompileElementHandlers(MapHandleList* receiver_maps,
- CodeHandleList* handlers);
+ CodeHandleList* handlers,
+ LanguageMode language_mode);
static void GenerateStoreSlow(MacroAssembler* masm);
};
-}
-} // namespace v8::internal
+} // namespace internal
+} // namespace v8
#endif // V8_IC_HANDLER_COMPILER_H_