Introduce code stub constructors for stub keys.

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"
@@ skipping 17 matching lines @@
   V(CallConstruct)                          \
   V(CallFunction)                           \
   V(CallIC)                                 \
   V(CallIC_Array)                           \
   V(CEntry)                                 \
   V(CompareIC)                              \
   V(DoubleToI)                              \
   V(FunctionPrototype)                      \
   V(Instanceof)                             \
   V(InternalArrayConstructor)               \
+  V(JSConstructEntry)                       \
   V(JSEntry)                                \
   V(KeyedLoadICTrampoline)                  \
   V(LoadICTrampoline)                       \
   V(MathPow)                                \
   V(ProfileEntryHook)                       \
   V(RecordWrite)                            \
   V(RegExpExec)                             \
   V(StoreArrayLiteralElement)               \
   V(StoreBufferOverflow)                    \
   V(StoreElement)                           \
@@ skipping 143 matching lines @@
   }
 
   friend OStream& operator<<(OStream& os, const CodeStub& s) {
     s.PrintName(os);
     return os;
   }
 
   Isolate* isolate() const { return isolate_; }
 
  protected:
-  explicit CodeStub(uint32_t key) : minor_key_(MinorKeyFromKey(key)) {}
+  CodeStub(uint32_t key, Isolate* isolate)
+      : minor_key_(MinorKeyFromKey(key)), isolate_(isolate) {}
 
   // Generates the assembler code for the stub.
   virtual Handle<Code> GenerateCode() = 0;
 
   // Returns whether the code generated for this stub needs to be allocated as
   // a fixed (non-moveable) code object.
   virtual bool NeedsImmovableCode() { return false; }
 
   virtual void PrintName(OStream& os) const;        // NOLINT
   virtual void PrintBaseName(OStream& os) const;    // NOLINT
@@ skipping 39 matching lines @@
   class MajorKeyBits: public BitField<uint32_t, 0, kStubMajorKeyBits> {};
   class MinorKeyBits: public BitField<uint32_t,
       kStubMajorKeyBits, kStubMinorKeyBits> {};  // NOLINT
 
   friend class BreakPointIterator;
 
   Isolate* isolate_;
 };
 
 
