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

src/ia32/codegen-ia32.cc

 // 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 5932 matching lines @@
   // push.
   Label slow_case;
   Label exit;
   StringHelper::GenerateFastCharCodeAt(masm_,
                                        object.reg(),
                                        index.reg(),
                                        scratch.reg(),
                                        result.reg(),
                                        &slow_case,
                                        &slow_case,
+                                       &slow_case,
                                        &slow_case);
   __ jmp(&exit);
 
   __ bind(&slow_case);
   // Move the undefined value into the result register, which will
   // trigger the slow case.
   __ Set(result.reg(), Immediate(Factory::undefined_value()));
 
   __ bind(&exit);
   frame_->Push(&result);
@@ skipping 6081 matching lines @@
   return name_;
 }
 
 
 void StringHelper::GenerateFastCharCodeAt(MacroAssembler* masm,
                                           Register object,
                                           Register index,
                                           Register scratch,
                                           Register result,
                                           Label* receiver_not_string,
-                                          Label* index_not_positive_smi,
+                                          Label* index_not_smi,
+                                          Label* index_out_of_range,
                                           Label* slow_case) {
   Label not_a_flat_string;
   Label try_again_with_new_string;
   Label ascii_string;
   Label got_char_code;
 
   // If the receiver is a smi trigger the non-string case.
   ASSERT(kSmiTag == 0);
   __ test(object, Immediate(kSmiTagMask));
   __ j(zero, receiver_not_string);
 
   // Fetch the instance type of the receiver into result register.
   __ mov(result, FieldOperand(object, HeapObject::kMapOffset));
   __ movzx_b(result, FieldOperand(result, Map::kInstanceTypeOffset));
   // If the receiver is not a string trigger the non-string case.
   __ test(result, Immediate(kIsNotStringMask));
   __ j(not_zero, receiver_not_string);
 
-  // If the index is negative or non-smi trigger the non-positive-smi
-  // case.
+  // If the index is non-smi trigger the non-smi case.
   ASSERT(kSmiTag == 0);
-  __ test(index, Immediate(kSmiTagMask | kSmiSignMask));
-  __ j(not_zero, index_not_positive_smi);
+  __ test(index, Immediate(kSmiTagMask));
+  __ j(not_zero, index_not_smi);
 
   // Put untagged index into scratch register.
   __ mov(scratch, index);
   __ SmiUntag(scratch);
 
   // Check for index out of range.
   __ cmp(scratch, FieldOperand(object, String::kLengthOffset));
-  __ j(greater_equal, slow_case);
+  __ j(above_equal, index_out_of_range);
 
   __ bind(&try_again_with_new_string);
   // ----------- S t a t e -------------
   //  -- object  : string to access
   //  -- result  : instance type of the string
-  //  -- scratch : positive smi index < length
+  //  -- scratch : non-negative index < length
   // -----------------------------------
 
   // We need special handling for non-flat strings.
   ASSERT(kSeqStringTag == 0);
   __ test(result, Immediate(kStringRepresentationMask));
   __ j(not_zero, &not_a_flat_string);
 
   // Check for 1-byte or 2-byte string.
   ASSERT(kAsciiStringTag != 0);
   __ test(result, Immediate(kStringEncodingMask));
   __ j(not_zero, &ascii_string);
 
   // 2-byte string.
-  // Load the 2-byte character code into the temp register.
+  // Load the 2-byte character code into the result register.
   __ movzx_w(result, FieldOperand(object,
                                   scratch, times_2,
                                   SeqTwoByteString::kHeaderSize));
   __ jmp(&got_char_code);
 
   // Handle non-flat strings.
   __ bind(&not_a_flat_string);
   __ and_(result, kStringRepresentationMask);
   __ cmp(result, kConsStringTag);
   __ j(not_equal, slow_case);
 
   // ConsString.
   // Check whether the right hand side is the empty string (i.e. if
   // this is really a flat string in a cons string). If that is not
   // the case we would rather go to the runtime system now to flatten
   // the string.
   __ mov(result, FieldOperand(object, ConsString::kSecondOffset));
   __ cmp(Operand(result), Factory::empty_string());
   __ j(not_equal, slow_case);
   // Get the first of the two strings and load its instance type.
   __ mov(object, FieldOperand(object, ConsString::kFirstOffset));
   __ mov(result, FieldOperand(object, HeapObject::kMapOffset));
   __ movzx_b(result, FieldOperand(result, Map::kInstanceTypeOffset));
   __ jmp(&try_again_with_new_string);
 
   // ASCII string.
   __ bind(&ascii_string);
-  // Load the byte into the temp register.
+  // Load the byte into the result register.
   __ movzx_b(result, FieldOperand(object,
                                   scratch, times_1,
                                   SeqAsciiString::kHeaderSize));
   __ bind(&got_char_code);
   __ SmiTag(result);
 }
 
 
 void StringHelper::GenerateCharFromCode(MacroAssembler* masm,
                                         Register code,
@@ skipping 783 matching lines @@
 
   // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ bind(&runtime);
   __ TailCallRuntime(Runtime::kStringCompare, 2, 1);
 }
 
 #undef __
 
 } }  // namespace v8::internal