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

src/ia32/ic-ia32.cc

 // Copyright 2006-2008 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 478 matching lines @@
 }
 
 
 void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax    : key (index)
   //  -- edx    : receiver
   //  -- esp[0] : return address
   // -----------------------------------
   Label miss;
-  Label not_positive_smi;
+  Label index_not_smi;
+  Label index_out_of_range;
   Label slow_char_code;
   Label got_char_code;
 
   Register receiver = edx;
   Register index = eax;
   Register code = ebx;
   Register scratch = ecx;
 
   StringHelper::GenerateFastCharCodeAt(masm,
                                        receiver,
                                        index,
                                        scratch,
                                        code,
                                        &miss,  // When not a string.
-                                       &not_positive_smi,
+                                       &index_not_smi,
+                                       &index_out_of_range,
                                        &slow_char_code);
   // If we didn't bail out, code register contains smi tagged char
   // code.
   __ bind(&got_char_code);
   StringHelper::GenerateCharFromCode(masm, code, eax, JUMP_FUNCTION);
 #ifdef DEBUG
   __ Abort("Unexpected fall-through from char from code tail call");
 #endif
 
-  // Check if key is a smi or a heap number.
-  __ bind(&not_positive_smi);
-  ASSERT(kSmiTag == 0);
-  __ test(index, Immediate(kSmiTagMask));
-  __ j(zero, &slow_char_code);
-  __ mov(ecx, FieldOperand(eax, HeapObject::kMapOffset));
-  __ cmp(ecx, Factory::heap_number_map());
-  __ j(not_equal, &miss);
+  // Check if key is a heap number.
+  __ bind(&index_not_smi);
+  __ CheckMap(index, Factory::heap_number_map(), &miss, true);
 
   // Push receiver and key on the stack (now that we know they are a
   // string and a number), and call runtime.
   __ bind(&slow_char_code);
   __ EnterInternalFrame();
   __ push(receiver);
   __ push(index);
   __ CallRuntime(Runtime::kStringCharCodeAt, 2);
   ASSERT(!code.is(eax));
   __ mov(code, eax);
   __ LeaveInternalFrame();
 
   // Check if the runtime call returned NaN char code. If yes, return
   // undefined. Otherwise, we can continue.
   if (FLAG_debug_code) {
     ASSERT(kSmiTag == 0);
     __ test(code, Immediate(kSmiTagMask));
     __ j(zero, &got_char_code);
     __ mov(scratch, FieldOperand(code, HeapObject::kMapOffset));
     __ cmp(scratch, Factory::heap_number_map());
     __ Assert(equal, "StringCharCodeAt must return smi or heap number");
   }
   __ cmp(code, Factory::nan_value());
   __ j(not_equal, &got_char_code);
+  __ bind(&index_out_of_range);
   __ Set(eax, Immediate(Factory::undefined_value()));
   __ ret(0);
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 
 void KeyedLoadIC::GenerateExternalArray(MacroAssembler* masm,
                                         ExternalArrayType array_type) {
@@ skipping 1072 matching lines @@
 
   // Do tail-call to runtime routine.
   ExternalReference ref = ExternalReference(IC_Utility(kKeyedStoreIC_Miss));
   __ TailCallExternalReference(ref, 3, 1);
 }
 
 #undef __
 
 
 } }  // namespace v8::internal