From 0700bc1bf82089e10038f62528e375bcb6f22a0c Mon Sep 17 00:00:00 2001 From: ishell Date: Wed, 9 Nov 2016 10:22:06 -0800 Subject: [PATCH] [stubs] Ensure CSA_ASSERT and CSA_SLOW_ASSERT do not produce unused instructions in release mode. ... and make them applicable outside of CSA. Nice bonus is that the assert condition instructions will now appear inside [Assert / ]Assert brackets. BUG= Review-Url: https://codereview.chromium.org/2489743002 Cr-Commit-Position: refs/heads/master@{#40869} --- src/builtins/builtins-array.cc | 14 +- src/builtins/builtins-regexp.cc | 6 +- src/builtins/builtins-string.cc | 26 +-- src/code-stub-assembler.cc | 210 ++++++++++++----------- src/code-stub-assembler.h | 19 +- src/code-stubs.cc | 27 +-- src/interpreter/interpreter-assembler.cc | 5 +- test/cctest/test-code-stub-assembler.cc | 9 +- 8 files changed, 170 insertions(+), 146 deletions(-) diff --git a/src/builtins/builtins-array.cc b/src/builtins/builtins-array.cc index 7e8c48668f..8a5232d6e2 100644 --- a/src/builtins/builtins-array.cc +++ b/src/builtins/builtins-array.cc @@ -2179,14 +2179,14 @@ void Builtins::Generate_ArrayIteratorPrototypeNext( assembler->Bind(&if_isfastarray); { - assembler->Assert( - assembler->Word32Equal(assembler->LoadMapInstanceType(array_map), - assembler->Int32Constant(JS_ARRAY_TYPE))); + CSA_ASSERT(assembler, + assembler->Word32Equal(assembler->LoadMapInstanceType(array_map), + assembler->Int32Constant(JS_ARRAY_TYPE))); Node* length = assembler->LoadObjectField(array, JSArray::kLengthOffset); - assembler->Assert(assembler->TaggedIsSmi(length)); - assembler->Assert(assembler->TaggedIsSmi(index)); + CSA_ASSERT(assembler, assembler->TaggedIsSmi(length)); + CSA_ASSERT(assembler, assembler->TaggedIsSmi(index)); assembler->GotoUnless(assembler->SmiBelow(index, length), &set_done); @@ -2384,8 +2384,8 @@ void Builtins::Generate_ArrayIteratorPrototypeNext( assembler->Bind(&done); length = var_length.value(); } - assembler->Assert(assembler->TaggedIsSmi(length)); - assembler->Assert(assembler->TaggedIsSmi(index)); + CSA_ASSERT(assembler, assembler->TaggedIsSmi(length)); + CSA_ASSERT(assembler, assembler->TaggedIsSmi(index)); assembler->GotoUnless(assembler->SmiBelow(index, length), &set_done); diff --git a/src/builtins/builtins-regexp.cc b/src/builtins/builtins-regexp.cc index 40a99856b4..8be6dce548 100644 --- a/src/builtins/builtins-regexp.cc +++ b/src/builtins/builtins-regexp.cc @@ -1602,7 +1602,7 @@ compiler::Node* ReplaceGlobalCallableFastPath( Node* const res_length = a->LoadJSArrayLength(res); Node* const res_elems = a->LoadElements(res); - a->CSA_ASSERT(a->HasInstanceType(res_elems, FIXED_ARRAY_TYPE)); + CSA_ASSERT(a, a->HasInstanceType(res_elems, FIXED_ARRAY_TYPE)); CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS; Node* const num_capture_registers = a->LoadFixedArrayElement( @@ -1677,7 +1677,7 @@ compiler::Node* ReplaceGlobalCallableFastPath( a->Bind(&if_isstring); { - a->Assert(a->IsStringInstanceType(a->LoadInstanceType(elem))); + CSA_ASSERT(a, a->IsStringInstanceType(a->LoadInstanceType(elem))); Callable call_callable = CodeFactory::Call(isolate); Node* const replacement_obj = @@ -1725,7 +1725,7 @@ compiler::Node* ReplaceGlobalCallableFastPath( // elem must be an Array. // Use the apply argument as backing for global RegExp properties. - a->CSA_ASSERT(a->HasInstanceType(elem, JS_ARRAY_TYPE)); + CSA_ASSERT(a, a->HasInstanceType(elem, JS_ARRAY_TYPE)); // TODO(jgruber): Remove indirection through Call->ReflectApply. Callable call_callable = CodeFactory::Call(isolate); diff --git a/src/builtins/builtins-string.cc b/src/builtins/builtins-string.cc index f210b8d9b4..6450a9d1f2 100644 --- a/src/builtins/builtins-string.cc +++ b/src/builtins/builtins-string.cc @@ -1001,8 +1001,8 @@ void Builtins::Generate_StringPrototypeSubstr(CodeStubAssembler* a) { // two cases according to the spec: if it is negative, "" is returned; if // it is positive, then length is set to {string_length} - {start}. - a->Assert(a->WordEqual(a->LoadMap(var_length.value()), - a->HeapNumberMapConstant())); + CSA_ASSERT(a, a->WordEqual(a->LoadMap(var_length.value()), + a->HeapNumberMapConstant())); Label if_isnegative(a), if_ispositive(a); Node* const float_zero = a->Float64Constant(0.); @@ -1071,7 +1071,8 @@ compiler::Node* ToSmiBetweenZeroAnd(CodeStubAssembler* a, a->Bind(&if_isnotsmi); { // {value} is a heap number - in this case, it is definitely out of bounds. - a->Assert(a->WordEqual(a->LoadMap(value_int), a->HeapNumberMapConstant())); + CSA_ASSERT(a, + a->WordEqual(a->LoadMap(value_int), a->HeapNumberMapConstant())); Node* const float_zero = a->Float64Constant(0.); Node* const smi_zero = a->SmiConstant(Smi::kZero); @@ -1301,17 +1302,16 @@ compiler::Node* LoadSurrogatePairInternal(CodeStubAssembler* assembler, { Node* lead = var_result.value(); Node* trail = var_trail.value(); -#ifdef ENABLE_SLOW_DCHECKS + // Check that this path is only taken if a surrogate pair is found - assembler->Assert(assembler->Uint32GreaterThanOrEqual( - lead, assembler->Int32Constant(0xD800))); - assembler->Assert( - assembler->Uint32LessThan(lead, assembler->Int32Constant(0xDC00))); - assembler->Assert(assembler->Uint32GreaterThanOrEqual( - trail, assembler->Int32Constant(0xDC00))); - assembler->Assert( - assembler->Uint32LessThan(trail, assembler->Int32Constant(0xE000))); -#endif + CSA_SLOW_ASSERT(assembler, assembler->Uint32GreaterThanOrEqual( + lead, assembler->Int32Constant(0xD800))); + CSA_SLOW_ASSERT(assembler, assembler->Uint32LessThan( + lead, assembler->Int32Constant(0xDC00))); + CSA_SLOW_ASSERT(assembler, assembler->Uint32GreaterThanOrEqual( + trail, assembler->Int32Constant(0xDC00))); + CSA_SLOW_ASSERT(assembler, assembler->Uint32LessThan( + trail, assembler->Int32Constant(0xE000))); switch (encoding) { case UnicodeEncoding::UTF16: diff --git a/src/code-stub-assembler.cc b/src/code-stub-assembler.cc index 86331567c4..8838bc5587 100644 --- a/src/code-stub-assembler.cc +++ b/src/code-stub-assembler.cc @@ -25,7 +25,7 @@ CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone, const char* name) : compiler::CodeAssembler(isolate, zone, parameter_count, flags, name) {} -void CodeStubAssembler::Assert(Node* condition, const char* message, +void CodeStubAssembler::Assert(ConditionBody codition_body, const char* message, const char* file, int line) { #if defined(DEBUG) Label ok(this); @@ -33,9 +33,10 @@ void CodeStubAssembler::Assert(Node* condition, const char* message, if (message != nullptr && FLAG_code_comments) { Comment("[ Assert: %s", message); } else { - Comment("[ Assert "); + Comment("[ Assert"); } - + Node* condition = codition_body(); + DCHECK_NOT_NULL(condition); Branch(condition, &ok, ¬_ok); Bind(¬_ok); if (message != nullptr) { @@ -129,7 +130,7 @@ Node* CodeStubAssembler::IntPtrSubFoldConstants(Node* left, Node* right) { Node* CodeStubAssembler::IntPtrRoundUpToPowerOfTwo32(Node* value) { Comment("IntPtrRoundUpToPowerOfTwo32"); - CSA_ASSERT(UintPtrLessThanOrEqual(value, IntPtrConstant(0x80000000u))); + CSA_ASSERT(this, UintPtrLessThanOrEqual(value, IntPtrConstant(0x80000000u))); value = IntPtrSub(value, IntPtrConstant(1)); for (int i = 1; i <= 16; i *= 2) { value = WordOr(value, WordShr(value, IntPtrConstant(i))); @@ -1009,7 +1010,7 @@ Node* CodeStubAssembler::LoadElements(Node* object) { } Node* CodeStubAssembler::LoadJSArrayLength(Node* array) { - CSA_ASSERT(IsJSArray(array)); + CSA_ASSERT(this, IsJSArray(array)); return LoadObjectField(array, JSArray::kLengthOffset); } @@ -1022,17 +1023,17 @@ Node* CodeStubAssembler::LoadAndUntagFixedArrayBaseLength(Node* array) { } Node* CodeStubAssembler::LoadMapBitField(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); return LoadObjectField(map, Map::kBitFieldOffset, MachineType::Uint8()); } Node* CodeStubAssembler::LoadMapBitField2(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); return LoadObjectField(map, Map::kBitField2Offset, MachineType::Uint8()); } Node* CodeStubAssembler::LoadMapBitField3(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); return LoadObjectField(map, Map::kBitField3Offset, MachineType::Uint32()); } @@ -1041,24 +1042,24 @@ Node* CodeStubAssembler::LoadMapInstanceType(Node* map) { } Node* CodeStubAssembler::LoadMapElementsKind(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); Node* bit_field2 = LoadMapBitField2(map); return DecodeWord32(bit_field2); } Node* CodeStubAssembler::LoadMapDescriptors(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); return LoadObjectField(map, Map::kDescriptorsOffset); } Node* CodeStubAssembler::LoadMapPrototype(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); return LoadObjectField(map, Map::kPrototypeOffset); } Node* CodeStubAssembler::LoadMapPrototypeInfo(Node* map, Label* if_no_proto_info) { - CSA_ASSERT(IsMap(map)); + CSA_ASSERT(this, IsMap(map)); Node* prototype_info = LoadObjectField(map, Map::kTransitionsOrPrototypeInfoOffset); GotoIf(TaggedIsSmi(prototype_info), if_no_proto_info); @@ -1069,16 +1070,17 @@ Node* CodeStubAssembler::LoadMapPrototypeInfo(Node* map, } Node* CodeStubAssembler::LoadMapInstanceSize(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); return ChangeUint32ToWord( LoadObjectField(map, Map::kInstanceSizeOffset, MachineType::Uint8())); } Node* CodeStubAssembler::LoadMapInobjectProperties(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); // See Map::GetInObjectProperties() for details. STATIC_ASSERT(LAST_JS_OBJECT_TYPE == LAST_TYPE); - CSA_ASSERT(Int32GreaterThanOrEqual(LoadMapInstanceType(map), + CSA_ASSERT(this, + Int32GreaterThanOrEqual(LoadMapInstanceType(map), Int32Constant(FIRST_JS_OBJECT_TYPE))); return ChangeUint32ToWord(LoadObjectField( map, Map::kInObjectPropertiesOrConstructorFunctionIndexOffset, @@ -1086,18 +1088,18 @@ Node* CodeStubAssembler::LoadMapInobjectProperties(Node* map) { } Node* CodeStubAssembler::LoadMapConstructorFunctionIndex(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); // See Map::GetConstructorFunctionIndex() for details. STATIC_ASSERT(FIRST_PRIMITIVE_TYPE == FIRST_TYPE); - CSA_ASSERT(Int32LessThanOrEqual(LoadMapInstanceType(map), - Int32Constant(LAST_PRIMITIVE_TYPE))); + CSA_ASSERT(this, Int32LessThanOrEqual(LoadMapInstanceType(map), + Int32Constant(LAST_PRIMITIVE_TYPE))); return ChangeUint32ToWord(LoadObjectField( map, Map::kInObjectPropertiesOrConstructorFunctionIndexOffset, MachineType::Uint8())); } Node* CodeStubAssembler::LoadMapConstructor(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); Variable result(this, MachineRepresentation::kTagged); result.Bind(LoadObjectField(map, Map::kConstructorOrBackPointerOffset)); @@ -1118,7 +1120,7 @@ Node* CodeStubAssembler::LoadMapConstructor(Node* map) { } Node* CodeStubAssembler::LoadNameHashField(Node* name) { - CSA_ASSERT(IsName(name)); + CSA_ASSERT(this, IsName(name)); return LoadObjectField(name, Name::kHashFieldOffset, MachineType::Uint32()); } @@ -1134,12 +1136,12 @@ Node* CodeStubAssembler::LoadNameHash(Node* name, Label* if_hash_not_computed) { } Node* CodeStubAssembler::LoadStringLength(Node* object) { - CSA_ASSERT(IsString(object)); + CSA_ASSERT(this, IsString(object)); return LoadObjectField(object, String::kLengthOffset); } Node* CodeStubAssembler::LoadJSValueValue(Node* object) { - CSA_ASSERT(IsJSValue(object)); + CSA_ASSERT(this, IsJSValue(object)); return LoadObjectField(object, JSValue::kValueOffset); } @@ -1149,7 +1151,7 @@ Node* CodeStubAssembler::LoadWeakCellValueUnchecked(Node* weak_cell) { } Node* CodeStubAssembler::LoadWeakCellValue(Node* weak_cell, Label* if_cleared) { - CSA_ASSERT(IsWeakCell(weak_cell)); + CSA_ASSERT(this, IsWeakCell(weak_cell)); Node* value = LoadWeakCellValueUnchecked(weak_cell); if (if_cleared != nullptr) { GotoIf(WordEqual(value, IntPtrConstant(0)), if_cleared); @@ -1227,7 +1229,7 @@ Node* CodeStubAssembler::LoadAndUntagToWord32FixedArrayElement( Node* CodeStubAssembler::LoadFixedDoubleArrayElement( Node* object, Node* index_node, MachineType machine_type, int additional_offset, ParameterMode parameter_mode, Label* if_hole) { - CSA_ASSERT(IsFixedDoubleArray(object)); + CSA_ASSERT(this, IsFixedDoubleArray(object)); int32_t header_size = FixedDoubleArray::kHeaderSize + additional_offset - kHeapObjectTag; Node* offset = ElementOffsetFromIndex(index_node, FAST_HOLEY_DOUBLE_ELEMENTS, @@ -1293,7 +1295,7 @@ Node* CodeStubAssembler::LoadNativeContext(Node* context) { Node* CodeStubAssembler::LoadJSArrayElementsMap(ElementsKind kind, Node* native_context) { - CSA_ASSERT(IsNativeContext(native_context)); + CSA_ASSERT(this, IsNativeContext(native_context)); return LoadFixedArrayElement(native_context, IntPtrConstant(Context::ArrayMapIndex(kind))); } @@ -1369,7 +1371,7 @@ Node* CodeStubAssembler::StoreFixedArrayElement(Node* object, Node* index_node, Node* CodeStubAssembler::StoreFixedDoubleArrayElement( Node* object, Node* index_node, Node* value, ParameterMode parameter_mode) { - CSA_ASSERT(IsFixedDoubleArray(object)); + CSA_ASSERT(this, IsFixedDoubleArray(object)); Node* offset = ElementOffsetFromIndex(index_node, FAST_DOUBLE_ELEMENTS, parameter_mode, FixedArray::kHeaderSize - kHeapObjectTag); @@ -1517,7 +1519,7 @@ Node* CodeStubAssembler::AllocateSeqTwoByteString(Node* context, Node* length, Node* CodeStubAssembler::AllocateSlicedString( Heap::RootListIndex map_root_index, Node* length, Node* parent, Node* offset) { - CSA_ASSERT(TaggedIsSmi(length)); + CSA_ASSERT(this, TaggedIsSmi(length)); Node* result = Allocate(SlicedString::kSize); Node* map = LoadRoot(map_root_index); DCHECK(Heap::RootIsImmortalImmovable(map_root_index)); @@ -1550,7 +1552,7 @@ Node* CodeStubAssembler::AllocateConsString(Heap::RootListIndex map_root_index, Node* length, Node* first, Node* second, AllocationFlags flags) { - CSA_ASSERT(TaggedIsSmi(length)); + CSA_ASSERT(this, TaggedIsSmi(length)); Node* result = Allocate(ConsString::kSize, flags); Node* map = LoadRoot(map_root_index); DCHECK(Heap::RootIsImmortalImmovable(map_root_index)); @@ -1589,7 +1591,7 @@ Node* CodeStubAssembler::AllocateTwoByteConsString(Node* length, Node* first, Node* CodeStubAssembler::NewConsString(Node* context, Node* length, Node* left, Node* right, AllocationFlags flags) { - CSA_ASSERT(TaggedIsSmi(length)); + CSA_ASSERT(this, TaggedIsSmi(length)); // Added string can be a cons string. Comment("Allocating ConsString"); Node* left_instance_type = LoadInstanceType(left); @@ -1644,7 +1646,8 @@ Node* CodeStubAssembler::AllocateRegExpResult(Node* context, Node* length, Node* index, Node* input) { Node* const max_length = SmiConstant(Smi::FromInt(JSArray::kInitialMaxFastElementArray)); - CSA_ASSERT(SmiLessThanOrEqual(length, max_length)); + CSA_ASSERT(this, SmiLessThanOrEqual(length, max_length)); + USE(max_length); // Allocate the JSRegExpResult. // TODO(jgruber): Fold JSArray and FixedArray allocations, then remove @@ -1689,11 +1692,12 @@ Node* CodeStubAssembler::AllocateNameDictionary(int at_least_space_for) { } Node* CodeStubAssembler::AllocateNameDictionary(Node* at_least_space_for) { - CSA_ASSERT(UintPtrLessThanOrEqual( - at_least_space_for, IntPtrConstant(NameDictionary::kMaxCapacity))); + CSA_ASSERT(this, UintPtrLessThanOrEqual( + at_least_space_for, + IntPtrConstant(NameDictionary::kMaxCapacity))); Node* capacity = HashTableComputeCapacity(at_least_space_for); - CSA_ASSERT(WordIsPowerOfTwo(capacity)); + CSA_ASSERT(this, WordIsPowerOfTwo(capacity)); Node* length = EntryToIndex(capacity); Node* store_size = @@ -1738,10 +1742,10 @@ Node* CodeStubAssembler::AllocateNameDictionary(Node* at_least_space_for) { Node* CodeStubAssembler::AllocateJSObjectFromMap(Node* map, Node* properties, Node* elements) { - CSA_ASSERT(IsMap(map)); + CSA_ASSERT(this, IsMap(map)); Node* size = IntPtrMul(LoadMapInstanceSize(map), IntPtrConstant(kPointerSize)); - CSA_ASSERT(IsRegularHeapObjectSize(size)); + CSA_ASSERT(this, IsRegularHeapObjectSize(size)); Node* object = Allocate(size); StoreMapNoWriteBarrier(object, map); InitializeJSObjectFromMap(object, map, size, properties, elements); @@ -1754,7 +1758,7 @@ void CodeStubAssembler::InitializeJSObjectFromMap(Node* object, Node* map, // This helper assumes that the object is in new-space, as guarded by the // check in AllocatedJSObjectFromMap. if (properties == nullptr) { - CSA_ASSERT(Word32BinaryNot(IsDictionaryMap((map)))); + CSA_ASSERT(this, Word32BinaryNot(IsDictionaryMap((map)))); StoreObjectFieldRoot(object, JSObject::kPropertiesOffset, Heap::kEmptyFixedArrayRootIndex); } else { @@ -1787,8 +1791,8 @@ void CodeStubAssembler::StoreFieldsNoWriteBarrier(Node* start_address, Node* end_address, Node* value) { Comment("StoreFieldsNoWriteBarrier"); - CSA_ASSERT(WordIsWordAligned(start_address)); - CSA_ASSERT(WordIsWordAligned(end_address)); + CSA_ASSERT(this, WordIsWordAligned(start_address)); + CSA_ASSERT(this, WordIsWordAligned(end_address)); BuildFastLoop( MachineType::PointerRepresentation(), start_address, end_address, [value](CodeStubAssembler* a, Node* current) { @@ -1890,7 +1894,8 @@ Node* CodeStubAssembler::AllocateFixedArray(ElementsKind kind, Node* capacity_node, ParameterMode mode, AllocationFlags flags) { - CSA_ASSERT(IntPtrGreaterThan(capacity_node, IntPtrOrSmiConstant(0, mode))); + CSA_ASSERT(this, + IntPtrGreaterThan(capacity_node, IntPtrOrSmiConstant(0, mode))); Node* total_size = GetFixedArrayAllocationSize(capacity_node, kind, mode); // Allocate both array and elements object, and initialize the JSArray. @@ -2658,24 +2663,24 @@ Node* CodeStubAssembler::ThrowIfNotInstanceType(Node* context, Node* value, Node* CodeStubAssembler::IsSpecialReceiverMap(Node* map) { Node* is_special = IsSpecialReceiverInstanceType(LoadMapInstanceType(map)); - Node* bit_field = LoadMapBitField(map); uint32_t mask = 1 << Map::kHasNamedInterceptor | 1 << Map::kIsAccessCheckNeeded; + USE(mask); // Interceptors or access checks imply special receiver. - CSA_ASSERT( - Select(IsSetWord32(bit_field, mask), is_special, Int32Constant(1))); + CSA_ASSERT(this, Select(IsSetWord32(LoadMapBitField(map), mask), is_special, + Int32Constant(1), MachineRepresentation::kWord32)); return is_special; } Node* CodeStubAssembler::IsDictionaryMap(Node* map) { - CSA_SLOW_ASSERT(IsMap(map)); + CSA_SLOW_ASSERT(this, IsMap(map)); Node* bit_field3 = LoadMapBitField3(map); return Word32NotEqual(IsSetWord32(bit_field3), Int32Constant(0)); } Node* CodeStubAssembler::IsCallableMap(Node* map) { - CSA_ASSERT(IsMap(map)); + CSA_ASSERT(this, IsMap(map)); return Word32NotEqual( Word32And(LoadMapBitField(map), Int32Constant(1 << Map::kIsCallable)), Int32Constant(0)); @@ -2762,7 +2767,7 @@ Node* CodeStubAssembler::IsUnseededNumberDictionary(Node* object) { } Node* CodeStubAssembler::StringCharCodeAt(Node* string, Node* index) { - CSA_ASSERT(IsString(string)); + CSA_ASSERT(this, IsString(string)); // Translate the {index} into a Word. index = SmiToWord(index); @@ -3294,8 +3299,8 @@ Node* CodeStubAssembler::StringAdd(Node* context, Node* left, Node* right, Goto(&done_native); Bind(&cons); - CSA_ASSERT(TaggedIsSmi(left_length)); - CSA_ASSERT(TaggedIsSmi(right_length)); + CSA_ASSERT(this, TaggedIsSmi(left_length)); + CSA_ASSERT(this, TaggedIsSmi(right_length)); Node* new_length = SmiAdd(left_length, right_length); GotoIf(UintPtrGreaterThanOrEqual( new_length, SmiConstant(Smi::FromInt(String::kMaxLength))), @@ -3379,7 +3384,7 @@ Node* CodeStubAssembler::StringAdd(Node* context, Node* left, Node* right, Node* CodeStubAssembler::StringIndexOfChar(Node* context, Node* string, Node* needle_char, Node* from) { - CSA_ASSERT(IsString(string)); + CSA_ASSERT(this, IsString(string)); Variable var_result(this, MachineRepresentation::kTagged); Label out(this), runtime(this, Label::kDeferred); @@ -3651,8 +3656,8 @@ Node* CodeStubAssembler::ToName(Node* context, Node* value) { Node* CodeStubAssembler::NonNumberToNumber(Node* context, Node* input) { // Assert input is a HeapObject (not smi or heap number) - CSA_ASSERT(Word32BinaryNot(TaggedIsSmi(input))); - CSA_ASSERT(Word32NotEqual(LoadMap(input), HeapNumberMapConstant())); + CSA_ASSERT(this, Word32BinaryNot(TaggedIsSmi(input))); + CSA_ASSERT(this, Word32NotEqual(LoadMap(input), HeapNumberMapConstant())); // We might need to loop once here due to ToPrimitive conversions. Variable var_input(this, MachineRepresentation::kTagged); @@ -3809,7 +3814,7 @@ Node* CodeStubAssembler::ToString(Node* context, Node* input) { } Node* CodeStubAssembler::FlattenString(Node* string) { - CSA_ASSERT(IsString(string)); + CSA_ASSERT(this, IsString(string)); Variable var_result(this, MachineRepresentation::kTagged); var_result.Bind(string); @@ -4043,7 +4048,7 @@ void CodeStubAssembler::NameDictionaryLookup(Node* dictionary, Variable* var_name_index, Label* if_not_found, int inlined_probes) { - CSA_ASSERT(IsDictionary(dictionary)); + CSA_ASSERT(this, IsDictionary(dictionary)); DCHECK_EQ(MachineType::PointerRepresentation(), var_name_index->rep()); Comment("NameDictionaryLookup"); @@ -4128,7 +4133,7 @@ void CodeStubAssembler::NumberDictionaryLookup(Node* dictionary, Label* if_found, Variable* var_entry, Label* if_not_found) { - CSA_ASSERT(IsDictionary(dictionary)); + CSA_ASSERT(this, IsDictionary(dictionary)); DCHECK_EQ(MachineType::PointerRepresentation(), var_entry->rep()); Comment("NumberDictionaryLookup"); @@ -4235,10 +4240,10 @@ void CodeStubAssembler::TryLookupProperty( Int32Constant(LAST_SPECIAL_RECEIVER_TYPE)), &if_objectisspecial); - Node* bit_field = LoadMapBitField(map); - Node* mask = Int32Constant(1 << Map::kHasNamedInterceptor | - 1 << Map::kIsAccessCheckNeeded); - CSA_ASSERT(Word32Equal(Word32And(bit_field, mask), Int32Constant(0))); + uint32_t mask = + 1 << Map::kHasNamedInterceptor | 1 << Map::kIsAccessCheckNeeded; + CSA_ASSERT(this, Word32BinaryNot(IsSetWord32(LoadMapBitField(map), mask))); + USE(mask); Node* bit_field3 = LoadMapBitField3(map); Label if_isfastmap(this), if_isslowmap(this); @@ -4431,7 +4436,7 @@ void CodeStubAssembler::LoadPropertyFromNameDictionary(Node* dictionary, Variable* var_details, Variable* var_value) { Comment("LoadPropertyFromNameDictionary"); - CSA_ASSERT(IsDictionary(dictionary)); + CSA_ASSERT(this, IsDictionary(dictionary)); const int name_to_details_offset = (NameDictionary::kEntryDetailsIndex - NameDictionary::kEntryKeyIndex) * kPointerSize; @@ -4455,7 +4460,7 @@ void CodeStubAssembler::LoadPropertyFromGlobalDictionary(Node* dictionary, Variable* var_value, Label* if_deleted) { Comment("[ LoadPropertyFromGlobalDictionary"); - CSA_ASSERT(IsDictionary(dictionary)); + CSA_ASSERT(this, IsDictionary(dictionary)); const int name_to_value_offset = (GlobalDictionary::kEntryValueIndex - GlobalDictionary::kEntryKeyIndex) * @@ -4495,7 +4500,7 @@ Node* CodeStubAssembler::CallGetterIfAccessor(Node* value, Node* details, GotoIf(Word32Equal(LoadInstanceType(accessor_pair), Int32Constant(ACCESSOR_INFO_TYPE)), if_bailout); - CSA_ASSERT(HasInstanceType(accessor_pair, ACCESSOR_PAIR_TYPE)); + CSA_ASSERT(this, HasInstanceType(accessor_pair, ACCESSOR_PAIR_TYPE)); Node* getter = LoadObjectField(accessor_pair, AccessorPair::kGetterOffset); Node* getter_map = LoadMap(getter); Node* instance_type = LoadMapInstanceType(getter_map); @@ -4650,18 +4655,18 @@ void CodeStubAssembler::TryLookupElement(Node* object, Node* map, } Bind(&if_isfaststringwrapper); { - CSA_ASSERT(HasInstanceType(object, JS_VALUE_TYPE)); + CSA_ASSERT(this, HasInstanceType(object, JS_VALUE_TYPE)); Node* string = LoadJSValueValue(object); - CSA_ASSERT(IsStringInstanceType(LoadInstanceType(string))); + CSA_ASSERT(this, IsStringInstanceType(LoadInstanceType(string))); Node* length = LoadStringLength(string); GotoIf(UintPtrLessThan(intptr_index, SmiUntag(length)), if_found); Goto(&if_isobjectorsmi); } Bind(&if_isslowstringwrapper); { - CSA_ASSERT(HasInstanceType(object, JS_VALUE_TYPE)); + CSA_ASSERT(this, HasInstanceType(object, JS_VALUE_TYPE)); Node* string = LoadJSValueValue(object); - CSA_ASSERT(IsStringInstanceType(LoadInstanceType(string))); + CSA_ASSERT(this, IsStringInstanceType(LoadInstanceType(string))); Node* length = LoadStringLength(string); GotoIf(UintPtrLessThan(intptr_index, SmiUntag(length)), if_found); Goto(&if_isdictionary); @@ -5134,9 +5139,10 @@ compiler::Node* CodeStubAssembler::StubCachePrimaryOffset(compiler::Node* name, STATIC_ASSERT(StubCache::kCacheIndexShift == Name::kHashShift); // Compute the hash of the name (use entire hash field). Node* hash_field = LoadNameHashField(name); - CSA_ASSERT(Word32Equal( - Word32And(hash_field, Int32Constant(Name::kHashNotComputedMask)), - Int32Constant(0))); + CSA_ASSERT(this, + Word32Equal(Word32And(hash_field, + Int32Constant(Name::kHashNotComputedMask)), + Int32Constant(0))); // Using only the low bits in 64-bit mode is unlikely to increase the // risk of collision even if the heap is spread over an area larger than @@ -5612,8 +5618,9 @@ void CodeStubAssembler::HandleLoadICHandlerCase( Node* descriptor = DecodeWord(handler_word); #if defined(DEBUG) - CSA_ASSERT(UintPtrLessThan( - descriptor, LoadAndUntagFixedArrayBaseLength(descriptors))); + CSA_ASSERT( + this, UintPtrLessThan(descriptor, + LoadAndUntagFixedArrayBaseLength(descriptors))); #endif Node* value = LoadFixedArrayElement(descriptors, descriptor, 0, INTPTR_PARAMETERS); @@ -5675,7 +5682,7 @@ void CodeStubAssembler::HandleLoadICProtoHandler( Bind(&validity_cell_check_done); Node* smi_handler = LoadObjectField(handler, LoadHandler::kSmiHandlerOffset); - CSA_ASSERT(TaggedIsSmi(smi_handler)); + CSA_ASSERT(this, TaggedIsSmi(smi_handler)); Node* handler_flags = SmiUntag(smi_handler); Label check_prototypes(this); @@ -5705,7 +5712,7 @@ void CodeStubAssembler::HandleLoadICProtoHandler( Node* holder = LoadWeakCellValue(maybe_holder_cell); // The |holder| is guaranteed to be alive at this point since we passed // both the receiver map check and the validity cell check. - CSA_ASSERT(WordNotEqual(holder, IntPtrConstant(0))); + CSA_ASSERT(this, WordNotEqual(holder, IntPtrConstant(0))); var_holder->Bind(holder); var_smi_handler->Bind(smi_handler); @@ -5731,7 +5738,7 @@ void CodeStubAssembler::HandleLoadICProtoHandler( FixedArray::OffsetOfElementAt(LoadHandler::kFirstPrototypeIndex); Node* expected_native_context = LoadWeakCellValue(LoadObjectField(handler, offset), miss); - CSA_ASSERT(IsNativeContext(expected_native_context)); + CSA_ASSERT(this, IsNativeContext(expected_native_context)); Node* native_context = LoadNativeContext(p->context); GotoIf(WordEqual(expected_native_context, native_context), &can_access); @@ -5769,7 +5776,7 @@ void CodeStubAssembler::HandleLoadICProtoHandler( // The |holder| is guaranteed to be alive at this point since we passed // the receiver map check, the validity cell check and the prototype chain // check. - CSA_ASSERT(WordNotEqual(holder, IntPtrConstant(0))); + CSA_ASSERT(this, WordNotEqual(holder, IntPtrConstant(0))); var_holder->Bind(holder); var_smi_handler->Bind(smi_handler); @@ -5791,7 +5798,7 @@ void CodeStubAssembler::CheckPrototype(Node* prototype_cell, Node* name, Bind(&if_dictionary_object); { - CSA_ASSERT(IsDictionaryMap(LoadMap(maybe_prototype))); + CSA_ASSERT(this, IsDictionaryMap(LoadMap(maybe_prototype))); NameDictionaryNegativeLookup(maybe_prototype, name, miss); Goto(&done); } @@ -5809,7 +5816,7 @@ void CodeStubAssembler::CheckPrototype(Node* prototype_cell, Node* name, void CodeStubAssembler::NameDictionaryNegativeLookup(Node* object, Node* name, Label* miss) { - CSA_ASSERT(IsDictionaryMap(LoadMap(object))); + CSA_ASSERT(this, IsDictionaryMap(LoadMap(object))); Node* properties = LoadProperties(object); // Ensure the property does not exist in a dictionary-mode object. Variable var_name_index(this, MachineType::PointerRepresentation()); @@ -6126,8 +6133,8 @@ void CodeStubAssembler::HandleStoreICSmiHandlerCase(Node* handler_word, &if_heap_object_field); GotoIf(WordEqual(field_representation, IntPtrConstant(StoreHandler::kDouble)), &if_double_field); - CSA_ASSERT( - WordEqual(field_representation, IntPtrConstant(StoreHandler::kSmi))); + CSA_ASSERT(this, WordEqual(field_representation, + IntPtrConstant(StoreHandler::kSmi))); Goto(&if_smi_field); Bind(&if_tagged_field); @@ -6332,11 +6339,11 @@ void CodeStubAssembler::LoadGlobalIC(const LoadICParameters* p) { Label try_handler(this), miss(this); Node* weak_cell = LoadFixedArrayElement(p->vector, p->slot, 0, SMI_PARAMETERS); - CSA_ASSERT(HasInstanceType(weak_cell, WEAK_CELL_TYPE)); + CSA_ASSERT(this, HasInstanceType(weak_cell, WEAK_CELL_TYPE)); // Load value or try handler case if the {weak_cell} is cleared. Node* property_cell = LoadWeakCellValue(weak_cell, &try_handler); - CSA_ASSERT(HasInstanceType(property_cell, PROPERTY_CELL_TYPE)); + CSA_ASSERT(this, HasInstanceType(property_cell, PROPERTY_CELL_TYPE)); Node* value = LoadObjectField(property_cell, PropertyCell::kValueOffset); GotoIf(WordEqual(value, TheHoleConstant()), &miss); @@ -6350,7 +6357,7 @@ void CodeStubAssembler::LoadGlobalIC(const LoadICParameters* p) { &miss); // In this case {handler} must be a Code object. - CSA_ASSERT(HasInstanceType(handler, CODE_TYPE)); + CSA_ASSERT(this, HasInstanceType(handler, CODE_TYPE)); LoadWithVectorDescriptor descriptor(isolate()); Node* native_context = LoadNativeContext(p->context); Node* receiver = @@ -6382,9 +6389,9 @@ void CodeStubAssembler::ExtendPropertiesBackingStore(compiler::Node* object) { FixedArrayBase::GetMaxLengthForNewSpaceAllocation(kind)); // The size of a new properties backing store is guaranteed to be small // enough that the new backing store will be allocated in new space. - CSA_ASSERT(UintPtrLessThan( - new_capacity, - IntPtrConstant(kMaxNumberOfDescriptors + JSObject::kFieldsAdded))); + CSA_ASSERT(this, UintPtrLessThan(new_capacity, + IntPtrConstant(kMaxNumberOfDescriptors + + JSObject::kFieldsAdded))); Node* new_properties = AllocateFixedArray(kind, new_capacity, mode); @@ -6531,7 +6538,7 @@ Node* CodeStubAssembler::EmitKeyedSloppyArguments(Node* receiver, Node* key, Bind(&if_mapped); { - CSA_ASSERT(TaggedIsSmi(mapped_index)); + CSA_ASSERT(this, TaggedIsSmi(mapped_index)); mapped_index = SmiUntag(mapped_index); Node* the_context = LoadFixedArrayElement(elements, IntPtrConstant(0), 0, INTPTR_PARAMETERS); @@ -6543,7 +6550,7 @@ Node* CodeStubAssembler::EmitKeyedSloppyArguments(Node* receiver, Node* key, if (is_load) { Node* result = LoadFixedArrayElement(the_context, mapped_index, 0, INTPTR_PARAMETERS); - CSA_ASSERT(WordNotEqual(result, TheHoleConstant())); + CSA_ASSERT(this, WordNotEqual(result, TheHoleConstant())); var_result.Bind(result); } else { StoreFixedArrayElement(the_context, mapped_index, value, @@ -6937,7 +6944,7 @@ Node* CodeStubAssembler::PageFromAddress(Node* address) { } Node* CodeStubAssembler::EnumLength(Node* map) { - CSA_ASSERT(IsMap(map)); + CSA_ASSERT(this, IsMap(map)); Node* bitfield_3 = LoadMapBitField3(map); Node* enum_length = DecodeWordFromWord32(bitfield_3); return SmiTag(enum_length); @@ -7202,7 +7209,7 @@ void CodeStubAssembler::BranchIfNumericRelationalComparison( Bind(&if_rhsisnotsmi); { - CSA_ASSERT(WordEqual(LoadMap(rhs), HeapNumberMapConstant())); + CSA_ASSERT(this, WordEqual(LoadMap(rhs), HeapNumberMapConstant())); // Convert the {lhs} and {rhs} to floating point values, and // perform a floating point comparison. var_fcmp_lhs.Bind(SmiToFloat64(lhs)); @@ -7213,7 +7220,7 @@ void CodeStubAssembler::BranchIfNumericRelationalComparison( Bind(&if_lhsisnotsmi); { - CSA_ASSERT(WordEqual(LoadMap(lhs), HeapNumberMapConstant())); + CSA_ASSERT(this, WordEqual(LoadMap(lhs), HeapNumberMapConstant())); // Check if {rhs} is a Smi or a HeapObject. Label if_rhsissmi(this), if_rhsisnotsmi(this); @@ -7230,7 +7237,7 @@ void CodeStubAssembler::BranchIfNumericRelationalComparison( Bind(&if_rhsisnotsmi); { - CSA_ASSERT(WordEqual(LoadMap(rhs), HeapNumberMapConstant())); + CSA_ASSERT(this, WordEqual(LoadMap(rhs), HeapNumberMapConstant())); // Convert the {lhs} and {rhs} to floating point values, and // perform a floating point comparison. @@ -8529,7 +8536,7 @@ compiler::Node* CodeStubAssembler::Typeof(compiler::Node* value, SIMD128_TYPES(SIMD128_BRANCH) #undef SIMD128_BRANCH - CSA_ASSERT(Word32Equal(instance_type, Int32Constant(SYMBOL_TYPE))); + CSA_ASSERT(this, Word32Equal(instance_type, Int32Constant(SYMBOL_TYPE))); result_var.Bind(HeapConstant(isolate()->factory()->symbol_string())); Goto(&return_result); @@ -8647,7 +8654,7 @@ compiler::Node* CodeStubAssembler::NumberInc(compiler::Node* value) { Bind(&if_isnotsmi); { // Check if the value is a HeapNumber. - CSA_ASSERT(IsHeapNumberMap(LoadMap(value))); + CSA_ASSERT(this, IsHeapNumberMap(LoadMap(value))); // Load the HeapNumber value. var_finc_value.Bind(LoadHeapNumberValue(value)); @@ -8702,7 +8709,7 @@ compiler::Node* CodeStubAssembler::CreateArrayIterator( Context::UINT8_ARRAY_KEY_VALUE_ITERATOR_MAP_INDEX)); // Assert: Type(array) is Object - CSA_ASSERT(IsJSReceiverInstanceType(array_type)); + CSA_ASSERT(this, IsJSReceiverInstanceType(array_type)); Variable var_result(this, MachineRepresentation::kTagged); Variable var_map_index(this, MachineType::PointerRepresentation()); @@ -8761,10 +8768,12 @@ compiler::Node* CodeStubAssembler::CreateArrayIterator( Node* map_index = IntPtrAdd(IntPtrConstant(kBaseMapIndex + kFastIteratorOffset), LoadMapElementsKind(array_map)); - CSA_ASSERT(IntPtrGreaterThanOrEqual( - map_index, IntPtrConstant(kBaseMapIndex + kFastIteratorOffset))); - CSA_ASSERT(IntPtrLessThan( - map_index, IntPtrConstant(kBaseMapIndex + kSlowIteratorOffset))); + CSA_ASSERT(this, IntPtrGreaterThanOrEqual( + map_index, IntPtrConstant(kBaseMapIndex + + kFastIteratorOffset))); + CSA_ASSERT(this, IntPtrLessThan(map_index, + IntPtrConstant(kBaseMapIndex + + kSlowIteratorOffset))); var_map_index.Bind(map_index); var_array_map.Bind(array_map); @@ -8786,10 +8795,11 @@ compiler::Node* CodeStubAssembler::CreateArrayIterator( Node* map_index = IntPtrAdd(IntPtrConstant(kBaseMapIndex - UINT8_ELEMENTS), LoadMapElementsKind(array_map)); - CSA_ASSERT(IntPtrLessThan( - map_index, IntPtrConstant(kBaseMapIndex + kFastIteratorOffset))); CSA_ASSERT( - IntPtrGreaterThanOrEqual(map_index, IntPtrConstant(kBaseMapIndex))); + this, IntPtrLessThan(map_index, IntPtrConstant(kBaseMapIndex + + kFastIteratorOffset))); + CSA_ASSERT(this, IntPtrGreaterThanOrEqual(map_index, + IntPtrConstant(kBaseMapIndex))); var_map_index.Bind(map_index); var_array_map.Bind(UndefinedConstant()); Goto(&allocate_iterator); @@ -8827,7 +8837,7 @@ compiler::Node* CodeStubAssembler::AllocateJSArrayIterator( } compiler::Node* CodeStubAssembler::IsDetachedBuffer(compiler::Node* buffer) { - CSA_ASSERT(HasInstanceType(buffer, JS_ARRAY_BUFFER_TYPE)); + CSA_ASSERT(this, HasInstanceType(buffer, JS_ARRAY_BUFFER_TYPE)); Node* buffer_bit_field = LoadObjectField( buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32()); diff --git a/src/code-stub-assembler.h b/src/code-stub-assembler.h index 53b8d16893..68b2aa6354 100644 --- a/src/code-stub-assembler.h +++ b/src/code-stub-assembler.h @@ -161,7 +161,8 @@ class V8_EXPORT_PRIVATE CodeStubAssembler : public compiler::CodeAssembler { compiler::Node* offset); compiler::Node* IsRegularHeapObjectSize(compiler::Node* size); - void Assert(compiler::Node* condition, const char* string = nullptr, + typedef std::function ConditionBody; + void Assert(ConditionBody condition_body, const char* string = nullptr, const char* file = nullptr, int line = 0); // Check a value for smi-ness @@ -1263,14 +1264,20 @@ class CodeStubArguments { compiler::Node* fp_; }; -#define CSA_ASSERT(x) Assert((x), #x, __FILE__, __LINE__) +#ifdef DEBUG +#define CSA_ASSERT(csa, x) \ + (csa)->Assert([&] { return (x); }, #x, __FILE__, __LINE__) +#else +#define CSA_ASSERT(csa, x) ((void)0) +#endif + #ifdef ENABLE_SLOW_DCHECKS -#define CSA_SLOW_ASSERT(x) \ - if (FLAG_enable_slow_asserts) { \ - Assert((x), #x, __FILE__, __LINE__); \ +#define CSA_SLOW_ASSERT(csa, x) \ + if (FLAG_enable_slow_asserts) { \ + (csa)->Assert([&] { return (x); }, #x, __FILE__, __LINE__); \ } #else -#define CSA_SLOW_ASSERT(x) +#define CSA_SLOW_ASSERT(csa, x) ((void)0) #endif DEFINE_OPERATORS_FOR_FLAGS(CodeStubAssembler::AllocationFlags); diff --git a/src/code-stubs.cc b/src/code-stubs.cc index 0075d709d7..3ca726ee7e 100644 --- a/src/code-stubs.cc +++ b/src/code-stubs.cc @@ -1754,9 +1754,10 @@ compiler::Node* IncStub::Generate(CodeStubAssembler* assembler, // We do not require an Or with earlier feedback here because once we // convert the value to a number, we cannot reach this path. We can // only reach this path on the first pass when the feedback is kNone. - assembler->Assert(assembler->Word32Equal( - var_type_feedback.value(), - assembler->Int32Constant(BinaryOperationFeedback::kNone))); + CSA_ASSERT(assembler, + assembler->Word32Equal(var_type_feedback.value(), + assembler->Int32Constant( + BinaryOperationFeedback::kNone))); Label if_valueisoddball(assembler), if_valuenotoddball(assembler); Node* instance_type = assembler->LoadMapInstanceType(value_map); @@ -1893,9 +1894,10 @@ compiler::Node* DecStub::Generate(CodeStubAssembler* assembler, // We do not require an Or with earlier feedback here because once we // convert the value to a number, we cannot reach this path. We can // only reach this path on the first pass when the feedback is kNone. - assembler->Assert(assembler->Word32Equal( - var_type_feedback.value(), - assembler->Int32Constant(BinaryOperationFeedback::kNone))); + CSA_ASSERT(assembler, + assembler->Word32Equal(var_type_feedback.value(), + assembler->Int32Constant( + BinaryOperationFeedback::kNone))); Label if_valueisoddball(assembler), if_valuenotoddball(assembler); Node* instance_type = assembler->LoadMapInstanceType(value_map); @@ -2571,12 +2573,13 @@ compiler::Node* FastNewClosureStub::Generate(CodeStubAssembler* assembler, if (FLAG_debug_code) { // Function must be a function without a prototype. - assembler->Assert(assembler->Word32And( - compiler_hints, - assembler->Int32Constant((FunctionKind::kAccessorFunction | - FunctionKind::kArrowFunction | - FunctionKind::kConciseMethod) - << SharedFunctionInfo::kFunctionKindShift))); + CSA_ASSERT(assembler, assembler->Word32And( + compiler_hints, + assembler->Int32Constant( + (FunctionKind::kAccessorFunction | + FunctionKind::kArrowFunction | + FunctionKind::kConciseMethod) + << SharedFunctionInfo::kFunctionKindShift))); } assembler->Goto(&if_function_without_prototype); diff --git a/src/interpreter/interpreter-assembler.cc b/src/interpreter/interpreter-assembler.cc index 1e2fe88eb5..59b4d8ff7c 100644 --- a/src/interpreter/interpreter-assembler.cc +++ b/src/interpreter/interpreter-assembler.cc @@ -1159,8 +1159,9 @@ Node* InterpreterAssembler::TruncateTaggedToWord32WithFeedback( // We do not require an Or with earlier feedback here because once we // convert the value to a number, we cannot reach this path. We can // only reach this path on the first pass when the feedback is kNone. - Assert(Word32Equal(var_type_feedback->value(), - Int32Constant(BinaryOperationFeedback::kNone))); + CSA_ASSERT(this, + Word32Equal(var_type_feedback->value(), + Int32Constant(BinaryOperationFeedback::kNone))); Label if_valueisoddball(this), if_valueisnotoddball(this, Label::kDeferred); diff --git a/test/cctest/test-code-stub-assembler.cc b/test/cctest/test-code-stub-assembler.cc index 19fabe1f4d..8465c83cb0 100644 --- a/test/cctest/test-code-stub-assembler.cc +++ b/test/cctest/test-code-stub-assembler.cc @@ -1925,9 +1925,12 @@ TEST(Arguments) { CodeStubArguments arguments(&m, m.IntPtrConstant(3)); - m.Assert(m.WordEqual(arguments.AtIndex(0), m.SmiConstant(Smi::FromInt(12)))); - m.Assert(m.WordEqual(arguments.AtIndex(1), m.SmiConstant(Smi::FromInt(13)))); - m.Assert(m.WordEqual(arguments.AtIndex(2), m.SmiConstant(Smi::FromInt(14)))); + CSA_ASSERT( + &m, m.WordEqual(arguments.AtIndex(0), m.SmiConstant(Smi::FromInt(12)))); + CSA_ASSERT( + &m, m.WordEqual(arguments.AtIndex(1), m.SmiConstant(Smi::FromInt(13)))); + CSA_ASSERT( + &m, m.WordEqual(arguments.AtIndex(2), m.SmiConstant(Smi::FromInt(14)))); m.Return(arguments.GetReceiver());