Load constants from the DescriptorArray

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 58 matching lines @@
   V(StoreArrayLiteralElement)               \
   V(StubFailureTrampoline)                  \
   V(ArrayConstructor)                       \
   V(InternalArrayConstructor)               \
   V(ProfileEntryHook)                       \
   V(StoreGlobal)                            \
   V(CallApiFunction)                        \
   V(CallApiGetter)                          \
   /* IC Handler stubs */                    \
   V(LoadField)                              \
+  V(LoadConstant)                           \
   V(StringLength)
 
 // List of code stubs only used on ARM 32 bits platforms.
 #if V8_TARGET_ARCH_ARM
 #define CODE_STUB_LIST_ARM(V)  \
   V(GetProperty)               \
   V(SetProperty)               \
   V(InvokeBuiltin)             \
   V(DirectCEntry)
 #else
@@ skipping 807 matching lines @@
   virtual int MinorKey() const { return 0; }
 };
 
 
 class HandlerStub : public HydrogenCodeStub {
  public:
   virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
   virtual ExtraICState GetExtraICState() const { return kind(); }
   virtual InlineCacheState GetICState() { return MONOMORPHIC; }
 
+  virtual void InitializeInterfaceDescriptor(
+      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
+
  protected:
   explicit HandlerStub(Isolate* isolate)
       : HydrogenCodeStub(isolate), bit_field_(0) {}
   virtual int NotMissMinorKey() const { return bit_field_; }
   virtual Code::Kind kind() const = 0;
   int bit_field_;
 };
 
 
 class LoadFieldStub: public HandlerStub {
  public:
   LoadFieldStub(Isolate* isolate, FieldIndex index)
     : HandlerStub(isolate), index_(index) {
     int property_index_key = index_.GetLoadFieldStubKey();
     bit_field_ = EncodedLoadFieldByIndexBits::encode(property_index_key);
   }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
-  virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
-
   Representation representation() {
     if (unboxed_double()) return Representation::Double();
     return Representation::Tagged();
   }
 
   FieldIndex index() const { return index_; }
   bool unboxed_double() { return index_.is_double(); }
 
  protected:
   explicit LoadFieldStub(Isolate* isolate);
   virtual Code::Kind kind() const { return Code::LOAD_IC; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
  private:
   class EncodedLoadFieldByIndexBits : public BitField<int, 0, 13> {};
   virtual CodeStub::Major MajorKey() const { return LoadField; }
   FieldIndex index_;
 };
 
 
+class LoadConstantStub : public HandlerStub {
+ public:
+  LoadConstantStub(Isolate* isolate, int descriptor) : HandlerStub(isolate) {
+    bit_field_ = descriptor;
+  }
+
+  virtual Handle<Code> GenerateCode() V8_OVERRIDE;
+
+  int descriptor() const { return bit_field_; }
+
+ protected:
+  explicit LoadConstantStub(Isolate* isolate);
+  virtual Code::Kind kind() const { return Code::LOAD_IC; }
+  virtual Code::StubType GetStubType() { return Code::FAST; }
+
+ private:
+  virtual CodeStub::Major MajorKey() const { return LoadConstant; }
+};
+
+
 class StringLengthStub: public HandlerStub {
  public:
   explicit StringLengthStub(Isolate* isolate) : HandlerStub(isolate) {}
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
-  virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
 
  protected:
   virtual Code::Kind kind() const { return Code::LOAD_IC; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
  private:
   virtual CodeStub::Major MajorKey() const { return StringLength; }
 };
 
 
@@ skipping 21 matching lines @@
       Code::FindAndReplacePattern pattern;
       pattern.Add(isolate()->factory()->global_property_cell_map(), cell);
       return CodeStub::GetCodeCopy(pattern);
     }
   }
 
   virtual Code::Kind kind() const { return Code::STORE_IC; }
 
   virtual Handle<Code> GenerateCode() V8_OVERRIDE;
 
-  virtual void InitializeInterfaceDescriptor(
-      CodeStubInterfaceDescriptor* descriptor) V8_OVERRIDE;
-
   bool is_constant() const {
     return IsConstantBits::decode(bit_field_);
   }
   bool check_global() const {
     return CheckGlobalBits::decode(bit_field_);
   }
   void set_is_constant(bool value) {
     bit_field_ = IsConstantBits::update(bit_field_, value);
   }
 
@@ skipping 1460 matching lines @@
 
 
 class CallDescriptors {
  public:
   static void InitializeForIsolate(Isolate* isolate);
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_