Land the Fan (disabled)

src/code-stubs.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_CODE_STUBS_H_
 #define V8_CODE_STUBS_H_
 
 #include "src/allocation.h"
 #include "src/assembler.h"
 #include "src/codegen.h"
 #include "src/globals.h"
 #include "src/macro-assembler.h"
+#include "src/ostreams.h"
 
 namespace v8 {
 namespace internal {
 
 // List of code stubs used on all platforms.
 #define CODE_STUB_LIST_ALL_PLATFORMS(V)     \
   V(CallFunction)                           \
   V(CallConstruct)                          \
   V(BinaryOpIC)                             \
   V(BinaryOpICWithAllocationSite)           \
@@ skipping 318 matching lines @@
   PlatformInterfaceDescriptor* platform_specific_descriptor_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceDescriptor);
 };
 
 
 class CodeStubInterfaceDescriptor: public InterfaceDescriptor {
  public:
   CodeStubInterfaceDescriptor();
 
-  void Initialize(int register_parameter_count, Register* registers,
+  void Initialize(CodeStub::Major major, int register_parameter_count,
+                  Register* registers, Address deoptimization_handler = NULL,
+                  Representation* register_param_representations = NULL,
+                  int hint_stack_parameter_count = -1,
+                  StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);
+  void Initialize(CodeStub::Major major, int register_parameter_count,
+                  Register* registers, Register stack_parameter_count,
                   Address deoptimization_handler = NULL,
                   Representation* register_param_representations = NULL,
                   int hint_stack_parameter_count = -1,
-                  StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE);
-  void Initialize(int register_parameter_count, Register* registers,
-                  Register stack_parameter_count,
-                  Address deoptimization_handler = NULL,
-                  Representation* register_param_representations = NULL,
-                  int hint_stack_parameter_count = -1,
                   StubFunctionMode function_mode = NOT_JS_FUNCTION_STUB_MODE,
                   HandlerArgumentsMode handler_mode = DONT_PASS_ARGUMENTS);
 
   void SetMissHandler(ExternalReference handler) {
     miss_handler_ = handler;
     has_miss_handler_ = true;
     // Our miss handler infrastructure doesn't currently support
     // variable stack parameter counts.
     ASSERT(!stack_parameter_count_.is_valid());
   }
@@ skipping 16 matching lines @@
     if (handler_arguments_mode_ == PASS_ARGUMENTS) {
       params += 1;
     }
     return params;
   }
 
   int hint_stack_parameter_count() const { return hint_stack_parameter_count_; }
   Register stack_parameter_count() const { return stack_parameter_count_; }
   StubFunctionMode function_mode() const { return function_mode_; }
   Address deoptimization_handler() const { return deoptimization_handler_; }
+  CodeStub::Major MajorKey() const { return major_; }
 
  private:
   Register stack_parameter_count_;
   // If hint_stack_parameter_count_ > 0, the code stub can optimize the
   // return sequence. Default value is -1, which means it is ignored.
   int hint_stack_parameter_count_;
   StubFunctionMode function_mode_;
 
   Address deoptimization_handler_;
   HandlerArgumentsMode handler_arguments_mode_;
 
   ExternalReference miss_handler_;
   bool has_miss_handler_;
+  CodeStub::Major major_;
 };
 
 
 class CallInterfaceDescriptor: public InterfaceDescriptor {
  public:
   CallInterfaceDescriptor() { }
 
   // A copy of the passed in registers and param_representations is made
   // and owned by the CallInterfaceDescriptor.
 
@@ skipping 316 matching lines @@
   };
 
   InstanceofStub(Isolate* isolate, Flags flags)
       : PlatformCodeStub(isolate), flags_(flags) { }
 
   static Register left();
   static Register right();
 
   void Generate(MacroAssembler* masm);
 
+  virtual void InitializeInterfaceDescriptor(
+      Isolate* isolate, CodeStubInterfaceDescriptor* descriptor);
+
  private:
   Major MajorKey() const { return Instanceof; }
   int MinorKey() const { return static_cast<int>(flags_); }
 
   bool HasArgsInRegisters() const {
     return (flags_ & kArgsInRegisters) != 0;
   }
 
   bool HasCallSiteInlineCheck() const {
     return (flags_ & kCallSiteInlineCheck) != 0;
@@ skipping 369 matching lines @@
   virtual void Generate(MacroAssembler* masm) V8_OVERRIDE;
   virtual Major MajorKey() const V8_OVERRIDE { return CallApiGetter; }
   virtual int MinorKey() const V8_OVERRIDE { return 0; }
 
   DISALLOW_COPY_AND_ASSIGN(CallApiGetterStub);
 };
 
 
 class BinaryOpICStub : public HydrogenCodeStub {
  public:
-  BinaryOpICStub(Isolate* isolate, Token::Value op, OverwriteMode mode)
+  BinaryOpICStub(Isolate* isolate, Token::Value op,
+                 OverwriteMode mode = NO_OVERWRITE)
       : HydrogenCodeStub(isolate, UNINITIALIZED), state_(isolate, op, mode) {}
 
-  BinaryOpICStub(Isolate* isolate, const BinaryOpIC::State& state)
+  explicit BinaryOpICStub(Isolate* isolate, const BinaryOpIC::State& state)
       : HydrogenCodeStub(isolate), state_(state) {}
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const V8_OVERRIDE {
@@ skipping 462 matching lines @@
  public:
   CallFunctionStub(Isolate* isolate, int argc, CallFunctionFlags flags)
       : PlatformCodeStub(isolate), argc_(argc), flags_(flags) { }
 
   void Generate(MacroAssembler* masm);
 
   static int ExtractArgcFromMinorKey(int minor_key) {
     return ArgcBits::decode(minor_key);
   }
 
+  virtual void InitializeInterfaceDescriptor(
+      Isolate* isolate, CodeStubInterfaceDescriptor* descriptor);
+
  private:
   int argc_;
   CallFunctionFlags flags_;
 
   virtual void PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
   // Minor key encoding in 32 bits with Bitfield <Type, shift, size>.
   class FlagBits: public BitField<CallFunctionFlags, 0, 2> {};
   class ArgcBits: public BitField<unsigned, 2, 32 - 2> {};
 
@@ skipping 17 matching lines @@
  public:
   CallConstructStub(Isolate* isolate, CallConstructorFlags flags)
       : PlatformCodeStub(isolate), flags_(flags) {}
 
   void Generate(MacroAssembler* masm);
 
   virtual void FinishCode(Handle<Code> code) {
     code->set_has_function_cache(RecordCallTarget());
   }
 
+  virtual void InitializeInterfaceDescriptor(
+      Isolate* isolate, CodeStubInterfaceDescriptor* descriptor);
+
  private:
   CallConstructorFlags flags_;
 
   virtual void PrintName(OStream& os) const V8_OVERRIDE;  // NOLINT
 
   Major MajorKey() const { return CallConstruct; }
   int MinorKey() const { return flags_; }
 
   bool RecordCallTarget() const {
     return (flags_ & RECORD_CONSTRUCTOR_TARGET) != 0;
@@ skipping 855 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_