+#define DEFINE_CODE_STUB_BASE(NAME, SUPER)                      \
+ public:                                                        \
+  NAME(uint32_t key, Isolate* isolate) : SUPER(key, isolate) {} \
+                                                                \
+ private:                                                       \
+  DISALLOW_COPY_AND_ASSIGN(NAME)
+
+
+#define DEFINE_CODE_STUB(NAME, SUPER)              \
+ protected:                                        \
+  virtual inline Major MajorKey() const OVERRIDE { \
+    return NAME;                                   \
+  };                                               \
+  DEFINE_CODE_STUB_BASE(NAME##Stub, SUPER)
+
+
 class PlatformCodeStub : public CodeStub {
  public:
-  explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) { }
-
   // Retrieve the code for the stub. Generate the code if needed.
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual Code::Kind GetCodeKind() const { return Code::STUB; }
 
  protected:
+  explicit PlatformCodeStub(Isolate* isolate) : CodeStub(isolate) {}
+
   // Generates the assembler code for the stub.
   virtual void Generate(MacroAssembler* masm) = 0;
 
-  explicit PlatformCodeStub(uint32_t key) : CodeStub(key) {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(PlatformCodeStub);
+  DEFINE_CODE_STUB_BASE(PlatformCodeStub, CodeStub);
 };
 
 
 enum StubFunctionMode { NOT_JS_FUNCTION_STUB_MODE, JS_FUNCTION_STUB_MODE };
 enum HandlerArgumentsMode { DONT_PASS_ARGUMENTS, PASS_ARGUMENTS };
 
 
 class CodeStubInterfaceDescriptor {
  public:
   CodeStubInterfaceDescriptor();
@@ skipping 96 matching lines @@
 };
 
 
 class HydrogenCodeStub : public CodeStub {
  public:
   enum InitializationState {
     UNINITIALIZED,
     INITIALIZED
   };
 
-  explicit HydrogenCodeStub(Isolate* isolate,
-                            InitializationState state = INITIALIZED)
-      : CodeStub(isolate) {
-    minor_key_ = IsMissBits::encode(state == UNINITIALIZED);
-  }
-
   virtual Code::Kind GetCodeKind() const { return Code::STUB; }
 
   CodeStubInterfaceDescriptor* GetInterfaceDescriptor() {
     return isolate()->code_stub_interface_descriptor(MajorKey());
   }
 
   template<class SubClass>
   static Handle<Code> GetUninitialized(Isolate* isolate) {
     SubClass::GenerateAheadOfTime(isolate);
     return SubClass().GetCode(isolate);
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) = 0;
 
   // Retrieve the code for the stub. Generate the code if needed.
   virtual Handle<Code> GenerateCode() = 0;
 
   bool IsUninitialized() const { return IsMissBits::decode(minor_key_); }
 
   Handle<Code> GenerateLightweightMissCode();
 
   template<class StateType>
   void TraceTransition(StateType from, StateType to);
 
  protected:
+  explicit HydrogenCodeStub(Isolate* isolate,
+                            InitializationState state = INITIALIZED)
+      : CodeStub(isolate) {
+    minor_key_ = IsMissBits::encode(state == UNINITIALIZED);
+  }
+
   void set_sub_minor_key(uint32_t key) {
     minor_key_ = SubMinorKeyBits::update(minor_key_, key);
   }
 
   uint32_t sub_minor_key() const { return SubMinorKeyBits::decode(minor_key_); }
 
   static const int kSubMinorKeyBits = kStubMinorKeyBits - 1;
 
  private:
   class IsMissBits : public BitField<bool, kSubMinorKeyBits, 1> {};
   class SubMinorKeyBits : public BitField<int, 0, kSubMinorKeyBits> {};
 
   void GenerateLightweightMiss(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(HydrogenCodeStub);
+  DEFINE_CODE_STUB_BASE(HydrogenCodeStub, CodeStub);
 };
 
 
 // Helper interface to prepare to/restore after making runtime calls.
 class RuntimeCallHelper {
  public:
   virtual ~RuntimeCallHelper() {}
 
   virtual void BeforeCall(MacroAssembler* masm) const = 0;
 
@@ skipping 62 matching lines @@
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate) {
     ToNumberStub stub(isolate);
     stub.InitializeInterfaceDescriptor(
         isolate->code_stub_interface_descriptor(CodeStub::ToNumber));
   }
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(ToNumberStub);
+  DEFINE_CODE_STUB(ToNumber, HydrogenCodeStub);
 };
 
 
 class NumberToStringStub FINAL : public HydrogenCodeStub {
  public:
   explicit NumberToStringStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kNumber = 0;
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(NumberToStringStub);
+  DEFINE_CODE_STUB(NumberToString, HydrogenCodeStub);
 };
 
 
 class FastNewClosureStub : public HydrogenCodeStub {
  public:
   FastNewClosureStub(Isolate* isolate, StrictMode strict_mode,
                      bool is_generator)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(StrictModeBits::encode(strict_mode) |
                       IsGeneratorBits::encode(is_generator));
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   StrictMode strict_mode() const {
     return StrictModeBits::decode(sub_minor_key());
   }
 
   bool is_generator() const { return IsGeneratorBits::decode(sub_minor_key()); }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class StrictModeBits : public BitField<StrictMode, 0, 1> {};
   class IsGeneratorBits : public BitField<bool, 1, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(FastNewClosureStub);
+  DEFINE_CODE_STUB(FastNewClosure, HydrogenCodeStub);
 };
 
 
 class FastNewContextStub FINAL : public HydrogenCodeStub {
  public:
   static const int kMaximumSlots = 64;
 
   FastNewContextStub(Isolate* isolate, int slots) : HydrogenCodeStub(isolate) {
     DCHECK(slots > 0 && slots <= kMaximumSlots);
     set_sub_minor_key(SlotsBits::encode(slots));
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   int slots() const { return SlotsBits::decode(sub_minor_key()); }
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kFunction = 0;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class SlotsBits : public BitField<int, 0, 8> {};
 
-  DISALLOW_COPY_AND_ASSIGN(FastNewContextStub);
+  DEFINE_CODE_STUB(FastNewContext, HydrogenCodeStub);
 };
 
 
 class FastCloneShallowArrayStub : public HydrogenCodeStub {
  public:
   FastCloneShallowArrayStub(Isolate* isolate,
                             AllocationSiteMode allocation_site_mode)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(AllocationSiteModeBits::encode(allocation_site_mode));
   }
 
   AllocationSiteMode allocation_site_mode() const {
     return AllocationSiteModeBits::decode(sub_minor_key());
   }
 
   virtual Handle<Code> GenerateCode();
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class AllocationSiteModeBits: public BitField<AllocationSiteMode, 0, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(FastCloneShallowArrayStub);
+  DEFINE_CODE_STUB(FastCloneShallowArray, HydrogenCodeStub);
 };
 
 
 class FastCloneShallowObjectStub : public HydrogenCodeStub {
  public:
   // Maximum number of properties in copied object.
   static const int kMaximumClonedProperties = 6;
 
   FastCloneShallowObjectStub(Isolate* isolate, int length)
       : HydrogenCodeStub(isolate) {
     DCHECK_GE(length, 0);
     DCHECK_LE(length, kMaximumClonedProperties);
     set_sub_minor_key(LengthBits::encode(length));
   }
 
   int length() const { return LengthBits::decode(sub_minor_key()); }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class LengthBits : public BitField<int, 0, 4> {};
 
-  DISALLOW_COPY_AND_ASSIGN(FastCloneShallowObjectStub);
+  DEFINE_CODE_STUB(FastCloneShallowObject, HydrogenCodeStub);
 };
 
 
 class CreateAllocationSiteStub : public HydrogenCodeStub {
  public:
   explicit CreateAllocationSiteStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) { }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(CreateAllocationSiteStub);
+  DEFINE_CODE_STUB(CreateAllocationSite, HydrogenCodeStub);
 };
 
 
 class InstanceofStub: public PlatformCodeStub {
  public:
   enum Flags {
     kNoFlags = 0,
     kArgsInRegisters = 1 << 0,
     kCallSiteInlineCheck = 1 << 1,
     kReturnTrueFalseObject = 1 << 2
   };
 
   InstanceofStub(Isolate* isolate, Flags flags) : PlatformCodeStub(isolate) {
     minor_key_ = FlagBits::encode(flags);
   }
 
   void Generate(MacroAssembler* masm);
 
   static Register left() { return InstanceofDescriptor::left(); }
   static Register right() { return InstanceofDescriptor::right(); }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   Flags flags() const { return FlagBits::decode(minor_key_); }
 
   bool HasArgsInRegisters() const { return (flags() & kArgsInRegisters) != 0; }
 
   bool HasCallSiteInlineCheck() const {
     return (flags() & kCallSiteInlineCheck) != 0;
   }
 
   bool ReturnTrueFalseObject() const {
     return (flags() & kReturnTrueFalseObject) != 0;
   }
 
   virtual void PrintName(OStream& os) const OVERRIDE;  // NOLINT
 
   class FlagBits : public BitField<Flags, 0, 3> {};
 
-  DISALLOW_COPY_AND_ASSIGN(InstanceofStub);
+  DEFINE_CODE_STUB(Instanceof, PlatformCodeStub);
 };
 
 
 enum AllocationSiteOverrideMode {
   DONT_OVERRIDE,
   DISABLE_ALLOCATION_SITES,
   LAST_ALLOCATION_SITE_OVERRIDE_MODE = DISABLE_ALLOCATION_SITES
 };
 
 
 class ArrayConstructorStub: public PlatformCodeStub {
  public:
   enum ArgumentCountKey { ANY, NONE, ONE, MORE_THAN_ONE };
+
   ArrayConstructorStub(Isolate* isolate, int argument_count);
 
   explicit ArrayConstructorStub(Isolate* isolate);
 
   void Generate(MacroAssembler* masm);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   ArgumentCountKey argument_count() const {
     return ArgumentCountBits::decode(minor_key_);
   }
 
   void GenerateDispatchToArrayStub(MacroAssembler* masm,
                                    AllocationSiteOverrideMode mode);
 
   virtual void PrintName(OStream& os) const OVERRIDE;  // NOLINT
 
   class ArgumentCountBits : public BitField<ArgumentCountKey, 0, 2> {};
 
-  DISALLOW_COPY_AND_ASSIGN(ArrayConstructorStub);
+  DEFINE_CODE_STUB(ArrayConstructor, PlatformCodeStub);
 };
 
 
 class InternalArrayConstructorStub: public PlatformCodeStub {
  public:
   explicit InternalArrayConstructorStub(Isolate* isolate);
 
   void Generate(MacroAssembler* masm);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   void GenerateCase(MacroAssembler* masm, ElementsKind kind);
 
-  DISALLOW_COPY_AND_ASSIGN(InternalArrayConstructorStub);
+  DEFINE_CODE_STUB(InternalArrayConstructor, PlatformCodeStub);
 };
 
 
 class MathPowStub: public PlatformCodeStub {
  public:
   enum ExponentType { INTEGER, DOUBLE, TAGGED, ON_STACK };
 
   MathPowStub(Isolate* isolate, ExponentType exponent_type)
       : PlatformCodeStub(isolate) {
     minor_key_ = ExponentTypeBits::encode(exponent_type);
   }
 
   virtual void Generate(MacroAssembler* masm);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   ExponentType exponent_type() const {
     return ExponentTypeBits::decode(minor_key_);
   }
 
   class ExponentTypeBits : public BitField<ExponentType, 0, 2> {};
 
-  DISALLOW_COPY_AND_ASSIGN(MathPowStub);
+  DEFINE_CODE_STUB(MathPow, PlatformCodeStub);
 };
 
 
 class CallICStub: public PlatformCodeStub {
  public:
   CallICStub(Isolate* isolate, const CallIC::State& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
@@ skipping 18 matching lines @@
   int arg_count() const { return state().arg_count(); }
 
   CallIC::State state() const {
     return CallIC::State(static_cast<ExtraICState>(minor_key_));
   }
 
   // Code generation helpers.
   void GenerateMiss(MacroAssembler* masm, IC::UtilityId id);
 
  private:
-  virtual inline Major MajorKey() const OVERRIDE;
-
   virtual void PrintState(OStream& os) const OVERRIDE;  // NOLINT
 
-  DISALLOW_COPY_AND_ASSIGN(CallICStub);
+  DEFINE_CODE_STUB(CallIC, PlatformCodeStub);
 };
 
 
 class CallIC_ArrayStub: public CallICStub {
  public:
   CallIC_ArrayStub(Isolate* isolate, const CallIC::State& state_in)
       : CallICStub(isolate, state_in) {}
 
   virtual void Generate(MacroAssembler* masm);
 
   virtual InlineCacheState GetICState() const FINAL OVERRIDE {
     return MONOMORPHIC;
   }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void PrintState(OStream& os) const OVERRIDE;  // NOLINT
 
-  DISALLOW_COPY_AND_ASSIGN(CallIC_ArrayStub);
+  DEFINE_CODE_STUB(CallIC_Array, CallICStub);
 };
 
 
 // TODO(verwaest): Translate to hydrogen code stub.
 class FunctionPrototypeStub : public PlatformCodeStub {
  public:
   explicit FunctionPrototypeStub(Isolate* isolate)
       : PlatformCodeStub(isolate) {}
+
   virtual void Generate(MacroAssembler* masm);
+
   virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(FunctionPrototypeStub);
+  DEFINE_CODE_STUB(FunctionPrototype, PlatformCodeStub);
 };
 
 
 class HandlerStub : public HydrogenCodeStub {
  public:
   virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
   virtual ExtraICState GetExtraICState() const { return kind(); }
   virtual InlineCacheState GetICState() const { return MONOMORPHIC; }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  protected:
   explicit HandlerStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
+
   virtual Code::Kind kind() const = 0;
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(HandlerStub);
+  DEFINE_CODE_STUB_BASE(HandlerStub, HydrogenCodeStub);
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
   LoadFieldStub(Isolate* isolate, FieldIndex index) : HandlerStub(isolate) {
     int property_index_key = index.GetFieldAccessStubKey();
     set_sub_minor_key(LoadFieldByIndexBits::encode(property_index_key));
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   FieldIndex index() const {
     int property_index_key = LoadFieldByIndexBits::decode(sub_minor_key());
     return FieldIndex::FromFieldAccessStubKey(property_index_key);
   }
 
  protected:
-  explicit LoadFieldStub(Isolate* isolate);
   virtual Code::Kind kind() const { return Code::LOAD_IC; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class LoadFieldByIndexBits : public BitField<int, 0, 13> {};
 
-  DISALLOW_COPY_AND_ASSIGN(LoadFieldStub);
+  DEFINE_CODE_STUB(LoadField, HandlerStub);
 };
 
 
 class LoadConstantStub : public HandlerStub {
  public:
   LoadConstantStub(Isolate* isolate, int constant_index)
       : HandlerStub(isolate) {
     set_sub_minor_key(ConstantIndexBits::encode(constant_index));
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   int constant_index() const {
     return ConstantIndexBits::decode(sub_minor_key());
   }
 
  protected:
-  explicit LoadConstantStub(Isolate* isolate);
   virtual Code::Kind kind() const { return Code::LOAD_IC; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class ConstantIndexBits : public BitField<int, 0, kSubMinorKeyBits> {};
 
-  DISALLOW_COPY_AND_ASSIGN(LoadConstantStub);
+  DEFINE_CODE_STUB(LoadConstant, HandlerStub);
 };
 
 
 class StringLengthStub: public HandlerStub {
  public:
   explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {}
+
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
  protected:
   virtual Code::Kind kind() const { return Code::LOAD_IC; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(StringLengthStub);
+  DEFINE_CODE_STUB(StringLength, HandlerStub);
 };
 
 
 class StoreFieldStub : public HandlerStub {
  public:
   StoreFieldStub(Isolate* isolate, FieldIndex index,
                  Representation representation)
       : HandlerStub(isolate) {
     int property_index_key = index.GetFieldAccessStubKey();
     uint8_t repr = PropertyDetails::EncodeRepresentation(representation);
     set_sub_minor_key(StoreFieldByIndexBits::encode(property_index_key) |
                       RepresentationBits::encode(repr));
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   FieldIndex index() const {
     int property_index_key = StoreFieldByIndexBits::decode(sub_minor_key());
     return FieldIndex::FromFieldAccessStubKey(property_index_key);
   }
 
   Representation representation() {
     uint8_t repr = RepresentationBits::decode(sub_minor_key());
     return PropertyDetails::DecodeRepresentation(repr);
   }
 
   static void InstallDescriptors(Isolate* isolate);
 
  protected:
-  explicit StoreFieldStub(Isolate* isolate);
   virtual Code::Kind kind() const { return Code::STORE_IC; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class StoreFieldByIndexBits : public BitField<int, 0, 13> {};
   class RepresentationBits : public BitField<uint8_t, 13, 4> {};
 
-  DISALLOW_COPY_AND_ASSIGN(StoreFieldStub);
+  DEFINE_CODE_STUB(StoreField, HandlerStub);
 };
 
 
 class StoreGlobalStub : public HandlerStub {
  public:
   StoreGlobalStub(Isolate* isolate, bool is_constant, bool check_global)
       : HandlerStub(isolate) {
     set_sub_minor_key(IsConstantBits::encode(is_constant) |
                       CheckGlobalBits::encode(check_global));
   }
@@ skipping 32 matching lines @@
   Representation representation() {
     return Representation::FromKind(
         RepresentationBits::decode(sub_minor_key()));
   }
 
   void set_representation(Representation r) {
     set_sub_minor_key(RepresentationBits::update(sub_minor_key(), r.kind()));
   }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class IsConstantBits: public BitField<bool, 0, 1> {};
   class RepresentationBits: public BitField<Representation::Kind, 1, 8> {};
   class CheckGlobalBits: public BitField<bool, 9, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(StoreGlobalStub);
+  DEFINE_CODE_STUB(StoreGlobal, HandlerStub);
 };
 
 
 class CallApiFunctionStub : public PlatformCodeStub {
  public:
   CallApiFunctionStub(Isolate* isolate,
                       bool is_store,
                       bool call_data_undefined,
                       int argc) : PlatformCodeStub(isolate) {
     minor_key_ = IsStoreBits::encode(is_store) |
                  CallDataUndefinedBits::encode(call_data_undefined) |
                  ArgumentBits::encode(argc);
     DCHECK(!is_store || argc == 1);
   }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void Generate(MacroAssembler* masm) OVERRIDE;
 
   bool is_store() const { return IsStoreBits::decode(minor_key_); }
   bool call_data_undefined() const {
     return CallDataUndefinedBits::decode(minor_key_);
   }
   int argc() const { return ArgumentBits::decode(minor_key_); }
 
   class IsStoreBits: public BitField<bool, 0, 1> {};
   class CallDataUndefinedBits: public BitField<bool, 1, 1> {};
   class ArgumentBits: public BitField<int, 2, Code::kArgumentsBits> {};
   STATIC_ASSERT(Code::kArgumentsBits + 2 <= kStubMinorKeyBits);
 
-  DISALLOW_COPY_AND_ASSIGN(CallApiFunctionStub);
+  DEFINE_CODE_STUB(CallApiFunction, PlatformCodeStub);
 };
 
 
 class CallApiGetterStub : public PlatformCodeStub {
  public:
   explicit CallApiGetterStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
  private:
   virtual void Generate(MacroAssembler* masm) OVERRIDE;
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
 
-  DISALLOW_COPY_AND_ASSIGN(CallApiGetterStub);
+  DEFINE_CODE_STUB(CallApiGetter, PlatformCodeStub);
 };
 
 
 class BinaryOpICStub : public HydrogenCodeStub {
  public:
   BinaryOpICStub(Isolate* isolate, Token::Value op,
                  OverwriteMode mode = NO_OVERWRITE)
       : HydrogenCodeStub(isolate, UNINITIALIZED) {
     BinaryOpIC::State state(isolate, op, mode);
     set_sub_minor_key(state.GetExtraICState());
   }
 
-  explicit BinaryOpICStub(Isolate* isolate, const BinaryOpIC::State& state)
+  BinaryOpICStub(Isolate* isolate, const BinaryOpIC::State& state)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(state.GetExtraICState());
   }
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
@@ skipping 16 matching lines @@
     return BinaryOpIC::State(isolate(), GetExtraICState());
   }
 
   virtual void PrintState(OStream& os) const FINAL OVERRIDE;  // NOLINT
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLeft = 0;
   static const int kRight = 1;
 
  private:
-  virtual inline Major MajorKey() const OVERRIDE;
-
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpIC::State& state);
 
-  DISALLOW_COPY_AND_ASSIGN(BinaryOpICStub);
+  DEFINE_CODE_STUB(BinaryOpIC, HydrogenCodeStub);
 };
 
 
 // TODO(bmeurer): Merge this into the BinaryOpICStub once we have proper tail
 // call support for stubs in Hydrogen.
 class BinaryOpICWithAllocationSiteStub FINAL : public PlatformCodeStub {
  public:
   BinaryOpICWithAllocationSiteStub(Isolate* isolate,
                                    const BinaryOpIC::State& state)
       : PlatformCodeStub(isolate) {
@@ skipping 18 matching lines @@
 
   virtual ExtraICState GetExtraICState() const OVERRIDE {
     return static_cast<ExtraICState>(minor_key_);
   }
 
   virtual void Generate(MacroAssembler* masm) OVERRIDE;
 
   virtual void PrintState(OStream& os) const OVERRIDE;  // NOLINT
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   BinaryOpIC::State state() const {
     return BinaryOpIC::State(isolate(), static_cast<ExtraICState>(minor_key_));
   }
 
   static void GenerateAheadOfTime(Isolate* isolate,
                                   const BinaryOpIC::State& state);
 
-  DISALLOW_COPY_AND_ASSIGN(BinaryOpICWithAllocationSiteStub);
+  DEFINE_CODE_STUB(BinaryOpICWithAllocationSite, PlatformCodeStub);
 };
 
 
 class BinaryOpWithAllocationSiteStub FINAL : public BinaryOpICStub {
  public:
   BinaryOpWithAllocationSiteStub(Isolate* isolate,
                                  Token::Value op,
                                  OverwriteMode mode)
       : BinaryOpICStub(isolate, op, mode) {}
 
   BinaryOpWithAllocationSiteStub(Isolate* isolate,
                                  const BinaryOpIC::State& state)
       : BinaryOpICStub(isolate, state) {}
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const FINAL OVERRIDE {
     return Code::STUB;
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kAllocationSite = 0;
   static const int kLeft = 1;
   static const int kRight = 2;
+
+  DEFINE_CODE_STUB(BinaryOpWithAllocationSite, BinaryOpICStub);
 };
 
 
 enum StringAddFlags {
   // Omit both parameter checks.
   STRING_ADD_CHECK_NONE = 0,
   // Check left parameter.
   STRING_ADD_CHECK_LEFT = 1 << 0,
   // Check right parameter.
   STRING_ADD_CHECK_RIGHT = 1 << 1,
@@ skipping 24 matching lines @@
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLeft = 0;
   static const int kRight = 1;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class StringAddFlagsBits: public BitField<StringAddFlags, 0, 2> {};
   class PretenureFlagBits: public BitField<PretenureFlag, 2, 1> {};
 
   virtual void PrintBaseName(OStream& os) const OVERRIDE;  // NOLINT
 
-  DISALLOW_COPY_AND_ASSIGN(StringAddStub);
+  DEFINE_CODE_STUB(StringAdd, HydrogenCodeStub);
 };
 
 
 class CompareICStub : public PlatformCodeStub {
  public:
   CompareICStub(Isolate* isolate, Token::Value op, CompareIC::State left,
                 CompareIC::State right, CompareIC::State state)
       : PlatformCodeStub(isolate) {
     DCHECK(Token::IsCompareOp(op));
     minor_key_ = OpBits::encode(op - Token::EQ) | LeftStateBits::encode(left) |
                  RightStateBits::encode(right) | StateBits::encode(state);
   }
 
   virtual void Generate(MacroAssembler* masm);
 
   void set_known_map(Handle<Map> map) { known_map_ = map; }
 
-  explicit CompareICStub(uint32_t stub_key) : PlatformCodeStub(stub_key) {
-    DCHECK_EQ(MajorKeyFromKey(stub_key), MajorKey());
-  }
-
   virtual InlineCacheState GetICState() const;
 
   Token::Value op() const {
     return static_cast<Token::Value>(Token::EQ + OpBits::decode(minor_key_));
   }
 
   CompareIC::State left() const { return LeftStateBits::decode(minor_key_); }
   CompareIC::State right() const { return RightStateBits::decode(minor_key_); }
   CompareIC::State state() const { return StateBits::decode(minor_key_); }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual Code::Kind GetCodeKind() const { return Code::COMPARE_IC; }
 
   void GenerateSmis(MacroAssembler* masm);
   void GenerateNumbers(MacroAssembler* masm);
   void GenerateInternalizedStrings(MacroAssembler* masm);
   void GenerateStrings(MacroAssembler* masm);
   void GenerateUniqueNames(MacroAssembler* masm);
   void GenerateObjects(MacroAssembler* masm);
   void GenerateMiss(MacroAssembler* masm);
   void GenerateKnownObjects(MacroAssembler* masm);
   void GenerateGeneric(MacroAssembler* masm);
 
   bool strict() const { return op() == Token::EQ_STRICT; }
   Condition GetCondition() const { return CompareIC::ComputeCondition(op()); }
 
   virtual void AddToSpecialCache(Handle<Code> new_object);
   virtual bool FindCodeInSpecialCache(Code** code_out);
   virtual bool UseSpecialCache() { return state() == CompareIC::KNOWN_OBJECT; }
 
   class OpBits : public BitField<int, 0, 3> {};
   class LeftStateBits : public BitField<CompareIC::State, 3, 4> {};
   class RightStateBits : public BitField<CompareIC::State, 7, 4> {};
   class StateBits : public BitField<CompareIC::State, 11, 4> {};
 
   Handle<Map> known_map_;
 
-  DISALLOW_COPY_AND_ASSIGN(CompareICStub);
+  DEFINE_CODE_STUB(CompareIC, PlatformCodeStub);
 };
 
 
 class CompareNilICStub : public HydrogenCodeStub  {
  public:
   Type* GetType(Zone* zone, Handle<Map> map = Handle<Map>());
   Type* GetInputType(Zone* zone, Handle<Map> map);
 
   CompareNilICStub(Isolate* isolate, NilValue nil) : HydrogenCodeStub(isolate) {
     set_sub_minor_key(NilValueBits::encode(nil));
@@ skipping 49 matching lines @@
   virtual void PrintState(OStream& os) const OVERRIDE;     // NOLINT
   virtual void PrintBaseName(OStream& os) const OVERRIDE;  // NOLINT
 
  private:
   CompareNilICStub(Isolate* isolate, NilValue nil,
                    InitializationState init_state)
       : HydrogenCodeStub(isolate, init_state) {
     set_sub_minor_key(NilValueBits::encode(nil));
   }
 
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   enum CompareNilType {
     UNDEFINED,
     NULL_TYPE,
     MONOMORPHIC_MAP,
     GENERIC,
     NUMBER_OF_TYPES
   };
 
   // At most 6 different types can be distinguished, because the Code object
   // only has room for a single byte to hold a set and there are two more
   // boolean flags we need to store. :-P
   STATIC_ASSERT(NUMBER_OF_TYPES <= 6);
 
   class State : public EnumSet<CompareNilType, byte> {
    public:
     State() : EnumSet<CompareNilType, byte>(0) { }
     explicit State(byte bits) : EnumSet<CompareNilType, byte>(bits) { }
   };
   friend OStream& operator<<(OStream& os, const State& s);
 
   State state() const { return State(TypesBits::decode(sub_minor_key())); }
 
   class NilValueBits : public BitField<NilValue, 0, 1> {};
   class TypesBits : public BitField<byte, 1, NUMBER_OF_TYPES> {};
 
   friend class CompareNilIC;
 
-  DISALLOW_COPY_AND_ASSIGN(CompareNilICStub);
+  DEFINE_CODE_STUB(CompareNilIC, HydrogenCodeStub);
 };
 
 
 OStream& operator<<(OStream& os, const CompareNilICStub::State& s);
 
 
 class CEntryStub : public PlatformCodeStub {
  public:
   CEntryStub(Isolate* isolate, int result_size,
              SaveFPRegsMode save_doubles = kDontSaveFPRegs)
       : PlatformCodeStub(isolate) {
     minor_key_ = SaveDoublesBits::encode(save_doubles == kSaveFPRegs);
     DCHECK(result_size == 1 || result_size == 2);
 #ifdef _WIN64
     minor_key_ = ResultSizeBits::update(minor_key_, result_size);
 #endif  // _WIN64
   }
 
   void Generate(MacroAssembler* masm);
 
   // The version of this stub that doesn't save doubles is generated ahead of
   // time, so it's OK to call it from other stubs that can't cope with GC during
   // their code generation.  On machines that always have gp registers (x64) we
   // can generate both variants ahead of time.
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
 #ifdef _WIN64
   int result_size() const { return ResultSizeBits::decode(minor_key_); }
 #endif  // _WIN64
 
   bool NeedsImmovableCode();
 
   class SaveDoublesBits : public BitField<bool, 0, 1> {};
   class ResultSizeBits : public BitField<int, 1, 3> {};
 
-  DISALLOW_COPY_AND_ASSIGN(CEntryStub);
+  DEFINE_CODE_STUB(CEntry, PlatformCodeStub);
 };
 
 
 class JSEntryStub : public PlatformCodeStub {
  public:
   explicit JSEntryStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
   void Generate(MacroAssembler* masm) { GenerateBody(masm, false); }
 
  protected:
   void GenerateBody(MacroAssembler* masm, bool is_construct);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void FinishCode(Handle<Code> code);
 
   int handler_offset_;
 
-  DISALLOW_COPY_AND_ASSIGN(JSEntryStub);
+  DEFINE_CODE_STUB(JSEntry, PlatformCodeStub);
 };
 
 
 class JSConstructEntryStub : public JSEntryStub {
  public:
-  explicit JSConstructEntryStub(Isolate* isolate) : JSEntryStub(isolate) {
-    minor_key_ = 1;
-  }
+  explicit JSConstructEntryStub(Isolate* isolate) : JSEntryStub(isolate) {}
 
   void Generate(MacroAssembler* masm) { GenerateBody(masm, true); }
 
  private:
   virtual void PrintName(OStream& os) const OVERRIDE {  // NOLINT
     os << "JSConstructEntryStub";
   }
 
-  DISALLOW_COPY_AND_ASSIGN(JSConstructEntryStub);
+  DEFINE_CODE_STUB(JSConstructEntry, JSEntryStub);
 };
 
 
 class ArgumentsAccessStub: public PlatformCodeStub {
  public:
   enum Type {
     READ_ELEMENT,
     NEW_SLOPPY_FAST,
     NEW_SLOPPY_SLOW,
     NEW_STRICT
   };
 
   ArgumentsAccessStub(Isolate* isolate, Type type) : PlatformCodeStub(isolate) {
     minor_key_ = TypeBits::encode(type);
   }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   Type type() const { return TypeBits::decode(minor_key_); }
 
   void Generate(MacroAssembler* masm);
   void GenerateReadElement(MacroAssembler* masm);
   void GenerateNewStrict(MacroAssembler* masm);
   void GenerateNewSloppyFast(MacroAssembler* masm);
   void GenerateNewSloppySlow(MacroAssembler* masm);
 
   virtual void PrintName(OStream& os) const OVERRIDE;  // NOLINT
 
   class TypeBits : public BitField<Type, 0, 2> {};
 
-  DISALLOW_COPY_AND_ASSIGN(ArgumentsAccessStub);
+  DEFINE_CODE_STUB(ArgumentsAccess, PlatformCodeStub);
 };
 
 
 class RegExpExecStub: public PlatformCodeStub {
  public:
   explicit RegExpExecStub(Isolate* isolate) : PlatformCodeStub(isolate) { }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(RegExpExecStub);
+  DEFINE_CODE_STUB(RegExpExec, PlatformCodeStub);
 };
 
 
 class RegExpConstructResultStub FINAL : public HydrogenCodeStub {
  public:
   explicit RegExpConstructResultStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) { }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kLength = 0;
   static const int kIndex = 1;
   static const int kInput = 2;
 
- private:
-  DISALLOW_COPY_AND_ASSIGN(RegExpConstructResultStub);
+  DEFINE_CODE_STUB(RegExpConstructResult, HydrogenCodeStub);
 };
 
 
 class CallFunctionStub: public PlatformCodeStub {
  public:
   CallFunctionStub(Isolate* isolate, int argc, CallFunctionFlags flags)
       : PlatformCodeStub(isolate) {
     DCHECK(argc >= 0 && argc <= Code::kMaxArguments);
     minor_key_ = ArgcBits::encode(argc) | FlagBits::encode(flags);
   }
 
   void Generate(MacroAssembler* masm);
 
   static int ExtractArgcFromMinorKey(int minor_key) {
     return ArgcBits::decode(minor_key);
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   int argc() const { return ArgcBits::decode(minor_key_); }
   int flags() const { return FlagBits::decode(minor_key_); }
 
   bool CallAsMethod() const {
     return flags() == CALL_AS_METHOD || flags() == WRAP_AND_CALL;
   }
 
   bool NeedsChecks() const { return flags() != WRAP_AND_CALL; }
 
   virtual void PrintName(OStream& os) const 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, Code::kArgumentsBits> {};
   STATIC_ASSERT(Code::kArgumentsBits + 2 <= kStubMinorKeyBits);
 
-  DISALLOW_COPY_AND_ASSIGN(CallFunctionStub);
+  DEFINE_CODE_STUB(CallFunction, PlatformCodeStub);
 };
 
 
 class CallConstructStub: public PlatformCodeStub {
  public:
   CallConstructStub(Isolate* isolate, CallConstructorFlags flags)
       : PlatformCodeStub(isolate) {
     minor_key_ = FlagBits::encode(flags);
   }
 
   void Generate(MacroAssembler* masm);
 
   virtual void FinishCode(Handle<Code> code) {
     code->set_has_function_cache(RecordCallTarget());
   }
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   CallConstructorFlags flags() const { return FlagBits::decode(minor_key_); }
 
   bool RecordCallTarget() const {
     return (flags() & RECORD_CONSTRUCTOR_TARGET) != 0;
   }
 
   virtual void PrintName(OStream& os) const OVERRIDE;  // NOLINT
 
   class FlagBits : public BitField<CallConstructorFlags, 0, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(CallConstructStub);
+  DEFINE_CODE_STUB(CallConstruct, PlatformCodeStub);
 };
 
 
 enum StringIndexFlags {
   // Accepts smis or heap numbers.
   STRING_INDEX_IS_NUMBER,
 
   // Accepts smis or heap numbers that are valid array indices
   // (ECMA-262 15.4). Invalid indices are reported as being out of
   // range.
@@ skipping 167 matching lines @@
 class LoadDictionaryElementStub : public HydrogenCodeStub {
  public:
   explicit LoadDictionaryElementStub(Isolate* isolate)
       : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(LoadDictionaryElementStub);
+  DEFINE_CODE_STUB(LoadDictionaryElement, HydrogenCodeStub);
 };
 
 
 class KeyedLoadGenericStub : public HydrogenCodeStub {
  public:
   explicit KeyedLoadGenericStub(Isolate* isolate) : HydrogenCodeStub(isolate) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const { return Code::KEYED_LOAD_IC; }
   virtual InlineCacheState GetICState() const { return GENERIC; }
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(KeyedLoadGenericStub);
+  DEFINE_CODE_STUB(KeyedLoadGeneric, HydrogenCodeStub);
 };
 
 
 class LoadICTrampolineStub : public PlatformCodeStub {
  public:
   LoadICTrampolineStub(Isolate* isolate, const LoadIC::State& state)
       : PlatformCodeStub(isolate) {
     minor_key_ = state.GetExtraICState();
   }
 
   virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
 
   virtual InlineCacheState GetICState() const FINAL OVERRIDE {
     return GENERIC;
   }
 
   virtual ExtraICState GetExtraICState() const FINAL OVERRIDE {
     return static_cast<ExtraICState>(minor_key_);
   }
 
-  virtual inline Major MajorKey() const OVERRIDE;
-
  private:
   LoadIC::State state() const {
     return LoadIC::State(static_cast<ExtraICState>(minor_key_));
   }
 
   virtual void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(LoadICTrampolineStub);
+  DEFINE_CODE_STUB(LoadICTrampoline, PlatformCodeStub);
 };
 
 
 class KeyedLoadICTrampolineStub : public LoadICTrampolineStub {
  public:
   explicit KeyedLoadICTrampolineStub(Isolate* isolate)
       : LoadICTrampolineStub(isolate, LoadIC::State(0)) {}
 
   virtual Code::Kind GetCodeKind() const OVERRIDE {
     return Code::KEYED_LOAD_IC;
   }
 
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
  private:
   virtual void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(KeyedLoadICTrampolineStub);
+  DEFINE_CODE_STUB(KeyedLoadICTrampoline, LoadICTrampolineStub);
 };
 
 
 class VectorLoadStub : public HydrogenCodeStub {
  public:
   explicit VectorLoadStub(Isolate* isolate, const LoadIC::State& state)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(state.GetExtraICState());
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const OVERRIDE { return Code::LOAD_IC; }
 
   virtual InlineCacheState GetICState() const FINAL OVERRIDE {
     return GENERIC;
   }
 
   virtual ExtraICState GetExtraICState() const FINAL OVERRIDE {
     return static_cast<ExtraICState>(sub_minor_key());
   }
 
  private:
-  virtual inline Major MajorKey() const OVERRIDE;
-
   LoadIC::State state() const { return LoadIC::State(GetExtraICState()); }
 
-  DISALLOW_COPY_AND_ASSIGN(VectorLoadStub);
+  DEFINE_CODE_STUB(VectorLoad, HydrogenCodeStub);
 };
 
 
 class VectorKeyedLoadStub : public VectorLoadStub {
  public:
   explicit VectorKeyedLoadStub(Isolate* isolate)
       : VectorLoadStub(isolate, LoadIC::State(0)) {}
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual Code::Kind GetCodeKind() const OVERRIDE {
     return Code::KEYED_LOAD_IC;
   }
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(VectorKeyedLoadStub);
+  DEFINE_CODE_STUB(VectorKeyedLoad, VectorLoadStub);
 };
 
 
 class DoubleToIStub : public PlatformCodeStub {
  public:
   DoubleToIStub(Isolate* isolate, Register source, Register destination,
                 int offset, bool is_truncating, bool skip_fastpath = false)
       : PlatformCodeStub(isolate) {
     minor_key_ = SourceRegisterBits::encode(source.code()) |
                  DestinationRegisterBits::encode(destination.code()) |
                  OffsetBits::encode(offset) |
                  IsTruncatingBits::encode(is_truncating) |
                  SkipFastPathBits::encode(skip_fastpath) |
                  SSE3Bits::encode(CpuFeatures::IsSupported(SSE3) ? 1 : 0);
   }
 
   void Generate(MacroAssembler* masm);
 
   virtual bool SometimesSetsUpAFrame() { return false; }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   Register source() const {
     return Register::from_code(SourceRegisterBits::decode(minor_key_));
   }
   Register destination() const {
     return Register::from_code(DestinationRegisterBits::decode(minor_key_));
   }
   bool is_truncating() const { return IsTruncatingBits::decode(minor_key_); }
   bool skip_fastpath() const { return SkipFastPathBits::decode(minor_key_); }
   int offset() const { return OffsetBits::decode(minor_key_); }
 
   static const int kBitsPerRegisterNumber = 6;
   STATIC_ASSERT((1L << kBitsPerRegisterNumber) >= Register::kNumRegisters);
   class SourceRegisterBits:
       public BitField<int, 0, kBitsPerRegisterNumber> {};  // NOLINT
   class DestinationRegisterBits:
       public BitField<int, kBitsPerRegisterNumber,
         kBitsPerRegisterNumber> {};  // NOLINT
   class IsTruncatingBits:
       public BitField<bool, 2 * kBitsPerRegisterNumber, 1> {};  // NOLINT
   class OffsetBits:
       public BitField<int, 2 * kBitsPerRegisterNumber + 1, 3> {};  // NOLINT
   class SkipFastPathBits:
       public BitField<int, 2 * kBitsPerRegisterNumber + 4, 1> {};  // NOLINT
   class SSE3Bits:
       public BitField<int, 2 * kBitsPerRegisterNumber + 5, 1> {};  // NOLINT
 
-  DISALLOW_COPY_AND_ASSIGN(DoubleToIStub);
+  DEFINE_CODE_STUB(DoubleToI, PlatformCodeStub);
 };
 
 
 class LoadFastElementStub : public HydrogenCodeStub {
  public:
   LoadFastElementStub(Isolate* isolate, bool is_js_array,
                       ElementsKind elements_kind)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(ElementsKindBits::encode(elements_kind) |
                       IsJSArrayBits::encode(is_js_array));
   }
 
   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   static void InstallDescriptors(Isolate* isolate);
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 8, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(LoadFastElementStub);
+  DEFINE_CODE_STUB(LoadFastElement, HydrogenCodeStub);
 };
 
 
 class StoreFastElementStub : public HydrogenCodeStub {
  public:
   StoreFastElementStub(Isolate* isolate, bool is_js_array,
                        ElementsKind elements_kind, KeyedAccessStoreMode mode)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(ElementsKindBits::encode(elements_kind) |
                       IsJSArrayBits::encode(is_js_array) |
                       StoreModeBits::encode(mode));
   }
 
   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
   KeyedAccessStoreMode store_mode() const {
     return StoreModeBits::decode(sub_minor_key());
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class ElementsKindBits: public BitField<ElementsKind,      0, 8> {};
   class StoreModeBits: public BitField<KeyedAccessStoreMode, 8, 4> {};
   class IsJSArrayBits: public BitField<bool,                12, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(StoreFastElementStub);
+  DEFINE_CODE_STUB(StoreFastElement, HydrogenCodeStub);
 };
 
 
 class TransitionElementsKindStub : public HydrogenCodeStub {
  public:
   TransitionElementsKindStub(Isolate* isolate,
                              ElementsKind from_kind,
                              ElementsKind to_kind,
                              bool is_js_array) : HydrogenCodeStub(isolate) {
     set_sub_minor_key(FromKindBits::encode(from_kind) |
                       ToKindBits::encode(to_kind) |
                       IsJSArrayBits::encode(is_js_array));
   }
 
   ElementsKind from_kind() const {
     return FromKindBits::decode(sub_minor_key());
   }
 
   ElementsKind to_kind() const { return ToKindBits::decode(sub_minor_key()); }
 
   bool is_js_array() const { return IsJSArrayBits::decode(sub_minor_key()); }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class FromKindBits: public BitField<ElementsKind, 8, 8> {};
   class ToKindBits: public BitField<ElementsKind, 0, 8> {};
   class IsJSArrayBits: public BitField<bool, 16, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(TransitionElementsKindStub);
+  DEFINE_CODE_STUB(TransitionElementsKind, HydrogenCodeStub);
 };
 
 
 class ArrayConstructorStubBase : public HydrogenCodeStub {
  public:
   ArrayConstructorStubBase(Isolate* isolate,
                            ElementsKind kind,
                            AllocationSiteOverrideMode override_mode)
       : HydrogenCodeStub(isolate) {
     // It only makes sense to override local allocation site behavior
@@ skipping 24 matching lines @@
   OStream& BasePrintName(OStream& os, const char* name) const;  // NOLINT
 
  private:
   // Ensure data fits within available bits.
   STATIC_ASSERT(LAST_ALLOCATION_SITE_OVERRIDE_MODE == 1);
 
   class ElementsKindBits: public BitField<ElementsKind, 0, 8> {};
   class AllocationSiteOverrideModeBits: public
       BitField<AllocationSiteOverrideMode, 8, 1> {};  // NOLINT
 
-  DISALLOW_COPY_AND_ASSIGN(ArrayConstructorStubBase);
+  DEFINE_CODE_STUB_BASE(ArrayConstructorStubBase, HydrogenCodeStub);
 };
 
 
 class ArrayNoArgumentConstructorStub : public ArrayConstructorStubBase {
  public:
   ArrayNoArgumentConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void PrintName(OStream& os) const OVERRIDE {  // NOLINT
     BasePrintName(os, "ArrayNoArgumentConstructorStub");
   }
 
-  DISALLOW_COPY_AND_ASSIGN(ArrayNoArgumentConstructorStub);
+  DEFINE_CODE_STUB(ArrayNoArgumentConstructor, ArrayConstructorStubBase);
 };
 
 
 class ArraySingleArgumentConstructorStub : public ArrayConstructorStubBase {
  public:
   ArraySingleArgumentConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void PrintName(OStream& os) const {  // NOLINT
     BasePrintName(os, "ArraySingleArgumentConstructorStub");
   }
 
-  DISALLOW_COPY_AND_ASSIGN(ArraySingleArgumentConstructorStub);
+  DEFINE_CODE_STUB(ArraySingleArgumentConstructor, ArrayConstructorStubBase);
 };
 
 
 class ArrayNArgumentsConstructorStub : public ArrayConstructorStubBase {
  public:
   ArrayNArgumentsConstructorStub(
       Isolate* isolate,
       ElementsKind kind,
       AllocationSiteOverrideMode override_mode = DONT_OVERRIDE)
       : ArrayConstructorStubBase(isolate, kind, override_mode) {
   }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void PrintName(OStream& os) const {  // NOLINT
     BasePrintName(os, "ArrayNArgumentsConstructorStub");
   }
 
-  DISALLOW_COPY_AND_ASSIGN(ArrayNArgumentsConstructorStub);
+  DEFINE_CODE_STUB(ArrayNArgumentsConstructor, ArrayConstructorStubBase);
 };
 
 
 class InternalArrayConstructorStubBase : public HydrogenCodeStub {
  public:
   InternalArrayConstructorStubBase(Isolate* isolate, ElementsKind kind)
       : HydrogenCodeStub(isolate) {
     set_sub_minor_key(ElementsKindBits::encode(kind));
   }
 
   static void GenerateStubsAheadOfTime(Isolate* isolate);
   static void InstallDescriptors(Isolate* isolate);
 
   // Parameters accessed via CodeStubGraphBuilder::GetParameter()
   static const int kConstructor = 0;
 
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(sub_minor_key());
   }
 
  private:
   class ElementsKindBits : public BitField<ElementsKind, 0, 8> {};
 
-  DISALLOW_COPY_AND_ASSIGN(InternalArrayConstructorStubBase);
+  DEFINE_CODE_STUB_BASE(InternalArrayConstructorStubBase, HydrogenCodeStub);
 };
 
 
 class InternalArrayNoArgumentConstructorStub : public
     InternalArrayConstructorStubBase {
  public:
   InternalArrayNoArgumentConstructorStub(Isolate* isolate,
                                          ElementsKind kind)
       : InternalArrayConstructorStubBase(isolate, kind) { }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(InternalArrayNoArgumentConstructorStub);
+  DEFINE_CODE_STUB(InternalArrayNoArgumentConstructor,
+                   InternalArrayConstructorStubBase);
 };
 
 
 class InternalArraySingleArgumentConstructorStub : public
     InternalArrayConstructorStubBase {
  public:
   InternalArraySingleArgumentConstructorStub(Isolate* isolate,
                                              ElementsKind kind)
       : InternalArrayConstructorStubBase(isolate, kind) { }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(InternalArraySingleArgumentConstructorStub);
+  DEFINE_CODE_STUB(InternalArraySingleArgumentConstructor,
+                   InternalArrayConstructorStubBase);
 };
 
 
 class InternalArrayNArgumentsConstructorStub : public
     InternalArrayConstructorStubBase {
  public:
   InternalArrayNArgumentsConstructorStub(Isolate* isolate, ElementsKind kind)
       : InternalArrayConstructorStubBase(isolate, kind) { }
 
   virtual Handle<Code> GenerateCode() OVERRIDE;
 
   virtual void InitializeInterfaceDescriptor(
       CodeStubInterfaceDescriptor* descriptor) OVERRIDE;
 
- private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
-  DISALLOW_COPY_AND_ASSIGN(InternalArrayNArgumentsConstructorStub);
+  DEFINE_CODE_STUB(InternalArrayNArgumentsConstructor,
+                   InternalArrayConstructorStubBase);
 };
 
 
 class StoreElementStub : public PlatformCodeStub {
  public:
   StoreElementStub(Isolate* isolate, ElementsKind elements_kind)
       : PlatformCodeStub(isolate) {
     minor_key_ = ElementsKindBits::encode(elements_kind);
   }
 
   void Generate(MacroAssembler* masm);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   ElementsKind elements_kind() const {
     return ElementsKindBits::decode(minor_key_);
   }
 
   class ElementsKindBits : public BitField<ElementsKind, 0, 8> {};
 
-  DISALLOW_COPY_AND_ASSIGN(StoreElementStub);
+  DEFINE_CODE_STUB(StoreElement, PlatformCodeStub);
 };
 
 
 class ToBooleanStub: public HydrogenCodeStub {
  public:
   enum Type {
     UNDEFINED,
     BOOLEAN,
     NULL_TYPE,
     SMI,
@@ skipping 72 matching lines @@
       return MONOMORPHIC;
     }
   }
 
  private:
   ToBooleanStub(Isolate* isolate, InitializationState init_state)
       : HydrogenCodeStub(isolate, init_state) {
     set_sub_minor_key(ResultModeBits::encode(RESULT_AS_SMI));
   }
 
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class TypesBits : public BitField<byte, 0, NUMBER_OF_TYPES> {};
   class ResultModeBits : public BitField<ResultMode, NUMBER_OF_TYPES, 2> {};
 
-  DISALLOW_COPY_AND_ASSIGN(ToBooleanStub);
+  DEFINE_CODE_STUB(ToBoolean, HydrogenCodeStub);
 };
 
 
 OStream& operator<<(OStream& os, const ToBooleanStub::Types& t);
 
 
 class ElementsTransitionAndStoreStub : public HydrogenCodeStub {
  public:
   ElementsTransitionAndStoreStub(Isolate* isolate, ElementsKind from_kind,
                                  ElementsKind to_kind, bool is_jsarray,
@@ skipping 32 matching lines @@
     return ElementTransitionAndStoreDescriptor::MapRegister();
   }
   static const Register KeyRegister() {
     return ElementTransitionAndStoreDescriptor::NameRegister();
   }
   static const Register ObjectRegister() {
     return ElementTransitionAndStoreDescriptor::ReceiverRegister();
   }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   class FromBits : public BitField<ElementsKind, 0, 8> {};
   class ToBits : public BitField<ElementsKind, 8, 8> {};
   class IsJSArrayBits : public BitField<bool, 16, 1> {};
   class StoreModeBits : public BitField<KeyedAccessStoreMode, 17, 4> {};
 
-  DISALLOW_COPY_AND_ASSIGN(ElementsTransitionAndStoreStub);
+  DEFINE_CODE_STUB(ElementsTransitionAndStore, HydrogenCodeStub);
 };
 
 
 class StoreArrayLiteralElementStub : public PlatformCodeStub {
  public:
   explicit StoreArrayLiteralElementStub(Isolate* isolate)
       : PlatformCodeStub(isolate) { }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(StoreArrayLiteralElementStub);
+  DEFINE_CODE_STUB(StoreArrayLiteralElement, PlatformCodeStub);
 };
 
 
 class StubFailureTrampolineStub : public PlatformCodeStub {
  public:
   StubFailureTrampolineStub(Isolate* isolate, StubFunctionMode function_mode)
       : PlatformCodeStub(isolate) {
     minor_key_ = FunctionModeField::encode(function_mode);
   }
 
   static void GenerateAheadOfTime(Isolate* isolate);
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   StubFunctionMode function_mode() const {
     return FunctionModeField::decode(minor_key_);
   }
 
   void Generate(MacroAssembler* masm);
 
   class FunctionModeField : public BitField<StubFunctionMode, 0, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(StubFailureTrampolineStub);
+  DEFINE_CODE_STUB(StubFailureTrampoline, PlatformCodeStub);
 };
 
 
 class ProfileEntryHookStub : public PlatformCodeStub {
  public:
   explicit ProfileEntryHookStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
   // The profile entry hook function is not allowed to cause a GC.
   virtual bool SometimesSetsUpAFrame() { return false; }
 
   // Generates a call to the entry hook if it's enabled.
   static void MaybeCallEntryHook(MacroAssembler* masm);
 
  private:
   static void EntryHookTrampoline(intptr_t function,
                                   intptr_t stack_pointer,
                                   Isolate* isolate);
 
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(ProfileEntryHookStub);
+  DEFINE_CODE_STUB(ProfileEntryHook, PlatformCodeStub);
 };
 
 
 class StoreBufferOverflowStub : public PlatformCodeStub {
  public:
   StoreBufferOverflowStub(Isolate* isolate, SaveFPRegsMode save_fp)
       : PlatformCodeStub(isolate) {
     minor_key_ = SaveDoublesBits::encode(save_fp == kSaveFPRegs);
   }
 
   void Generate(MacroAssembler* masm);
 
   static void GenerateFixedRegStubsAheadOfTime(Isolate* isolate);
   virtual bool SometimesSetsUpAFrame() { return false; }
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   bool save_doubles() const { return SaveDoublesBits::decode(minor_key_); }
 
   class SaveDoublesBits : public BitField<bool, 0, 1> {};
 
-  DISALLOW_COPY_AND_ASSIGN(StoreBufferOverflowStub);
+  DEFINE_CODE_STUB(StoreBufferOverflow, PlatformCodeStub);
 };
 
 
 class SubStringStub : public PlatformCodeStub {
  public:
   explicit SubStringStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(SubStringStub);
+  DEFINE_CODE_STUB(SubString, PlatformCodeStub);
 };
 
 
 class StringCompareStub : public PlatformCodeStub {
  public:
   explicit StringCompareStub(Isolate* isolate) : PlatformCodeStub(isolate) {}
 
  private:
-  virtual inline Major MajorKey() const FINAL OVERRIDE;
-
   virtual void Generate(MacroAssembler* masm);
 
-  DISALLOW_COPY_AND_ASSIGN(StringCompareStub);
+  DEFINE_CODE_STUB(StringCompare, PlatformCodeStub);
 };
 
 
-#define DEFINE_MAJOR_KEY(NAME) \
-  CodeStub::Major NAME##Stub::MajorKey() const { return NAME; }
-
-CODE_STUB_LIST(DEFINE_MAJOR_KEY)
-
-#undef DEFINE_MAJOR_KEY
+#undef DEFINE_CODE_STUB
+#undef DEFINE_CODE_STUB_BASE
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_