Port string keyed load IC improvements (r4444) to x64.

src/x64/codegen-x64.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 798 matching lines @@
     return runtime_operands_type_ != BinaryOpIC::STRINGS;
   }
 
   virtual int GetCodeKind() { return Code::BINARY_OP_IC; }
 
   virtual InlineCacheState GetICState() {
     return BinaryOpIC::ToState(runtime_operands_type_);
   }
 };
 
+class StringHelper : public AllStatic {
+ public:
+  // Generates fast code for getting a char code out of a string
+  // object at the given index. May bail out for four reasons (in the
+  // listed order):
+  //   * Receiver is not a string (receiver_not_string label).
+  //   * Index is not a smi (index_not_smi label).
+  //   * Index is out of range (index_out_of_range).
+  //   * Some other reason (slow_case label). In this case it's
+  //     guaranteed that the above conditions are not violated,
+  //     e.g. it's safe to assume the receiver is a string and the
+  //     index is a non-negative smi < length.
+  // When successful, object, index, and scratch are clobbered.
+  // Otherwise, scratch and result are clobbered.
+  static void GenerateFastCharCodeAt(MacroAssembler* masm,
+                                     Register object,
+                                     Register index,
+                                     Register scratch,
+                                     Register result,
+                                     Label* receiver_not_string,
+                                     Label* index_not_smi,
+                                     Label* index_out_of_range,
+                                     Label* slow_case);
 
-class StringStubBase: public CodeStub {
- public:
+  // Generates code for creating a one-char string from the given char
+  // code. May do a runtime call, so any register can be clobbered
+  // and, if the given invoke flag specifies a call, an internal frame
+  // is required. In tail call mode the result must be rax register.
+  static void GenerateCharFromCode(MacroAssembler* masm,
+                                   Register code,
+                                   Register result,
+                                   Register scratch,
+                                   InvokeFlag flag);
+
   // Generate code for copying characters using a simple loop. This should only
   // be used in places where the number of characters is small and the
   // additional setup and checking in GenerateCopyCharactersREP adds too much
   // overhead. Copying of overlapping regions is not supported.
-  void GenerateCopyCharacters(MacroAssembler* masm,
+  static void GenerateCopyCharacters(MacroAssembler* masm,
                               Register dest,
                               Register src,
                               Register count,
                               bool ascii);
 
   // Generate code for copying characters using the rep movs instruction.
   // Copies rcx characters from rsi to rdi. Copying of overlapping regions is
   // not supported.
-  void GenerateCopyCharactersREP(MacroAssembler* masm,
+  static void GenerateCopyCharactersREP(MacroAssembler* masm,
                                  Register dest,     // Must be rdi.
                                  Register src,      // Must be rsi.
                                  Register count,    // Must be rcx.
                                  bool ascii);
 
 
   // Probe the symbol table for a two character string. If the string is
   // not found by probing a jump to the label not_found is performed. This jump
   // does not guarantee that the string is not in the symbol table. If the
   // string is found the code falls through with the string in register rax.
-  void GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,
+  static void GenerateTwoCharacterSymbolTableProbe(MacroAssembler* masm,
                                             Register c1,
                                             Register c2,
                                             Register scratch1,
                                             Register scratch2,
                                             Register scratch3,
                                             Register scratch4,
                                             Label* not_found);
 
   // Generate string hash.
-  void GenerateHashInit(MacroAssembler* masm,
+  static void GenerateHashInit(MacroAssembler* masm,
                         Register hash,
                         Register character,
                         Register scratch);
-  void GenerateHashAddCharacter(MacroAssembler* masm,
+  static void GenerateHashAddCharacter(MacroAssembler* masm,
                                 Register hash,
                                 Register character,
                                 Register scratch);
-  void GenerateHashGetHash(MacroAssembler* masm,
+  static void GenerateHashGetHash(MacroAssembler* masm,
                            Register hash,
                            Register scratch);
+ private:
+  DISALLOW_IMPLICIT_CONSTRUCTORS(StringHelper);
 };
 
 
 // Flag that indicates how to generate code for the stub StringAddStub.
 enum StringAddFlags {
   NO_STRING_ADD_FLAGS = 0,
   NO_STRING_CHECK_IN_STUB = 1 << 0  // Omit string check in stub.
 };
 
 
-class StringAddStub: public StringStubBase {
+class StringAddStub: public CodeStub {
  public:
   explicit StringAddStub(StringAddFlags flags) {
     string_check_ = ((flags & NO_STRING_CHECK_IN_STUB) == 0);
   }
 
  private:
   Major MajorKey() { return StringAdd; }
   int MinorKey() { return string_check_ ? 0 : 1; }
 
   void Generate(MacroAssembler* masm);
 
   // Should the stub check whether arguments are strings?
   bool string_check_;
 };
 
 
-class SubStringStub: public StringStubBase {
+class SubStringStub: public CodeStub {
  public:
   SubStringStub() {}
 
  private:
   Major MajorKey() { return SubString; }
   int MinorKey() { return 0; }
 
   void Generate(MacroAssembler* masm);
 };
 
@@ skipping 53 matching lines @@
   void Print() {
     PrintF("NumberToStringStub\n");
   }
 #endif
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_CODEGEN_X64_H_