A64: Fix int32 use in Lithium string functions

src/a64/codegen-a64.cc

 // Copyright 2013 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 392 matching lines @@
     MacroAssembler::EmitCodeAgeSequence(&patcher, stub);
   }
 }
 
 
 void StringCharLoadGenerator::Generate(MacroAssembler* masm,
                                        Register string,
                                        Register index,
                                        Register result,
                                        Label* call_runtime) {
+  ASSERT(string.Is64Bits() && index.Is32Bits() && result.Is64Bits());
   // Fetch the instance type of the receiver into result register.
   __ Ldr(result, FieldMemOperand(string, HeapObject::kMapOffset));
   __ Ldrb(result, FieldMemOperand(result, Map::kInstanceTypeOffset));
 
   // We need special handling for indirect strings.
   Label check_sequential;
   __ TestAndBranchIfAllClear(result, kIsIndirectStringMask, &check_sequential);
 
   // Dispatch on the indirect string shape: slice or cons.
   Label cons_string;
   __ TestAndBranchIfAllClear(result, kSlicedNotConsMask, &cons_string);
 
   // Handle slices.
   Label indirect_string_loaded;
-  __ Ldrsw(result,
-           UntagSmiFieldMemOperand(string, SlicedString::kOffsetOffset));
+  __ Ldr(result.W(),
+         UntagSmiFieldMemOperand(string, SlicedString::kOffsetOffset));
   __ Ldr(string, FieldMemOperand(string, SlicedString::kParentOffset));
-  __ Add(index, index, result);
+  __ Add(index, index, result.W());
   __ B(&indirect_string_loaded);
 
   // Handle cons strings.
   // 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.
   __ Bind(&cons_string);
   __ Ldr(result, FieldMemOperand(string, ConsString::kSecondOffset));
   __ JumpIfNotRoot(result, Heap::kempty_stringRootIndex, call_runtime);
@@ skipping 31 matching lines @@
   // can be bound far away in deferred code.
   __ Tst(result, kShortExternalStringMask);
   __ B(ne, call_runtime);
   __ Ldr(string, FieldMemOperand(string, ExternalString::kResourceDataOffset));
 
   Label ascii, done;
   __ Bind(&check_encoding);
   STATIC_ASSERT(kTwoByteStringTag == 0);
   __ TestAndBranchIfAnySet(result, kStringEncodingMask, &ascii);
   // Two-byte string.
-  __ Ldrh(result, MemOperand(string, index, LSL, 1));
+  __ Ldrh(result, MemOperand(string, index, SXTW, 1));
   __ B(&done);
   __ Bind(&ascii);
   // Ascii string.
-  __ Ldrb(result, MemOperand(string, index));
+  __ Ldrb(result, MemOperand(string, index, SXTW));
   __ Bind(&done);
 }
 
 
 static MemOperand ExpConstant(Register base, int index) {
   return MemOperand(base, index * kDoubleSize);
 }
 
 
 void MathExpGenerator::EmitMathExp(MacroAssembler* masm,
@@ skipping 110 matching lines @@
   __ Fmul(result, double_temp3, double_temp1);
 
   __ Bind(&done);
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64