[Isolates] Merge r 6300:6500 from bleeding_edge to isolates.

src/stub-cache.h

 // Copyright 2006-2008 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
@@ skipping 162 matching lines @@
 
   MUST_USE_RESULT MaybeObject* ComputeKeyedStoreField(
       String* name,
       JSObject* receiver,
       int field_index,
       Map* transition = NULL);
 
   MUST_USE_RESULT MaybeObject* ComputeKeyedStoreSpecialized(
       JSObject* receiver);
 
+  MUST_USE_RESULT MaybeObject* ComputeKeyedLoadOrStoreExternalArray(
+      JSObject* receiver,
+      bool is_store);
+
   // ---
 
   MUST_USE_RESULT MaybeObject* ComputeCallField(int argc,
                                                 InLoopFlag in_loop,
                                                 Code::Kind,
                                                 String* name,
                                                 Object* object,
                                                 JSObject* holder,
                                                 int index);
 
-  MUST_USE_RESULT MaybeObject* ComputeCallConstant(int argc,
-                                                   InLoopFlag in_loop,
-                                                   Code::Kind,
-                                                   String* name,
-                                                   Object* object,
-                                                   JSObject* holder,
-                                                   JSFunction* function);
+  MUST_USE_RESULT MaybeObject* ComputeCallConstant(
+      int argc,
+      InLoopFlag in_loop,
+      Code::Kind,
+      Code::ExtraICState extra_ic_state,
+      String* name,
+      Object* object,
+      JSObject* holder,
+      JSFunction* function);
 
   MUST_USE_RESULT MaybeObject* ComputeCallNormal(int argc,
                                                  InLoopFlag in_loop,
                                                  Code::Kind,
                                                  String* name,
                                                  JSObject* receiver);
 
   MUST_USE_RESULT MaybeObject* ComputeCallInterceptor(int argc,
                                                       Code::Kind,
                                                       String* name,
@@ skipping 214 matching lines @@
 
   static void GenerateLoadArrayLength(MacroAssembler* masm,
                                       Register receiver,
                                       Register scratch,
                                       Label* miss_label);
 
   static void GenerateLoadStringLength(MacroAssembler* masm,
                                        Register receiver,
                                        Register scratch1,
                                        Register scratch2,
-                                       Label* miss_label);
+                                       Label* miss_label,
+                                       bool support_wrappers);
 
   static void GenerateLoadFunctionPrototype(MacroAssembler* masm,
                                             Register receiver,
                                             Register scratch1,
                                             Register scratch2,
                                             Label* miss_label);
 
   static void GenerateStoreField(MacroAssembler* masm,
                                  JSObject* object,
                                  int index,
@@ skipping 53 matching lines @@
   void GenerateLoadField(JSObject* object,
                          JSObject* holder,
                          Register receiver,
                          Register scratch1,
                          Register scratch2,
                          Register scratch3,
                          int index,
                          String* name,
                          Label* miss);
 
-  bool GenerateLoadCallback(JSObject* object,
-                            JSObject* holder,
-                            Register receiver,
-                            Register name_reg,
-                            Register scratch1,
-                            Register scratch2,
-                            Register scratch3,
-                            AccessorInfo* callback,
-                            String* name,
-                            Label* miss,
-                            Failure** failure);
+  MaybeObject* GenerateLoadCallback(JSObject* object,
+                                    JSObject* holder,
+                                    Register receiver,
+                                    Register name_reg,
+                                    Register scratch1,
+                                    Register scratch2,
+                                    Register scratch3,
+                                    AccessorInfo* callback,
+                                    String* name,
+                                    Label* miss);
 
   void GenerateLoadConstant(JSObject* object,
                             JSObject* holder,
                             Register receiver,
                             Register scratch1,
                             Register scratch2,
                             Register scratch3,
                             Object* value,
                             String* name,
                             Label* miss);
@@ skipping 134 matching lines @@
   V(StringFromCharCode)                         \
   V(MathFloor)                                  \
   V(MathAbs)
 
 
 class CallStubCompiler: public StubCompiler {
  public:
   CallStubCompiler(int argc,
                    InLoopFlag in_loop,
                    Code::Kind kind,
+                   Code::ExtraICState extra_ic_state,
                    InlineCacheHolderFlag cache_holder);
 
   MUST_USE_RESULT MaybeObject* CompileCallField(JSObject* object,
                                                 JSObject* holder,
                                                 int index,
                                                 String* name);
   MUST_USE_RESULT MaybeObject* CompileCallConstant(Object* object,
                                                    JSObject* holder,
                                                    JSFunction* function,
                                                    String* name,
@@ skipping 25 matching lines @@
                                                    JSObject* holder,           \
                                                    JSGlobalPropertyCell* cell, \
                                                    JSFunction* function,       \
                                                    String* fname);
   CUSTOM_CALL_IC_GENERATORS(DECLARE_CALL_GENERATOR)
 #undef DECLARE_CALL_GENERATOR
 
   const ParameterCount arguments_;
   const InLoopFlag in_loop_;
   const Code::Kind kind_;
+  const Code::ExtraICState extra_ic_state_;
   const InlineCacheHolderFlag cache_holder_;
 
   const ParameterCount& arguments() { return arguments_; }
 
   MUST_USE_RESULT MaybeObject* GetCode(PropertyType type, String* name);
 
   // Convenience function. Calls GetCode above passing
   // CONSTANT_FUNCTION type and the name of the given function.
   MUST_USE_RESULT MaybeObject* GetCode(JSFunction* function);
 
@@ skipping 68 matching lines @@
   // Determines whether the given function can be called using the
   // fast api call builtin.
   void AnalyzePossibleApiFunction(JSFunction* function);
 
   JSFunction* constant_function_;
   bool is_simple_api_call_;
   FunctionTemplateInfo* expected_receiver_type_;
   CallHandlerInfo* api_call_info_;
 };
 
+class ExternalArrayStubCompiler: public StubCompiler {
+ public:
+  explicit ExternalArrayStubCompiler() {}
+
+  MUST_USE_RESULT MaybeObject* CompileKeyedLoadStub(
+      ExternalArrayType array_type, Code::Flags flags);
+
+  MUST_USE_RESULT MaybeObject* CompileKeyedStoreStub(
+      ExternalArrayType array_type, Code::Flags flags);
+
+ private:
+  MaybeObject* GetCode(Code::Flags flags);
+};
+
 } }  // namespace v8::internal
 
 #endif  // V8_STUB_CACHE_H_