Eliminate special keyed load string stub in favor of uniform handlers.

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 21 matching lines @@
   V(CEntry)                                 \
   V(CompareIC)                              \
   V(DoubleToI)                              \
   V(FunctionPrototype)                      \
   V(Instanceof)                             \
   V(InternalArrayConstructor)               \
   V(JSEntry)                                \
   V(KeyedLoadICTrampoline)                  \
   V(LoadICTrampoline)                       \
   V(LoadIndexedInterceptor)                 \
+  V(LoadIndexedString)                      \
   V(MathPow)                                \
   V(ProfileEntryHook)                       \
   V(RecordWrite)                            \
   V(RegExpExec)                             \
   V(StoreArrayLiteralElement)               \
   V(StoreBufferOverflow)                    \
   V(StoreElement)                           \
   V(StringCompare)                          \
   V(StubFailureTrampoline)                  \
   V(SubString)                              \
@@ skipping 817 matching lines @@
       : PlatformCodeStub(isolate) {}
 
   virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
   virtual Code::StubType GetStubType() { return Code::FAST; }
 
   DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
   DEFINE_PLATFORM_CODE_STUB(LoadIndexedInterceptor, PlatformCodeStub);
 };
 
 
+class LoadIndexedStringStub : public PlatformCodeStub {
+ public:
+  explicit LoadIndexedStringStub(Isolate* isolate)
+      : PlatformCodeStub(isolate) {}
+
+  virtual Code::Kind GetCodeKind() const { return Code::HANDLER; }
+  virtual Code::StubType GetStubType() { return Code::FAST; }
+
+  DEFINE_CALL_INTERFACE_DESCRIPTOR(Load);
+  DEFINE_PLATFORM_CODE_STUB(LoadIndexedString, 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 InitializeDescriptor(CodeStubDescriptor* descriptor) OVERRIDE;
 
   virtual CallInterfaceDescriptor GetCallInterfaceDescriptor() OVERRIDE;
 
@@ skipping 755 matching lines @@
   // 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.
   STRING_INDEX_IS_ARRAY_INDEX
 };
 
 
+enum ReceiverCheckMode {
+  // We don't know anything about the receiver.
+  RECEIVER_IS_UNKNOWN,
+
+  // We know the receiver is a string.
+  RECEIVER_IS_STRING
+};
+
+
 // Generates code implementing String.prototype.charCodeAt.
 //
 // Only supports the case when the receiver is a string and the index
 // is a number (smi or heap number) that is a valid index into the
 // string. Additional index constraints are specified by the
 // flags. Otherwise, bails out to the provided labels.
 //
 // Register usage: |object| may be changed to another string in a way
 // that doesn't affect charCodeAt/charAt semantics, |index| is
 // preserved, |scratch| and |result| are clobbered.
 class StringCharCodeAtGenerator {
  public:
-  StringCharCodeAtGenerator(Register object,
-                            Register index,
-                            Register result,
-                            Label* receiver_not_string,
-                            Label* index_not_number,
+  StringCharCodeAtGenerator(Register object, Register index, Register result,
+                            Label* receiver_not_string, Label* index_not_number,
                             Label* index_out_of_range,
-                            StringIndexFlags index_flags)
+                            StringIndexFlags index_flags,
+                            ReceiverCheckMode check_mode = RECEIVER_IS_UNKNOWN)
       : object_(object),
         index_(index),
         result_(result),
         receiver_not_string_(receiver_not_string),
         index_not_number_(index_not_number),
         index_out_of_range_(index_out_of_range),
-        index_flags_(index_flags) {
+        index_flags_(index_flags),
+        check_mode_(check_mode) {
     DCHECK(!result_.is(object_));
     DCHECK(!result_.is(index_));
   }
 
   // Generates the fast case code. On the fallthrough path |result|
   // register contains the result.
   void GenerateFast(MacroAssembler* masm);
 
   // Generates the slow case code. Must not be naturally
   // reachable. Expected to be put after a ret instruction (e.g., in
@@ skipping 11 matching lines @@
  private:
   Register object_;
   Register index_;
   Register result_;
 
   Label* receiver_not_string_;
   Label* index_not_number_;
   Label* index_out_of_range_;
 
   StringIndexFlags index_flags_;
+  ReceiverCheckMode check_mode_;
 
   Label call_runtime_;
   Label index_not_smi_;
   Label got_smi_index_;
   Label exit_;
 
   DISALLOW_COPY_AND_ASSIGN(StringCharCodeAtGenerator);
 };
 
 
@@ skipping 39 matching lines @@
 // Only supports the case when the receiver is a string and the index
 // is a number (smi or heap number) that is a valid index into the
 // string. Additional index constraints are specified by the
 // flags. Otherwise, bails out to the provided labels.
 //
 // Register usage: |object| may be changed to another string in a way
 // that doesn't affect charCodeAt/charAt semantics, |index| is
 // preserved, |scratch1|, |scratch2|, and |result| are clobbered.
 class StringCharAtGenerator {
  public:
-  StringCharAtGenerator(Register object,
-                        Register index,
-                        Register scratch,
-                        Register result,
-                        Label* receiver_not_string,
-                        Label* index_not_number,
-                        Label* index_out_of_range,
-                        StringIndexFlags index_flags)
-      : char_code_at_generator_(object,
-                                index,
-                                scratch,
-                                receiver_not_string,
-                                index_not_number,
-                                index_out_of_range,
+  StringCharAtGenerator(Register object, Register index, Register scratch,
+                        Register result, Label* receiver_not_string,
+                        Label* index_not_number, Label* index_out_of_range,
+                        StringIndexFlags index_flags,
+                        ReceiverCheckMode check_mode = RECEIVER_IS_UNKNOWN)
+      : char_code_at_generator_(object, index, scratch, receiver_not_string,
+                                index_not_number, index_out_of_range,
                                 index_flags),
         char_from_code_generator_(scratch, result) {}
 
   // Generates the fast case code. On the fallthrough path |result|
   // register contains the result.
   void GenerateFast(MacroAssembler* masm) {
     char_code_at_generator_.GenerateFast(masm);
     char_from_code_generator_.GenerateFast(masm);
   }
 
@@ skipping 692 matching lines @@
 
 #undef DEFINE_CALL_INTERFACE_DESCRIPTOR
 #undef DEFINE_PLATFORM_CODE_STUB
 #undef DEFINE_HANDLER_CODE_STUB
 #undef DEFINE_HYDROGEN_CODE_STUB
 #undef DEFINE_CODE_STUB
 #undef DEFINE_CODE_STUB_BASE
 } }  // namespace v8::internal
 
 #endif  // V8_CODE_STUBS_H_