Skip to content

V
V8
Commit f1441384 authored by ishell's avatar ishell Committed by Commit bot
Browse files
Options

[stubs] Remove CSA::INTEGER_PARAMETERS in favor of CSA::INTPTR_PARAMETERS. 

BUG=

Review-Url: https://codereview.chromium.org/2580533002
Cr-Commit-Position: refs/heads/master@{#41722}
parent 18053154
Hide whitespace changes
Inline Side-by-side
Showing with 183 additions and 262 deletions
src/builtins/builtins-array.cc
View file @ f1441384
......@@ -1570,8 +1570,8 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.WordEqual(element_k, search_element),
&return_true);
......@@ -1584,8 +1584,8 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.WordEqual(element_k, undefined), &return_true);
assembler.GotoIf(assembler.WordEqual(element_k, the_hole), &return_true);
......@@ -1606,9 +1606,8 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoUnless(assembler.TaggedIsSmi(element_k), &not_smi);
assembler.Branch(
assembler.Float64Equal(search_num.value(),
......@@ -1635,9 +1634,8 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
assembler.GotoUnless(
assembler.IsHeapNumberMap(assembler.LoadMap(element_k)),
......@@ -1657,8 +1655,8 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
assembler.GotoUnless(
assembler.IsStringInstanceType(assembler.LoadInstanceType(element_k)),
......@@ -1689,8 +1687,8 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
Node* map_k = assembler.LoadMap(element_k);
......@@ -1732,8 +1730,7 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedDoubleArrayElement(
elements, index_var.value(), MachineType::Float64(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
elements, index_var.value(), MachineType::Float64());
assembler.Branch(assembler.Float64Equal(element_k, search_num.value()),
&return_true, &continue_loop);
assembler.Bind(&continue_loop);
......@@ -1749,8 +1746,7 @@ void Builtins::Generate_ArrayIncludes(compiler::CodeAssemblerState* state) {
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_false);
Node* element_k = assembler.LoadFixedDoubleArrayElement(
elements, index_var.value(), MachineType::Float64(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
elements, index_var.value(), MachineType::Float64());
assembler.BranchIfFloat64IsNaN(element_k, &return_true, &continue_loop);
assembler.Bind(&continue_loop);
index_var.Bind(assembler.IntPtrAdd(index_var.value(), intptr_one));
......@@ -2011,8 +2007,8 @@ void Builtins::Generate_ArrayIndexOf(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_not_found);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.WordEqual(element_k, search_element),
&return_found);
......@@ -2025,8 +2021,8 @@ void Builtins::Generate_ArrayIndexOf(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_not_found);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.WordEqual(element_k, undefined),
&return_found);
......@@ -2046,9 +2042,8 @@ void Builtins::Generate_ArrayIndexOf(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_not_found);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoUnless(assembler.TaggedIsSmi(element_k), &not_smi);
assembler.Branch(
assembler.Float64Equal(search_num.value(),
......@@ -2076,8 +2071,8 @@ void Builtins::Generate_ArrayIndexOf(compiler::CodeAssemblerState* state) {
assembler.GotoUnless(
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_not_found);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
assembler.GotoUnless(
assembler.IsStringInstanceType(assembler.LoadInstanceType(element_k)),
......@@ -2108,8 +2103,8 @@ void Builtins::Generate_ArrayIndexOf(compiler::CodeAssemblerState* state) {
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_not_found);
Node* element_k = assembler.LoadFixedArrayElement(
elements, index_var.value(), 0, CodeStubAssembler::INTPTR_PARAMETERS);
Node* element_k =
assembler.LoadFixedArrayElement(elements, index_var.value());
assembler.GotoIf(assembler.TaggedIsSmi(element_k), &continue_loop);
Node* map_k = assembler.LoadMap(element_k);
......@@ -2149,8 +2144,7 @@ void Builtins::Generate_ArrayIndexOf(compiler::CodeAssemblerState* state) {
assembler.UintPtrLessThan(index_var.value(), len_var.value()),
&return_not_found);
Node* element_k = assembler.LoadFixedDoubleArrayElement(
elements, index_var.value(), MachineType::Float64(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
elements, index_var.value(), MachineType::Float64());
assembler.Branch(assembler.Float64Equal(element_k, search_num.value()),
&return_found, &continue_loop);
assembler.Bind(&continue_loop);
......@@ -2709,8 +2703,8 @@ void Builtins::Generate_ArrayIteratorPrototypeNext(
assembler.Int32Constant(LAST_ARRAY_KEY_VALUE_ITERATOR_TYPE)),
&allocate_iterator_result);
Node* elements =
assembler.AllocateFixedArray(FAST_ELEMENTS, assembler.Int32Constant(2));
Node* elements = assembler.AllocateFixedArray(FAST_ELEMENTS,
assembler.IntPtrConstant(2));
assembler.StoreFixedArrayElement(elements, 0, index, SKIP_WRITE_BARRIER);
assembler.StoreFixedArrayElement(elements, 1, var_value.value(),
SKIP_WRITE_BARRIER);
......
src/builtins/builtins-conversion.cc
View file @ f1441384
......@@ -452,8 +452,7 @@ void Builtins::Generate_ToObject(compiler::CodeAssemblerState* state) {
assembler.Bind(&if_wrapjsvalue);
Node* native_context = assembler.LoadNativeContext(context);
Node* constructor = assembler.LoadFixedArrayElement(
native_context, constructor_function_index_var.value(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
native_context, constructor_function_index_var.value());
Node* initial_map = assembler.LoadObjectField(
constructor, JSFunction::kPrototypeOrInitialMapOffset);
Node* js_value = assembler.Allocate(JSValue::kSize);
......
src/builtins/builtins-function.cc
View file @ f1441384
......@@ -371,16 +371,13 @@ void Builtins::Generate_FastFunctionPrototypeBind(
&empty_arguments);
Node* elements_length = assembler.ChangeUint32ToWord(
assembler.Int32Sub(argc, assembler.Int32Constant(1)));
Node* elements = assembler.AllocateFixedArray(
FAST_ELEMENTS, elements_length, CodeStubAssembler::INTPTR_PARAMETERS);
Node* elements = assembler.AllocateFixedArray(FAST_ELEMENTS, elements_length);
Variable index(&assembler, MachineType::PointerRepresentation());
index.Bind(assembler.IntPtrConstant(0));
CodeStubAssembler::VariableList foreach_vars({&index}, assembler.zone());
args.ForEach(foreach_vars,
[&assembler, elements, &index](compiler::Node* arg) {
assembler.StoreFixedArrayElement(
elements, index.value(), arg, UPDATE_WRITE_BARRIER, 0,
CodeStubAssembler::INTPTR_PARAMETERS);
assembler.StoreFixedArrayElement(elements, index.value(), arg);
assembler.Increment(index);
},
assembler.IntPtrConstant(1));
......
src/builtins/builtins-internal.cc
View file @ f1441384
......@@ -173,8 +173,7 @@ void Generate_NewArgumentsElements(CodeStubAssembler* assembler,
assembler->Bind(&if_notempty);
{
// Allocate a FixedArray in new space.
Node* result = assembler->AllocateFixedArray(
kind, length, CodeStubAssembler::INTPTR_PARAMETERS);
Node* result = assembler->AllocateFixedArray(kind, length);
// Compute the effective {offset} into the {frame}.
Node* offset = assembler->IntPtrAdd(length, assembler->IntPtrConstant(1));
......@@ -200,8 +199,7 @@ void Generate_NewArgumentsElements(CodeStubAssembler* assembler,
// Store the {value} into the {result}.
assembler->StoreFixedArrayElement(result, index, value,
SKIP_WRITE_BARRIER, 0,
CodeStubAssembler::INTPTR_PARAMETERS);
SKIP_WRITE_BARRIER);
// Continue with next {index}.
var_index.Bind(
......
src/builtins/builtins-promise.cc
View file @ f1441384
......@@ -453,19 +453,19 @@ compiler::Node* InternalPerformPromiseThen(CodeStubAssembler* a,
// Create new FixedArrays to store callbacks, and migrate
// existing callbacks.
Node* const deferreds =
a->AllocateFixedArray(FAST_ELEMENTS, a->Int32Constant(2));
a->AllocateFixedArray(FAST_ELEMENTS, a->IntPtrConstant(2));
a->StoreFixedArrayElement(deferreds, 0, existing_deferred);
a->StoreFixedArrayElement(deferreds, 1, deferred);
Node* const fulfill_reactions =
a->AllocateFixedArray(FAST_ELEMENTS, a->Int32Constant(2));
a->AllocateFixedArray(FAST_ELEMENTS, a->IntPtrConstant(2));
a->StoreFixedArrayElement(
fulfill_reactions, 0,
a->LoadObjectField(promise, JSPromise::kFulfillReactionsOffset));
a->StoreFixedArrayElement(fulfill_reactions, 1, var_on_resolve.value());
Node* const reject_reactions =
a->AllocateFixedArray(FAST_ELEMENTS, a->Int32Constant(2));
a->AllocateFixedArray(FAST_ELEMENTS, a->IntPtrConstant(2));
a->StoreFixedArrayElement(
reject_reactions, 0,
a->LoadObjectField(promise, JSPromise::kRejectReactionsOffset));
......
src/builtins/builtins-regexp.cc
View file @ f1441384
......@@ -183,19 +183,16 @@ Node* RegExpBuiltinsAssembler::ConstructNewResultFromMatchInfo(Node* context,
{
Node* const from_cursor = var_from_cursor.value();
Node* const to_cursor = var_to_cursor.value();
Node* const start =
LoadFixedArrayElement(match_info, from_cursor, 0, INTPTR_PARAMETERS);
Node* const start = LoadFixedArrayElement(match_info, from_cursor);
Label next_iter(this);
GotoIf(SmiEqual(start, SmiConstant(Smi::FromInt(-1))), &next_iter);
Node* const from_cursor_plus1 = IntPtrAdd(from_cursor, IntPtrConstant(1));
Node* const end = LoadFixedArrayElement(match_info, from_cursor_plus1, 0,
INTPTR_PARAMETERS);
Node* const end = LoadFixedArrayElement(match_info, from_cursor_plus1);
Node* const capture = SubString(context, string, start, end);
StoreFixedArrayElement(result_elements, to_cursor, capture,
UPDATE_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
StoreFixedArrayElement(result_elements, to_cursor, capture);
Goto(&next_iter);
Bind(&next_iter);
......@@ -1374,9 +1371,6 @@ class GrowableFixedArray {
void Push(Node* const value) {
CodeStubAssembler* a = assembler_;
const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
Node* const length = var_length_.value();
Node* const capacity = var_capacity_.value();
......@@ -1386,7 +1380,7 @@ class GrowableFixedArray {
a->Bind(&grow);
{
Node* const new_capacity = NewCapacity(a, capacity);
Node* const new_array = ResizeFixedArray(length, new_capacity, mode);
Node* const new_array = ResizeFixedArray(length, new_capacity);
var_capacity_.Bind(new_capacity);
var_array_.Bind(new_array);
......@@ -1396,7 +1390,7 @@ class GrowableFixedArray {
a->Bind(&store);
{
Node* const array = var_array_.value();
a->StoreFixedArrayElement(array, length, value, barrier_mode, 0, mode);
a->StoreFixedArrayElement(array, length, value);
Node* const new_length = a->IntPtrAdd(length, a->IntPtrConstant(1));
var_length_.Bind(new_length);
......@@ -1407,7 +1401,6 @@ class GrowableFixedArray {
CodeStubAssembler* a = assembler_;
const ElementsKind kind = FAST_ELEMENTS;
const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
Node* const native_context = a->LoadNativeContext(context);
Node* const array_map = a->LoadJSArrayElementsMap(kind, native_context);
......@@ -1421,7 +1414,7 @@ class GrowableFixedArray {
a->GotoIf(a->WordEqual(length, capacity), &next);
Node* const array = ResizeFixedArray(length, length, mode);
Node* const array = ResizeFixedArray(length, length);
var_array_.Bind(array);
var_capacity_.Bind(length);
a->Goto(&next);
......@@ -1445,14 +1438,13 @@ class GrowableFixedArray {
CodeStubAssembler* a = assembler_;
const ElementsKind kind = FAST_ELEMENTS;
const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
static const int kInitialArraySize = 8;
Node* const capacity = a->IntPtrConstant(kInitialArraySize);
Node* const array = a->AllocateFixedArray(kind, capacity, mode);
Node* const array = a->AllocateFixedArray(kind, capacity);
a->FillFixedArrayWithValue(kind, array, a->IntPtrConstant(0), capacity,
Heap::kTheHoleValueRootIndex, mode);
Heap::kTheHoleValueRootIndex);
var_array_.Bind(array);
var_capacity_.Bind(capacity);
......@@ -1474,10 +1466,7 @@ class GrowableFixedArray {
// Creates a new array with {new_capacity} and copies the first
// {element_count} elements from the current array.
Node* ResizeFixedArray(Node* const element_count, Node* const new_capacity,
ParameterMode mode) {
DCHECK(mode == CodeStubAssembler::INTPTR_PARAMETERS);
Node* ResizeFixedArray(Node* const element_count, Node* const new_capacity) {
CodeStubAssembler* a = assembler_;
CSA_ASSERT(a, a->IntPtrGreaterThan(element_count, a->IntPtrConstant(0)));
......@@ -1486,6 +1475,7 @@ class GrowableFixedArray {
const ElementsKind kind = FAST_ELEMENTS;
const WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER;
const ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
const CodeStubAssembler::AllocationFlags flags =
CodeStubAssembler::kAllowLargeObjectAllocation;
......@@ -2202,8 +2192,7 @@ Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
Node* const i = var_i.value();
GotoUnless(IntPtrLessThan(i, end), &create_result);
ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
Node* const elem = LoadFixedArrayElement(res_elems, i, 0, mode);
Node* const elem = LoadFixedArrayElement(res_elems, i);
Label if_issmi(this), if_isstring(this), loop_epilogue(this);
Branch(TaggedIsSmi(elem), &if_issmi, &if_isstring);
......@@ -2230,8 +2219,7 @@ Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
Node* const next_i = IntPtrAdd(i, int_one);
var_i.Bind(next_i);
Node* const next_elem =
LoadFixedArrayElement(res_elems, next_i, 0, mode);
Node* const next_elem = LoadFixedArrayElement(res_elems, next_i);
Node* const new_match_start = SmiSub(next_elem, elem);
var_match_start.Bind(new_match_start);
......@@ -2249,8 +2237,7 @@ Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
var_match_start.value(), string);
Node* const replacement_str = ToString(context, replacement_obj);
StoreFixedArrayElement(res_elems, i, replacement_str,
UPDATE_WRITE_BARRIER, 0, mode);
StoreFixedArrayElement(res_elems, i, replacement_str);
Node* const elem_length = LoadStringLength(elem);
Node* const new_match_start =
......@@ -2270,8 +2257,6 @@ Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
Bind(&if_hasexplicitcaptures);
{
ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
Node* const from = int_zero;
Node* const to = SmiUntag(res_length);
const int increment = 1;
......@@ -2279,8 +2264,8 @@ Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
BuildFastLoop(
MachineType::PointerRepresentation(), from, to,
[this, res_elems, isolate, native_context, context, undefined,
replace_callable, mode](Node* index) {
Node* const elem = LoadFixedArrayElement(res_elems, index, 0, mode);
replace_callable](Node* index) {
Node* const elem = LoadFixedArrayElement(res_elems, index);
Label do_continue(this);
GotoIf(TaggedIsSmi(elem), &do_continue);
......@@ -2303,8 +2288,7 @@ Node* RegExpBuiltinsAssembler::ReplaceGlobalCallableFastPath(
// back from the callback function.
Node* const replacement_str = ToString(context, replacement_obj);
StoreFixedArrayElement(res_elems, index, replacement_str,
UPDATE_WRITE_BARRIER, 0, mode);
StoreFixedArrayElement(res_elems, index, replacement_str);
Goto(&do_continue);
Bind(&do_continue);
......
src/code-stub-assembler.cc
View file @ f1441384
......@@ -158,11 +158,9 @@ Node* CodeStubAssembler::StaleRegisterConstant() {
Node* CodeStubAssembler::IntPtrOrSmiConstant(int value, ParameterMode mode) {
if (mode == SMI_PARAMETERS) {
return SmiConstant(Smi::FromInt(value));
} else if (mode == INTPTR_PARAMETERS) {
return IntPtrConstant(value);
} else {
DCHECK_EQ(INTEGER_PARAMETERS, mode);
return Int32Constant(value);
DCHECK_EQ(INTPTR_PARAMETERS, mode);
return IntPtrConstant(value);
}
}
......@@ -1864,15 +1862,13 @@ Node* CodeStubAssembler::AllocateRegExpResult(Node* context, Node* length,
Node* const zero = IntPtrConstant(0);
Node* const length_intptr = SmiUntag(length);
const ElementsKind elements_kind = FAST_ELEMENTS;
const ParameterMode parameter_mode = INTPTR_PARAMETERS;
Node* const elements =
AllocateFixedArray(elements_kind, length_intptr, parameter_mode);
Node* const elements = AllocateFixedArray(elements_kind, length_intptr);
StoreObjectField(result, JSArray::kElementsOffset, elements);
// Fill in the elements with undefined.
FillFixedArrayWithValue(elements_kind, elements, zero, length_intptr,
Heap::kUndefinedValueRootIndex, parameter_mode);
Heap::kUndefinedValueRootIndex);
return result;
}
......@@ -3182,12 +3178,13 @@ Node* CodeStubAssembler::StringFromCharCode(Node* code) {
{
// Load the isolate wide single character string cache.
Node* cache = LoadRoot(Heap::kSingleCharacterStringCacheRootIndex);
Node* code_index = ChangeUint32ToWord(code);
// Check if we have an entry for the {code} in the single character string
// cache already.
Label if_entryisundefined(this, Label::kDeferred),
if_entryisnotundefined(this);
Node* entry = LoadFixedArrayElement(cache, code);
Node* entry = LoadFixedArrayElement(cache, code_index);
Branch(WordEqual(entry, UndefinedConstant()), &if_entryisundefined,
&if_entryisnotundefined);
......@@ -3198,7 +3195,7 @@ Node* CodeStubAssembler::StringFromCharCode(Node* code) {
StoreNoWriteBarrier(
MachineRepresentation::kWord8, result,
IntPtrConstant(SeqOneByteString::kHeaderSize - kHeapObjectTag), code);
StoreFixedArrayElement(cache, code, result);
StoreFixedArrayElement(cache, code_index, result);
var_result.Bind(result);
Goto(&if_done);
}
......@@ -3791,8 +3788,7 @@ Node* CodeStubAssembler::NumberToString(Node* context, Node* argument) {
Node* index = WordAnd(hash, SmiUntag(BitcastWordToTagged(mask)));
// Cache entry's key must be a heap number
Node* number_key =
LoadFixedArrayElement(number_string_cache, index, 0, INTPTR_PARAMETERS);
Node* number_key = LoadFixedArrayElement(number_string_cache, index);
GotoIf(TaggedIsSmi(number_key), &runtime);
map = LoadMap(number_key);
GotoUnless(IsHeapNumberMap(map), &runtime);
......@@ -3807,8 +3803,7 @@ Node* CodeStubAssembler::NumberToString(Node* context, Node* argument) {
// Heap number match, return value fro cache entry.
IncrementCounter(isolate()->counters()->number_to_string_native(), 1);
result.Bind(LoadFixedArrayElement(number_string_cache, index, kPointerSize,
INTPTR_PARAMETERS));
result.Bind(LoadFixedArrayElement(number_string_cache, index, kPointerSize));
Goto(&done);
Bind(&runtime);
......@@ -4446,8 +4441,7 @@ void CodeStubAssembler::NameDictionaryLookup(Node* dictionary,
Node* index = EntryToIndex<Dictionary>(entry);
var_name_index->Bind(index);
Node* current =
LoadFixedArrayElement(dictionary, index, 0, INTPTR_PARAMETERS);
Node* current = LoadFixedArrayElement(dictionary, index);
GotoIf(WordEqual(current, unique_name), if_found);
// See Dictionary::NextProbe().
......@@ -4476,8 +4470,7 @@ void CodeStubAssembler::NameDictionaryLookup(Node* dictionary,
Node* index = EntryToIndex<Dictionary>(entry);
var_name_index->Bind(index);
Node* current =
LoadFixedArrayElement(dictionary, index, 0, INTPTR_PARAMETERS);
Node* current = LoadFixedArrayElement(dictionary, index);
GotoIf(WordEqual(current, undefined), if_not_found);
if (mode == kFindExisting) {
GotoIf(WordEqual(current, unique_name), if_found);
......@@ -4555,8 +4548,7 @@ void CodeStubAssembler::NumberDictionaryLookup(Node* dictionary,
Node* entry = var_entry->value();
Node* index = EntryToIndex<Dictionary>(entry);
Node* current =
LoadFixedArrayElement(dictionary, index, 0, INTPTR_PARAMETERS);
Node* current = LoadFixedArrayElement(dictionary, index);
GotoIf(WordEqual(current, undefined), if_not_found);
Label next_probe(this);
{
......@@ -4614,13 +4606,12 @@ void CodeStubAssembler::InsertEntry<NameDictionary>(Node* dictionary,
Node* index,
Node* enum_index) {
// Store name and value.
StoreFixedArrayElement(dictionary, index, name, UPDATE_WRITE_BARRIER, 0,
INTPTR_PARAMETERS);
StoreFixedArrayElement(dictionary, index, name);
const int kNameToValueOffset =
(NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
kPointerSize;
StoreFixedArrayElement(dictionary, index, value, UPDATE_WRITE_BARRIER,
kNameToValueOffset, INTPTR_PARAMETERS);
kNameToValueOffset);
// Prepare details of the new property.
Variable var_details(this, MachineRepresentation::kTaggedSigned);
......@@ -4648,8 +4639,7 @@ void CodeStubAssembler::InsertEntry<NameDictionary>(Node* dictionary,
(NameDictionary::kEntryDetailsIndex - NameDictionary::kEntryKeyIndex) *
kPointerSize;
StoreFixedArrayElement(dictionary, index, var_details.value(),
SKIP_WRITE_BARRIER, kNameToDetailsOffset,
INTPTR_PARAMETERS);
SKIP_WRITE_BARRIER, kNameToDetailsOffset);
}
template <>
......@@ -4711,16 +4701,15 @@ void CodeStubAssembler::DescriptorLookupLinear(Node* unique_name,
Node* factor = IntPtrConstant(DescriptorArray::kDescriptorSize);
Node* last_exclusive = IntPtrAdd(first_inclusive, IntPtrMul(nof, factor));
BuildFastLoop(MachineType::PointerRepresentation(), last_exclusive,
first_inclusive,
[this, descriptors, unique_name, if_found,
var_name_index](Node* name_index) {
Node* candidate_name = LoadFixedArrayElement(
descriptors, name_index, 0, INTPTR_PARAMETERS);
var_name_index->Bind(name_index);
GotoIf(WordEqual(candidate_name, unique_name), if_found);
},
-DescriptorArray::kDescriptorSize, IndexAdvanceMode::kPre);
BuildFastLoop(
MachineType::PointerRepresentation(), last_exclusive, first_inclusive,
[this, descriptors, unique_name, if_found,
var_name_index](Node* name_index) {
Node* candidate_name = LoadFixedArrayElement(descriptors, name_index);
var_name_index->Bind(name_index);
GotoIf(WordEqual(candidate_name, unique_name), if_found);
},
-DescriptorArray::kDescriptorSize, IndexAdvanceMode::kPre);
Goto(if_not_found);
}
......@@ -4834,8 +4823,8 @@ void CodeStubAssembler::LoadPropertyFromFastObject(Node* object, Node* map,
(DescriptorArray::kDescriptorValue - DescriptorArray::kDescriptorKey) *
kPointerSize;
Node* details = LoadAndUntagToWord32FixedArrayElement(
descriptors, name_index, name_to_details_offset, INTPTR_PARAMETERS);
Node* details = LoadAndUntagToWord32FixedArrayElement(descriptors, name_index,
name_to_details_offset);
var_details->Bind(details);
Node* location = DecodeWord32<PropertyDetails::LocationField>(details);
......@@ -4891,8 +4880,7 @@ void CodeStubAssembler::LoadPropertyFromFastObject(Node* object, Node* map,
Comment("if_backing_store");
Node* properties = LoadProperties(object);
field_index = IntPtrSub(field_index, inobject_properties);
Node* value =
LoadFixedArrayElement(properties, field_index, 0, INTPTR_PARAMETERS);
Node* value = LoadFixedArrayElement(properties, field_index);
Label if_double(this), if_tagged(this);
Branch(Word32NotEqual(representation,
......@@ -4919,8 +4907,8 @@ void CodeStubAssembler::LoadPropertyFromFastObject(Node* object, Node* map,
}
Bind(&if_in_descriptor);
{
Node* value = LoadFixedArrayElement(
descriptors, name_index, name_to_value_offset, INTPTR_PARAMETERS);
Node* value =
LoadFixedArrayElement(descriptors, name_index, name_to_value_offset);
var_value->Bind(value);
Goto(&done);
}
......@@ -4942,12 +4930,12 @@ void CodeStubAssembler::LoadPropertyFromNameDictionary(Node* dictionary,
(NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
kPointerSize;
Node* details = LoadAndUntagToWord32FixedArrayElement(
dictionary, name_index, name_to_details_offset, INTPTR_PARAMETERS);
Node* details = LoadAndUntagToWord32FixedArrayElement(dictionary, name_index,
name_to_details_offset);
var_details->Bind(details);
var_value->Bind(LoadFixedArrayElement(
dictionary, name_index, name_to_value_offset, INTPTR_PARAMETERS));
var_value->Bind(
LoadFixedArrayElement(dictionary, name_index, name_to_value_offset));
Comment("] LoadPropertyFromNameDictionary");
}
......@@ -4964,8 +4952,8 @@ void CodeStubAssembler::LoadPropertyFromGlobalDictionary(Node* dictionary,
(GlobalDictionary::kEntryValueIndex - GlobalDictionary::kEntryKeyIndex) *
kPointerSize;
Node* property_cell = LoadFixedArrayElement(
dictionary, name_index, name_to_value_offset, INTPTR_PARAMETERS);
Node* property_cell =
LoadFixedArrayElement(dictionary, name_index, name_to_value_offset);
Node* value = LoadObjectField(property_cell, PropertyCell::kValueOffset);
GotoIf(WordEqual(value, TheHoleConstant()), if_deleted);
......@@ -5127,8 +5115,7 @@ void CodeStubAssembler::TryLookupElement(Node* object, Node* map,
GotoUnless(UintPtrLessThan(intptr_index, length), &if_oob);
Node* element =
LoadFixedArrayElement(elements, intptr_index, 0, INTPTR_PARAMETERS);
Node* element = LoadFixedArrayElement(elements, intptr_index);
Node* the_hole = TheHoleConstant();
Branch(WordEqual(element, the_hole), if_not_found, if_found);
}
......@@ -5447,10 +5434,6 @@ Node* CodeStubAssembler::ElementOffsetFromIndex(Node* index_node,
constant_index = ToSmiConstant(index_node, smi_index);
if (constant_index) index = smi_index->value();
index_node = BitcastTaggedToWord(index_node);
} else if (mode == INTEGER_PARAMETERS) {
int32_t temp = 0;
constant_index = ToInt32Constant(index_node, temp);
index = static_cast<intptr_t>(temp);
} else {
DCHECK(mode == INTPTR_PARAMETERS);
constant_index = ToIntPtrConstant(index_node, index);
......@@ -5458,9 +5441,6 @@ Node* CodeStubAssembler::ElementOffsetFromIndex(Node* index_node,
if (constant_index) {
return IntPtrConstant(base_size + element_size * index);
}
if (Is64() && mode == INTEGER_PARAMETERS) {
index_node = ChangeInt32ToInt64(index_node);
}
Node* shifted_index =
(element_size_shift == 0)
......@@ -5486,11 +5466,11 @@ void CodeStubAssembler::UpdateFeedback(Node* feedback,
// our new feedback in place.
// TODO(interpreter): Consider passing the feedback as Smi already to avoid
// the tagging completely.
Node* previous_feedback = LoadFixedArrayElement(type_feedback_vector, slot_id,
0, INTPTR_PARAMETERS);
Node* previous_feedback =
LoadFixedArrayElement(type_feedback_vector, slot_id);
Node* combined_feedback = SmiOr(previous_feedback, SmiFromWord32(feedback));
StoreFixedArrayElement(type_feedback_vector, slot_id, combined_feedback,
SKIP_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
SKIP_WRITE_BARRIER);
}
Node* CodeStubAssembler::LoadReceiverMap(Node* receiver) {
......@@ -5682,8 +5662,8 @@ Node* CodeStubAssembler::EmitKeyedSloppyArguments(Node* receiver, Node* key,
GotoIf(UintPtrGreaterThanOrEqual(key, adjusted_length), &if_unmapped);
Node* mapped_index = LoadFixedArrayElement(
elements, IntPtrAdd(key, intptr_two), 0, INTPTR_PARAMETERS);
Node* mapped_index =
LoadFixedArrayElement(elements, IntPtrAdd(key, intptr_two));
Branch(WordEqual(mapped_index, TheHoleConstant()), &if_unmapped, &if_mapped);
Bind(&if_mapped);
......@@ -5697,13 +5677,11 @@ Node* CodeStubAssembler::EmitKeyedSloppyArguments(Node* receiver, Node* key,
DCHECK_EQ(Context::SlotOffset(0) + kHeapObjectTag,
FixedArray::OffsetOfElementAt(0));
if (is_load) {
Node* result = LoadFixedArrayElement(the_context, mapped_index, 0,
INTPTR_PARAMETERS);
Node* result = LoadFixedArrayElement(the_context, mapped_index);
CSA_ASSERT(this, WordNotEqual(result, TheHoleConstant()));
var_result.Bind(result);
} else {
StoreFixedArrayElement(the_context, mapped_index, value,
UPDATE_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
StoreFixedArrayElement(the_context, mapped_index, value);
}
Goto(&end);
}
......@@ -5720,13 +5698,11 @@ Node* CodeStubAssembler::EmitKeyedSloppyArguments(Node* receiver, Node* key,
// The key falls into unmapped range.
if (is_load) {
Node* result =
LoadFixedArrayElement(backing_store, key, 0, INTPTR_PARAMETERS);
Node* result = LoadFixedArrayElement(backing_store, key);
GotoIf(WordEqual(result, TheHoleConstant()), bailout);
var_result.Bind(result);
} else {
StoreFixedArrayElement(backing_store, key, value, UPDATE_WRITE_BARRIER, 0,
INTPTR_PARAMETERS);
StoreFixedArrayElement(backing_store, key, value);
}
Goto(&end);
}
......@@ -8141,9 +8117,8 @@ Node* CodeStubAssembler::CreateArrayIterator(Node* array, Node* array_map,
Bind(&allocate_iterator);
{
Node* map =
LoadFixedArrayElement(LoadNativeContext(context), var_map_index.value(),
0, INTPTR_PARAMETERS);
Node* map = LoadFixedArrayElement(LoadNativeContext(context),
var_map_index.value());
var_result.Bind(AllocateJSArrayIterator(array, var_array_map.value(), map));
Goto(&return_result);
}
......
src/code-stub-assembler.h
View file @ f1441384
......@@ -64,9 +64,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
typedef base::Flags<AllocationFlag> AllocationFlags;
// TODO(ishell): Fix all loads/stores from arrays by int32 offsets/indices
// and eventually remove INTEGER_PARAMETERS in favour of INTPTR_PARAMETERS.
enum ParameterMode { INTEGER_PARAMETERS, SMI_PARAMETERS, INTPTR_PARAMETERS };
enum ParameterMode { SMI_PARAMETERS, INTPTR_PARAMETERS };
// On 32-bit platforms, there is a slight performance advantage to doing all
// of the array offset/index arithmetic with SMIs, since it's possible
......@@ -104,28 +102,23 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
return value;
}
#define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName, Int32OpName) \
Node* OpName(Node* a, Node* b, ParameterMode mode) { \
if (mode == SMI_PARAMETERS) { \
return SmiOpName(a, b); \
} else if (mode == INTPTR_PARAMETERS) { \
return IntPtrOpName(a, b); \
} else { \
DCHECK_EQ(INTEGER_PARAMETERS, mode); \
return Int32OpName(a, b); \
} \
#define PARAMETER_BINOP(OpName, IntPtrOpName, SmiOpName) \
Node* OpName(Node* a, Node* b, ParameterMode mode) { \
if (mode == SMI_PARAMETERS) { \
return SmiOpName(a, b); \
} else { \
DCHECK_EQ(INTPTR_PARAMETERS, mode); \
return IntPtrOpName(a, b); \
} \
}
PARAMETER_BINOP(IntPtrOrSmiAdd, IntPtrAdd, SmiAdd, Int32Add)
PARAMETER_BINOP(IntPtrOrSmiLessThan, IntPtrLessThan, SmiLessThan,
Int32LessThan)
PARAMETER_BINOP(IntPtrOrSmiGreaterThan, IntPtrGreaterThan, SmiGreaterThan,
Int32GreaterThan)
PARAMETER_BINOP(IntPtrOrSmiAdd, IntPtrAdd, SmiAdd)
PARAMETER_BINOP(IntPtrOrSmiLessThan, IntPtrLessThan, SmiLessThan)
PARAMETER_BINOP(IntPtrOrSmiGreaterThan, IntPtrGreaterThan, SmiGreaterThan)
PARAMETER_BINOP(IntPtrOrSmiGreaterThanOrEqual, IntPtrGreaterThanOrEqual,
SmiGreaterThanOrEqual, Int32GreaterThanOrEqual)
PARAMETER_BINOP(UintPtrOrSmiLessThan, UintPtrLessThan, SmiBelow,
Uint32LessThan)
SmiGreaterThanOrEqual)
PARAMETER_BINOP(UintPtrOrSmiLessThan, UintPtrLessThan, SmiBelow)
PARAMETER_BINOP(UintPtrOrSmiGreaterThanOrEqual, UintPtrGreaterThanOrEqual,
SmiAboveOrEqual, Uint32GreaterThanOrEqual)
SmiAboveOrEqual)
#undef PARAMETER_BINOP
Node* NoContextConstant();
......@@ -372,23 +365,23 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
Node* LoadWeakCellValue(Node* weak_cell, Label* if_cleared = nullptr);
// Load an array element from a FixedArray.
Node* LoadFixedArrayElement(
Node* object, Node* index, int additional_offset = 0,
ParameterMode parameter_mode = INTEGER_PARAMETERS);
Node* LoadFixedArrayElement(Node* object, Node* index,
int additional_offset = 0,
ParameterMode parameter_mode = INTPTR_PARAMETERS);
Node* LoadFixedArrayElement(Node* object, int index,
int additional_offset = 0) {
return LoadFixedArrayElement(object, IntPtrConstant(index),
additional_offset, INTPTR_PARAMETERS);
additional_offset);
}
// Load an array element from a FixedArray, untag it and return it as Word32.
Node* LoadAndUntagToWord32FixedArrayElement(
Node* object, Node* index, int additional_offset = 0,
ParameterMode parameter_mode = INTEGER_PARAMETERS);
ParameterMode parameter_mode = INTPTR_PARAMETERS);
// Load an array element from a FixedDoubleArray.
Node* LoadFixedDoubleArrayElement(
Node* object, Node* index, MachineType machine_type,
int additional_offset = 0,
ParameterMode parameter_mode = INTEGER_PARAMETERS,
ParameterMode parameter_mode = INTPTR_PARAMETERS,
Label* if_hole = nullptr);
// Load Float64 value by |base| + |offset| address. If the value is a double
......@@ -399,7 +392,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
MachineType machine_type = MachineType::Float64());
Node* LoadFixedTypedArrayElement(
Node* data_pointer, Node* index_node, ElementsKind elements_kind,
ParameterMode parameter_mode = INTEGER_PARAMETERS);
ParameterMode parameter_mode = INTPTR_PARAMETERS);
// Context manipulation
Node* LoadContextElement(Node* context, int slot_index);
......@@ -433,18 +426,18 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
Node* object, int index, Node* value,
WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER) {
return StoreFixedArrayElement(object, IntPtrConstant(index), value,
barrier_mode, 0, INTPTR_PARAMETERS);
barrier_mode);
}
Node* StoreFixedArrayElement(
Node* object, Node* index, Node* value,
WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
int additional_offset = 0,
ParameterMode parameter_mode = INTEGER_PARAMETERS);
ParameterMode parameter_mode = INTPTR_PARAMETERS);
Node* StoreFixedDoubleArrayElement(
Node* object, Node* index, Node* value,
ParameterMode parameter_mode = INTEGER_PARAMETERS);
ParameterMode parameter_mode = INTPTR_PARAMETERS);
Node* BuildAppendJSArray(ElementsKind kind, Node* context, Node* array,
CodeStubArguments& args, Variable& arg_index,
......@@ -522,15 +515,15 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
// The ParameterMode argument is only used for the capacity parameter.
std::pair<Node*, Node*> AllocateUninitializedJSArrayWithElements(
ElementsKind kind, Node* array_map, Node* length, Node* allocation_site,
Node* capacity, ParameterMode capacity_mode = INTEGER_PARAMETERS);
Node* capacity, ParameterMode capacity_mode = INTPTR_PARAMETERS);
// Allocate a JSArray and fill elements with the hole.
// The ParameterMode argument is only used for the capacity parameter.
Node* AllocateJSArray(ElementsKind kind, Node* array_map, Node* capacity,
Node* length, Node* allocation_site = nullptr,
ParameterMode capacity_mode = INTEGER_PARAMETERS);
ParameterMode capacity_mode = INTPTR_PARAMETERS);
Node* AllocateFixedArray(ElementsKind kind, Node* capacity,
ParameterMode mode = INTEGER_PARAMETERS,
ParameterMode mode = INTPTR_PARAMETERS,
AllocationFlags flags = kNone);
// Perform CreateArrayIterator (ES6 #sec-createarrayiterator).
......@@ -542,14 +535,14 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
void FillFixedArrayWithValue(ElementsKind kind, Node* array, Node* from_index,
Node* to_index,
Heap::RootListIndex value_root_index,
ParameterMode mode = INTEGER_PARAMETERS);
ParameterMode mode = INTPTR_PARAMETERS);
// Copies all elements from |from_array| of |length| size to
// |to_array| of the same size respecting the elements kind.
void CopyFixedArrayElements(
ElementsKind kind, Node* from_array, Node* to_array, Node* length,
WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
ParameterMode mode = INTEGER_PARAMETERS) {
ParameterMode mode = INTPTR_PARAMETERS) {
CopyFixedArrayElements(kind, from_array, kind, to_array, length, length,
barrier_mode, mode);
}
......@@ -560,7 +553,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
ElementsKind from_kind, Node* from_array, ElementsKind to_kind,
Node* to_array, Node* element_count, Node* capacity,
WriteBarrierMode barrier_mode = UPDATE_WRITE_BARRIER,
ParameterMode mode = INTEGER_PARAMETERS);
ParameterMode mode = INTPTR_PARAMETERS);
// Copies |character_count| elements from |from_string| to |to_string|
// starting at the |from_index|'th character. |from_string| and |to_string|
......@@ -585,7 +578,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler {
ElementsKind to_kind, Label* if_hole);
Node* CalculateNewElementsCapacity(Node* old_capacity,
ParameterMode mode = INTEGER_PARAMETERS);
ParameterMode mode = INTPTR_PARAMETERS);
// Tries to grow the |elements| array of given |object| to store the |key|
// or bails out if the growing gap is too big. Returns new elements.
......
src/code-stubs.cc
View file @ f1441384
......@@ -2112,8 +2112,7 @@ void StoreScriptContextFieldStub::GenerateAssembly(
Node* script_context = assembler.LoadScriptContext(context, context_index());
assembler.StoreFixedArrayElement(
script_context, assembler.IntPtrConstant(slot_index()), value,
UPDATE_WRITE_BARRIER, 0, CodeStubAssembler::INTPTR_PARAMETERS);
script_context, assembler.IntPtrConstant(slot_index()), value);
assembler.Return(value);
}
......@@ -2546,8 +2545,7 @@ compiler::Node* FastNewClosureStub::Generate(CodeStubAssembler* assembler,
// as the map of the allocated object.
Node* native_context = assembler->LoadNativeContext(context);
Node* map_slot_value =
assembler->LoadFixedArrayElement(native_context, map_index.value(), 0,
CodeStubAssembler::INTPTR_PARAMETERS);
assembler->LoadFixedArrayElement(native_context, map_index.value());
assembler->StoreMapNoWriteBarrier(result, map_slot_value);
// Initialize the rest of the function.
......@@ -3077,7 +3075,7 @@ void InternalArrayNoArgumentConstructorStub::GenerateAssembly(
Node* array = assembler.AllocateJSArray(
elements_kind(), array_map,
assembler.IntPtrConstant(JSArray::kPreallocatedArrayElements),
assembler.SmiConstant(Smi::kZero), nullptr);
assembler.SmiConstant(Smi::kZero));
assembler.Return(array);
}
......
src/ic/accessor-assembler.cc
View file @ f1441384
......@@ -80,15 +80,14 @@ void AccessorAssemblerImpl::HandlePolymorphicCase(
BuildFastLoop(
MachineType::PointerRepresentation(), init, length,
[this, receiver_map, feedback, if_handler, var_handler](Node* index) {
Node* cached_map = LoadWeakCellValue(
LoadFixedArrayElement(feedback, index, 0, INTPTR_PARAMETERS));
Node* cached_map =
LoadWeakCellValue(LoadFixedArrayElement(feedback, index));
Label next_entry(this);
GotoIf(WordNotEqual(receiver_map, cached_map), &next_entry);
// Found, now call handler.
Node* handler = LoadFixedArrayElement(feedback, index, kPointerSize,
INTPTR_PARAMETERS);
Node* handler = LoadFixedArrayElement(feedback, index, kPointerSize);
var_handler->Bind(handler);
Goto(if_handler);
......@@ -113,16 +112,16 @@ void AccessorAssemblerImpl::HandleKeyedStorePolymorphicCase(
BuildFastLoop(MachineType::PointerRepresentation(), init, length,
[this, receiver_map, feedback, if_handler, var_handler,
if_transition_handler, var_transition_map_cell](Node* index) {
Node* cached_map = LoadWeakCellValue(LoadFixedArrayElement(
feedback, index, 0, INTPTR_PARAMETERS));
Node* cached_map =
LoadWeakCellValue(LoadFixedArrayElement(feedback, index));
Label next_entry(this);
GotoIf(WordNotEqual(receiver_map, cached_map), &next_entry);
Node* maybe_transition_map_cell = LoadFixedArrayElement(
feedback, index, kPointerSize, INTPTR_PARAMETERS);
Node* maybe_transition_map_cell =
LoadFixedArrayElement(feedback, index, kPointerSize);
var_handler->Bind(LoadFixedArrayElement(
feedback, index, 2 * kPointerSize, INTPTR_PARAMETERS));
var_handler->Bind(
LoadFixedArrayElement(feedback, index, 2 * kPointerSize));
GotoIf(WordEqual(maybe_transition_map_cell,
LoadRoot(Heap::kUndefinedValueRootIndex)),
if_handler);
......@@ -286,8 +285,7 @@ void AccessorAssemblerImpl::HandleLoadICSmiHandlerCase(
CSA_ASSERT(this,
UintPtrLessThan(descriptor,
LoadAndUntagFixedArrayBaseLength(descriptors)));
Node* value =
LoadFixedArrayElement(descriptors, descriptor, 0, INTPTR_PARAMETERS);
Node* value = LoadFixedArrayElement(descriptors, descriptor);
Label if_accessor_info(this);
GotoIf(IsSetWord<LoadHandler::IsAccessorInfoBits>(handler_word),
......@@ -422,8 +420,7 @@ Node* AccessorAssemblerImpl::EmitLoadICProtoArrayCheck(
BuildFastLoop(
MachineType::PointerRepresentation(), start_index.value(), handler_length,
[this, p, handler, miss](Node* current) {
Node* prototype_cell =
LoadFixedArrayElement(handler, current, 0, INTPTR_PARAMETERS);
Node* prototype_cell = LoadFixedArrayElement(handler, current);
CheckPrototype(prototype_cell, p->name, miss);
},
1, IndexAdvanceMode::kPost);
......@@ -577,8 +574,8 @@ void AccessorAssemblerImpl::HandleStoreICProtoHandler(
BuildFastLoop(MachineType::PointerRepresentation(),
IntPtrConstant(StoreHandler::kFirstPrototypeIndex), length,
[this, p, handler, miss](Node* current) {
Node* prototype_cell = LoadFixedArrayElement(
handler, current, 0, INTPTR_PARAMETERS);
Node* prototype_cell =
LoadFixedArrayElement(handler, current);
CheckPrototype(prototype_cell, p->name, miss);
},
1, IndexAdvanceMode::kPost);
......@@ -613,8 +610,8 @@ void AccessorAssemblerImpl::HandleStoreICProtoHandler(
Node* value_index_in_descriptor =
DecodeWord<StoreHandler::DescriptorValueIndexBits>(handler_word);
Node* descriptors = LoadMapDescriptors(transition);
Node* constant = LoadFixedArrayElement(
descriptors, value_index_in_descriptor, 0, INTPTR_PARAMETERS);
Node* constant =
LoadFixedArrayElement(descriptors, value_index_in_descriptor);
GotoIf(WordNotEqual(p->value, constant), miss);
StoreMap(p->receiver, transition);
......@@ -687,8 +684,8 @@ void AccessorAssemblerImpl::HandleStoreICSmiHandlerCase(Node* handler_word,
DecodeWord<StoreHandler::DescriptorValueIndexBits>(handler_word);
Node* descriptors =
LoadMapDescriptors(transition ? transition : LoadMap(holder));
Node* maybe_field_type = LoadFixedArrayElement(
descriptors, value_index_in_descriptor, 0, INTPTR_PARAMETERS);
Node* maybe_field_type =
LoadFixedArrayElement(descriptors, value_index_in_descriptor);
Label do_store(this);
GotoIf(TaggedIsSmi(maybe_field_type), &do_store);
// Check that value type matches the field type.
......@@ -809,14 +806,13 @@ void AccessorAssemblerImpl::EmitElementLoad(
Bind(&if_fast_packed);
{
Comment("fast packed elements");
Return(LoadFixedArrayElement(elements, intptr_index, 0, INTPTR_PARAMETERS));
Return(LoadFixedArrayElement(elements, intptr_index));
}
Bind(&if_fast_holey);
{
Comment("fast holey elements");
Node* element =
LoadFixedArrayElement(elements, intptr_index, 0, INTPTR_PARAMETERS);
Node* element = LoadFixedArrayElement(elements, intptr_index);
GotoIf(WordEqual(element, TheHoleConstant()), if_hole);
Return(element);
}
......@@ -824,8 +820,8 @@ void AccessorAssemblerImpl::EmitElementLoad(
Bind(&if_fast_double);
{
Comment("packed double elements");
var_double_value->Bind(LoadFixedDoubleArrayElement(
elements, intptr_index, MachineType::Float64(), 0, INTPTR_PARAMETERS));
var_double_value->Bind(LoadFixedDoubleArrayElement(elements, intptr_index,
MachineType::Float64()));
Goto(rebox_double);
}
......@@ -863,15 +859,14 @@ void AccessorAssemblerImpl::EmitElementLoad(
// Check that the value is a data property.
Node* details_index = EntryToIndex<SeededNumberDictionary>(
var_entry.value(), SeededNumberDictionary::kEntryDetailsIndex);
Node* details = SmiToWord32(
LoadFixedArrayElement(elements, details_index, 0, INTPTR_PARAMETERS));
Node* details = SmiToWord32(LoadFixedArrayElement(elements, details_index));
Node* kind = DecodeWord32<PropertyDetails::KindField>(details);
// TODO(jkummerow): Support accessors without missing?
GotoUnless(Word32Equal(kind, Int32Constant(kData)), miss);
// Finally, load the value.
Node* value_index = EntryToIndex<SeededNumberDictionary>(
var_entry.value(), SeededNumberDictionary::kEntryValueIndex);
Return(LoadFixedArrayElement(elements, value_index, 0, INTPTR_PARAMETERS));
Return(LoadFixedArrayElement(elements, value_index));
}
Bind(&if_typed_array);
......
src/ic/keyed-store-generic.cc
View file @ f1441384
......@@ -534,7 +534,7 @@ void KeyedStoreGenericAssembler::LookupPropertyOnPrototypeChain(
DescriptorArray::kDescriptorKey) *
kPointerSize;
Node* details = LoadAndUntagToWord32FixedArrayElement(
descriptors, name_index, kNameToDetailsOffset, INTPTR_PARAMETERS);
descriptors, name_index, kNameToDetailsOffset);
JumpIfDataProperty(details, &ok_to_write, readonly);
// Accessor case.
......@@ -553,15 +553,15 @@ void KeyedStoreGenericAssembler::LookupPropertyOnPrototypeChain(
NameDictionary::kEntryKeyIndex) *
kPointerSize;
Node* details = LoadAndUntagToWord32FixedArrayElement(
dictionary, entry, kNameToDetailsOffset, INTPTR_PARAMETERS);
dictionary, entry, kNameToDetailsOffset);
JumpIfDataProperty(details, &ok_to_write, readonly);
// Accessor case.
const int kNameToValueOffset = (NameDictionary::kEntryValueIndex -
NameDictionary::kEntryKeyIndex) *
kPointerSize;
var_accessor_pair->Bind(LoadFixedArrayElement(
dictionary, entry, kNameToValueOffset, INTPTR_PARAMETERS));
var_accessor_pair->Bind(
LoadFixedArrayElement(dictionary, entry, kNameToValueOffset));
var_accessor_holder->Bind(holder);
Goto(accessor);
}
......@@ -574,8 +574,8 @@ void KeyedStoreGenericAssembler::LookupPropertyOnPrototypeChain(
GlobalDictionary::kEntryKeyIndex) *
kPointerSize;
Node* property_cell = LoadFixedArrayElement(
dictionary, entry, kNameToValueOffset, INTPTR_PARAMETERS);
Node* property_cell =
LoadFixedArrayElement(dictionary, entry, kNameToValueOffset);
Node* value =
LoadObjectField(property_cell, PropertyCell::kValueOffset);
......@@ -641,25 +641,22 @@ void KeyedStoreGenericAssembler::EmitGenericPropertyStore(
NameDictionary::kEntryKeyIndex) *
kPointerSize;
Node* details = LoadAndUntagToWord32FixedArrayElement(
properties, var_name_index.value(), kNameToDetailsOffset,
INTPTR_PARAMETERS);
properties, var_name_index.value(), kNameToDetailsOffset);
JumpIfDataProperty(details, &overwrite, &readonly);
// Accessor case.
const int kNameToValueOffset =
(NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
kPointerSize;
var_accessor_pair.Bind(
LoadFixedArrayElement(properties, var_name_index.value(),
kNameToValueOffset, INTPTR_PARAMETERS));
var_accessor_pair.Bind(LoadFixedArrayElement(
properties, var_name_index.value(), kNameToValueOffset));
var_accessor_holder.Bind(receiver);
Goto(&accessor);
Bind(&overwrite);
{
StoreFixedArrayElement(properties, var_name_index.value(), p->value,
UPDATE_WRITE_BARRIER, kNameToValueOffset,
INTPTR_PARAMETERS);
UPDATE_WRITE_BARRIER, kNameToValueOffset);
Return(p->value);
}
}
......
src/interpreter/interpreter-assembler.cc
View file @ f1441384
......@@ -451,7 +451,7 @@ Node* InterpreterAssembler::BytecodeOperandIntrinsicId(int operand_index) {
Node* InterpreterAssembler::LoadConstantPoolEntry(Node* index) {
Node* constant_pool = LoadObjectField(BytecodeArrayTaggedPointer(),
BytecodeArray::kConstantPoolOffset);
return LoadFixedArrayElement(constant_pool, index, 0, INTPTR_PARAMETERS);
return LoadFixedArrayElement(constant_pool, index);
}
Node* InterpreterAssembler::LoadAndUntagConstantPoolEntry(Node* index) {
......@@ -490,13 +490,12 @@ Node* InterpreterAssembler::IncrementCallCount(Node* type_feedback_vector,
Node* slot_id) {
Comment("increment call count");
Node* call_count_slot = IntPtrAdd(slot_id, IntPtrConstant(1));
Node* call_count = LoadFixedArrayElement(
type_feedback_vector, call_count_slot, 0, INTPTR_PARAMETERS);
Node* call_count =
LoadFixedArrayElement(type_feedback_vector, call_count_slot);
Node* new_count = SmiAdd(call_count, SmiConstant(1));
// Count is Smi, so we don't need a write barrier.
return StoreFixedArrayElement(type_feedback_vector, call_count_slot,
new_count, SKIP_WRITE_BARRIER, 0,
INTPTR_PARAMETERS);
new_count, SKIP_WRITE_BARRIER);
}
Node* InterpreterAssembler::CallJSWithFeedback(Node* function, Node* context,
......@@ -524,8 +523,7 @@ Node* InterpreterAssembler::CallJSWithFeedback(Node* function, Node* context,
end(this);
// The checks. First, does function match the recorded monomorphic target?
Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id,
0, INTPTR_PARAMETERS);
Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id);
Node* feedback_value = LoadWeakCellValueUnchecked(feedback_element);
Node* is_monomorphic = WordEqual(function, feedback_value);
GotoUnless(is_monomorphic, &extra_checks);
......@@ -645,7 +643,7 @@ Node* InterpreterAssembler::CallJSWithFeedback(Node* function, Node* context,
StoreFixedArrayElement(
type_feedback_vector, slot_id,
HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())),
SKIP_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
SKIP_WRITE_BARRIER);
Goto(&call);
}
}
......@@ -706,8 +704,7 @@ Node* InterpreterAssembler::CallConstruct(Node* constructor, Node* context,
GotoUnless(is_js_function, &call_construct);
// Check if it is a monomorphic constructor.
Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id,
0, INTPTR_PARAMETERS);
Node* feedback_element = LoadFixedArrayElement(type_feedback_vector, slot_id);
Node* feedback_value = LoadWeakCellValueUnchecked(feedback_element);
Node* is_monomorphic = WordEqual(constructor, feedback_value);
allocation_feedback.Bind(UndefinedConstant());
......@@ -812,7 +809,7 @@ Node* InterpreterAssembler::CallConstruct(Node* constructor, Node* context,
StoreFixedArrayElement(
type_feedback_vector, slot_id,
HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate())),
SKIP_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
SKIP_WRITE_BARRIER);
Goto(&call_construct_function);
}
}
......@@ -1263,8 +1260,7 @@ Node* InterpreterAssembler::ExportRegisterFile(Node* array) {
Node* reg_index = IntPtrSub(IntPtrConstant(Register(0).ToOperand()), index);
Node* value = LoadRegister(reg_index);
StoreFixedArrayElement(array, index, value, UPDATE_WRITE_BARRIER, 0,
INTPTR_PARAMETERS);
StoreFixedArrayElement(array, index, value);
var_index.Bind(IntPtrAdd(index, IntPtrConstant(1)));
Goto(&loop);
......@@ -1294,13 +1290,12 @@ Node* InterpreterAssembler::ImportRegisterFile(Node* array) {
Node* index = var_index.value();
GotoUnless(UintPtrLessThan(index, register_count), &done_loop);
Node* value = LoadFixedArrayElement(array, index, 0, INTPTR_PARAMETERS);
Node* value = LoadFixedArrayElement(array, index);
Node* reg_index = IntPtrSub(IntPtrConstant(Register(0).ToOperand()), index);
StoreRegister(value, reg_index);
StoreFixedArrayElement(array, index, StaleRegisterConstant(),
UPDATE_WRITE_BARRIER, 0, INTPTR_PARAMETERS);
StoreFixedArrayElement(array, index, StaleRegisterConstant());
var_index.Bind(IntPtrAdd(index, IntPtrConstant(1)));
Goto(&loop);
......
src/interpreter/interpreter.cc
View file @ f1441384
......@@ -884,8 +884,7 @@ void Interpreter::DoLdaModuleVariable(InterpreterAssembler* assembler) {
__ LoadObjectField(module, Module::kRegularExportsOffset);
// The actual array index is (cell_index - 1).
Node* export_index = __ IntPtrSub(cell_index, __ IntPtrConstant(1));
Node* cell = __ LoadFixedArrayElement(regular_exports, export_index, 0,
CodeStubAssembler::INTPTR_PARAMETERS);
Node* cell = __ LoadFixedArrayElement(regular_exports, export_index);
__ SetAccumulator(__ LoadObjectField(cell, Cell::kValueOffset));
__ Goto(&end);
}
......@@ -896,8 +895,7 @@ void Interpreter::DoLdaModuleVariable(InterpreterAssembler* assembler) {
__ LoadObjectField(module, Module::kRegularImportsOffset);
// The actual array index is (-cell_index - 1).
Node* import_index = __ IntPtrSub(__ IntPtrConstant(-1), cell_index);
Node* cell = __ LoadFixedArrayElement(regular_imports, import_index, 0,
CodeStubAssembler::INTPTR_PARAMETERS);
Node* cell = __ LoadFixedArrayElement(regular_imports, import_index);
__ SetAccumulator(__ LoadObjectField(cell, Cell::kValueOffset));
__ Goto(&end);
}
......@@ -929,8 +927,7 @@ void Interpreter::DoStaModuleVariable(InterpreterAssembler* assembler) {
__ LoadObjectField(module, Module::kRegularExportsOffset);
// The actual array index is (cell_index - 1).
Node* export_index = __ IntPtrSub(cell_index, __ IntPtrConstant(1));
Node* cell = __ LoadFixedArrayElement(regular_exports, export_index, 0,
CodeStubAssembler::INTPTR_PARAMETERS);
Node* cell = __ LoadFixedArrayElement(regular_exports, export_index);
__ StoreObjectField(cell, Cell::kValueOffset, value);
__ Goto(&end);
}
......@@ -2718,8 +2715,7 @@ void Interpreter::DoForInNext(InterpreterAssembler* assembler) {
Node* megamorphic_sentinel =
__ HeapConstant(TypeFeedbackVector::MegamorphicSentinel(isolate_));
__ StoreFixedArrayElement(type_feedback_vector, vector_index,
megamorphic_sentinel, SKIP_WRITE_BARRIER, 0,
CodeStubAssembler::INTPTR_PARAMETERS);
megamorphic_sentinel, SKIP_WRITE_BARRIER);
// Need to filter the {key} for the {receiver}.
Node* context = __ GetContext();
......
test/cctest/test-code-stub-assembler.cc
View file @ f1441384
......@@ -1897,10 +1897,10 @@ TEST(AllocatePromiseReactionJobInfo) {
CodeStubAssembler m(data.state());
Node* const context = m.Parameter(kNumParams + 2);
Node* const tasks = m.AllocateFixedArray(FAST_ELEMENTS, m.Int32Constant(1));
Node* const tasks = m.AllocateFixedArray(FAST_ELEMENTS, m.IntPtrConstant(1));
m.StoreFixedArrayElement(tasks, 0, m.UndefinedConstant());
Node* const deferred =
m.AllocateFixedArray(FAST_ELEMENTS, m.Int32Constant(1));
m.AllocateFixedArray(FAST_ELEMENTS, m.IntPtrConstant(1));
m.StoreFixedArrayElement(deferred, 0, m.UndefinedConstant());
Node* const info = m.AllocatePromiseReactionJobInfo(m.SmiConstant(1), tasks,
deferred, context);
......
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