Commit 1b03642b authored by plind44@gmail.com's avatar plind44@gmail.com

MIPS: Move NumberToStringStub::GenerateLookupNumberStringCache to the MacroAssembler.

Port r16806 (9f102a8)

Original commit message:
This renames the method to LookupNumberStringCache() and puts it into
the MacroAssembler in preparation of the NumberToStringStub Hydrogen
conversion.

BUG=
R=plind44@gmail.com

Review URL: https://codereview.chromium.org/23526072

Patch from Balazs Kilvady <kilvadyb@homejinni.com>.

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16839 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent e2fd02ac
......@@ -201,14 +201,12 @@ void Builtins::Generate_StringConstructCode(MacroAssembler* masm) {
Register argument = a2;
Label not_cached, argument_is_string;
NumberToStringStub::GenerateLookupNumberStringCache(
masm,
a0, // Input.
argument, // Result.
a3, // Scratch.
t0, // Scratch.
t1, // Scratch.
&not_cached);
__ LookupNumberStringCache(a0, // Input.
argument, // Result.
a3, // Scratch.
t0, // Scratch.
t1, // Scratch.
&not_cached);
__ IncrementCounter(counters->string_ctor_cached_number(), 1, a3, t0);
__ bind(&argument_is_string);
......
......@@ -994,97 +994,13 @@ static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,
}
void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
Register object,
Register result,
Register scratch1,
Register scratch2,
Register scratch3,
Label* not_found) {
// Use of registers. Register result is used as a temporary.
Register number_string_cache = result;
Register mask = scratch3;
// Load the number string cache.
__ LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
// Make the hash mask from the length of the number string cache. It
// contains two elements (number and string) for each cache entry.
__ lw(mask, FieldMemOperand(number_string_cache, FixedArray::kLengthOffset));
// Divide length by two (length is a smi).
__ sra(mask, mask, kSmiTagSize + 1);
__ Addu(mask, mask, -1); // Make mask.
// Calculate the entry in the number string cache. The hash value in the
// number string cache for smis is just the smi value, and the hash for
// doubles is the xor of the upper and lower words. See
// Heap::GetNumberStringCache.
Isolate* isolate = masm->isolate();
Label is_smi;
Label load_result_from_cache;
__ JumpIfSmi(object, &is_smi);
__ CheckMap(object,
scratch1,
Heap::kHeapNumberMapRootIndex,
not_found,
DONT_DO_SMI_CHECK);
STATIC_ASSERT(8 == kDoubleSize);
__ Addu(scratch1,
object,
Operand(HeapNumber::kValueOffset - kHeapObjectTag));
__ lw(scratch2, MemOperand(scratch1, kPointerSize));
__ lw(scratch1, MemOperand(scratch1, 0));
__ Xor(scratch1, scratch1, Operand(scratch2));
__ And(scratch1, scratch1, Operand(mask));
// Calculate address of entry in string cache: each entry consists
// of two pointer sized fields.
__ sll(scratch1, scratch1, kPointerSizeLog2 + 1);
__ Addu(scratch1, number_string_cache, scratch1);
Register probe = mask;
__ lw(probe,
FieldMemOperand(scratch1, FixedArray::kHeaderSize));
__ JumpIfSmi(probe, not_found);
__ ldc1(f12, FieldMemOperand(object, HeapNumber::kValueOffset));
__ ldc1(f14, FieldMemOperand(probe, HeapNumber::kValueOffset));
__ BranchF(&load_result_from_cache, NULL, eq, f12, f14);
__ Branch(not_found);
__ bind(&is_smi);
Register scratch = scratch1;
__ sra(scratch, object, 1); // Shift away the tag.
__ And(scratch, mask, Operand(scratch));
// Calculate address of entry in string cache: each entry consists
// of two pointer sized fields.
__ sll(scratch, scratch, kPointerSizeLog2 + 1);
__ Addu(scratch, number_string_cache, scratch);
// Check if the entry is the smi we are looking for.
__ lw(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
__ Branch(not_found, ne, object, Operand(probe));
// Get the result from the cache.
__ bind(&load_result_from_cache);
__ lw(result,
FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));
__ IncrementCounter(isolate->counters()->number_to_string_native(),
1,
scratch1,
scratch2);
}
void NumberToStringStub::Generate(MacroAssembler* masm) {
Label runtime;
__ lw(a1, MemOperand(sp, 0));
// Generate code to lookup number in the number string cache.
GenerateLookupNumberStringCache(masm, a1, v0, a2, a3, t0, &runtime);
__ LookupNumberStringCache(a1, v0, a2, a3, t0, &runtime);
__ DropAndRet(1);
__ bind(&runtime);
......@@ -5863,13 +5779,7 @@ void StringAddStub::GenerateConvertArgument(MacroAssembler* masm,
// Check the number to string cache.
__ bind(&not_string);
// Puts the cached result into scratch1.
NumberToStringStub::GenerateLookupNumberStringCache(masm,
arg,
scratch1,
scratch2,
scratch3,
scratch4,
slow);
__ LookupNumberStringCache(arg, scratch1, scratch2, scratch3, scratch4, slow);
__ mov(arg, scratch1);
__ sw(arg, MemOperand(sp, stack_offset));
__ bind(&done);
......
......@@ -272,19 +272,6 @@ class NumberToStringStub: public PlatformCodeStub {
public:
NumberToStringStub() { }
// Generate code to do a lookup in the number string cache. If the number in
// the register object is found in the cache the generated code falls through
// with the result in the result register. The object and the result register
// can be the same. If the number is not found in the cache the code jumps to
// the label not_found with only the content of register object unchanged.
static void GenerateLookupNumberStringCache(MacroAssembler* masm,
Register object,
Register result,
Register scratch1,
Register scratch2,
Register scratch3,
Label* not_found);
private:
Major MajorKey() { return NumberToString; }
int MinorKey() { return 0; }
......
......@@ -4945,6 +4945,86 @@ void MacroAssembler::JumpIfNotHeapNumber(Register object,
}
void MacroAssembler::LookupNumberStringCache(Register object,
Register result,
Register scratch1,
Register scratch2,
Register scratch3,
Label* not_found) {
// Use of registers. Register result is used as a temporary.
Register number_string_cache = result;
Register mask = scratch3;
// Load the number string cache.
LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
// Make the hash mask from the length of the number string cache. It
// contains two elements (number and string) for each cache entry.
lw(mask, FieldMemOperand(number_string_cache, FixedArray::kLengthOffset));
// Divide length by two (length is a smi).
sra(mask, mask, kSmiTagSize + 1);
Addu(mask, mask, -1); // Make mask.
// Calculate the entry in the number string cache. The hash value in the
// number string cache for smis is just the smi value, and the hash for
// doubles is the xor of the upper and lower words. See
// Heap::GetNumberStringCache.
Label is_smi;
Label load_result_from_cache;
JumpIfSmi(object, &is_smi);
CheckMap(object,
scratch1,
Heap::kHeapNumberMapRootIndex,
not_found,
DONT_DO_SMI_CHECK);
STATIC_ASSERT(8 == kDoubleSize);
Addu(scratch1,
object,
Operand(HeapNumber::kValueOffset - kHeapObjectTag));
lw(scratch2, MemOperand(scratch1, kPointerSize));
lw(scratch1, MemOperand(scratch1, 0));
Xor(scratch1, scratch1, Operand(scratch2));
And(scratch1, scratch1, Operand(mask));
// Calculate address of entry in string cache: each entry consists
// of two pointer sized fields.
sll(scratch1, scratch1, kPointerSizeLog2 + 1);
Addu(scratch1, number_string_cache, scratch1);
Register probe = mask;
lw(probe, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
JumpIfSmi(probe, not_found);
ldc1(f12, FieldMemOperand(object, HeapNumber::kValueOffset));
ldc1(f14, FieldMemOperand(probe, HeapNumber::kValueOffset));
BranchF(&load_result_from_cache, NULL, eq, f12, f14);
Branch(not_found);
bind(&is_smi);
Register scratch = scratch1;
sra(scratch, object, 1); // Shift away the tag.
And(scratch, mask, Operand(scratch));
// Calculate address of entry in string cache: each entry consists
// of two pointer sized fields.
sll(scratch, scratch, kPointerSizeLog2 + 1);
Addu(scratch, number_string_cache, scratch);
// Check if the entry is the smi we are looking for.
lw(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
Branch(not_found, ne, object, Operand(probe));
// Get the result from the cache.
bind(&load_result_from_cache);
lw(result, FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));
IncrementCounter(isolate()->counters()->number_to_string_native(),
1,
scratch1,
scratch2);
}
void MacroAssembler::JumpIfNonSmisNotBothSequentialAsciiStrings(
Register first,
Register second,
......
......@@ -1427,6 +1427,18 @@ class MacroAssembler: public Assembler {
// -------------------------------------------------------------------------
// String utilities.
// Generate code to do a lookup in the number string cache. If the number in
// the register object is found in the cache the generated code falls through
// with the result in the result register. The object and the result register
// can be the same. If the number is not found in the cache the code jumps to
// the label not_found with only the content of register object unchanged.
void LookupNumberStringCache(Register object,
Register result,
Register scratch1,
Register scratch2,
Register scratch3,
Label* not_found);
// Checks if both instance types are sequential ASCII strings and jumps to
// label if either is not.
void JumpIfBothInstanceTypesAreNotSequentialAscii(
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment