VectorICs: keyed element loads were kicking out non-smi keys unnecessarily

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 1759 matching lines @@
 
 enum ReceiverCheckMode {
   // We don't know anything about the receiver.
   RECEIVER_IS_UNKNOWN,
 
   // We know the receiver is a string.
   RECEIVER_IS_STRING
 };
 
 
+enum EmbedMode {
+  // The code being generated is part of an IC handler, which may MISS
+  // to an IC in failure cases.
+  PART_OF_IC_HANDLER,
+
+  NOT_PART_OF_IC_HANDLER
+};
+
+
 // 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.
@@ skipping 16 matching lines @@
     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
   // deferred code). Always jumps back to the fast case.
-  void GenerateSlow(MacroAssembler* masm,
+  void GenerateSlow(MacroAssembler* masm, EmbedMode embed_mode,
                     const RuntimeCallHelper& call_helper);
 
   // Skip handling slow case and directly jump to bailout.
   void SkipSlow(MacroAssembler* masm, Label* bailout) {
     masm->bind(&index_not_smi_);
     masm->bind(&call_runtime_);
     masm->jmp(bailout);
   }
 
  private:
@@ skipping 79 matching lines @@
   // 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);
   }
 
   // Generates the slow case code. Must not be naturally
   // reachable. Expected to be put after a ret instruction (e.g., in
   // deferred code). Always jumps back to the fast case.
-  void GenerateSlow(MacroAssembler* masm,
+  void GenerateSlow(MacroAssembler* masm, EmbedMode embed_mode,
                     const RuntimeCallHelper& call_helper) {
-    char_code_at_generator_.GenerateSlow(masm, call_helper);
+    char_code_at_generator_.GenerateSlow(masm, embed_mode, call_helper);
     char_from_code_generator_.GenerateSlow(masm, call_helper);
   }
 
   // Skip handling slow case and directly jump to bailout.
   void SkipSlow(MacroAssembler* masm, Label* bailout) {
     char_code_at_generator_.SkipSlow(masm, bailout);
     char_from_code_generator_.SkipSlow(masm, bailout);
   }
 
  private:
@@ skipping 814 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_