[stubs] Ensure CSA_ASSERT and CSA_SLOW_ASSERT do not produce unused instructions in release mode.

src/code-stub-assembler.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "src/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 using compiler::Node;
 
 CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
                                      const CallInterfaceDescriptor& descriptor,
                                      Code::Flags flags, const char* name,
                                      size_t result_size)
     : compiler::CodeAssembler(isolate, zone, descriptor, flags, name,
                               result_size) {}
 
 CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
                                      int parameter_count, Code::Flags flags,
                                      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);
   Label not_ok(this, Label::kDeferred);
   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, &not_ok);
   Bind(&not_ok);
   if (message != nullptr) {
     char chars[1024];
     Vector<char> buffer(chars);
     if (file != nullptr) {
       SNPrintF(buffer, "CSA_ASSERT failed: %s [%s:%d]\n", message, file, line);
     } else {
       SNPrintF(buffer, "CSA_ASSERT failed: %s\n", message);
     }
@@ skipping 73 matching lines @@
   } else if (is_right_constant) {
     if (right_constant == 0) {
       return left;
     }
   }
   return IntPtrSub(left, 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)));
   }
   return IntPtrAdd(value, IntPtrConstant(1));
 }
 
 Node* CodeStubAssembler::WordIsPowerOfTwo(Node* value) {
   // value && !(value & (value - 1))
   return WordEqual(
@@ skipping 859 matching lines @@
 
 Node* CodeStubAssembler::LoadProperties(Node* object) {
   return LoadObjectField(object, JSObject::kPropertiesOffset);
 }
 
 Node* CodeStubAssembler::LoadElements(Node* object) {
   return LoadObjectField(object, JSObject::kElementsOffset);
 }
 
 Node* CodeStubAssembler::LoadJSArrayLength(Node* array) {
-  CSA_ASSERT(IsJSArray(array));
+  CSA_ASSERT(this, IsJSArray(array));
   return LoadObjectField(array, JSArray::kLengthOffset);
 }
 
 Node* CodeStubAssembler::LoadFixedArrayBaseLength(Node* array) {
   return LoadObjectField(array, FixedArrayBase::kLengthOffset);
 }
 
 Node* CodeStubAssembler::LoadAndUntagFixedArrayBaseLength(Node* array) {
   return LoadAndUntagObjectField(array, FixedArrayBase::kLengthOffset);
 }
 
 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());
 }
 
 Node* CodeStubAssembler::LoadMapInstanceType(Node* map) {
   return LoadObjectField(map, Map::kInstanceTypeOffset, MachineType::Uint8());
 }
 
 Node* CodeStubAssembler::LoadMapElementsKind(Node* map) {
-  CSA_SLOW_ASSERT(IsMap(map));
+  CSA_SLOW_ASSERT(this, IsMap(map));
   Node* bit_field2 = LoadMapBitField2(map);
   return DecodeWord32<Map::ElementsKindBits>(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);
   GotoUnless(WordEqual(LoadMap(prototype_info),
                        LoadRoot(Heap::kPrototypeInfoMapRootIndex)),
              if_no_proto_info);
   return prototype_info;
 }
 
 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,
       MachineType::Uint8()));
 }
 
 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));
 
   Label done(this), loop(this, &result);
   Goto(&loop);
   Bind(&loop);
   {
     GotoIf(TaggedIsSmi(result.value()), &done);
     Node* is_map_type =
         Word32Equal(LoadInstanceType(result.value()), Int32Constant(MAP_TYPE));
     GotoUnless(is_map_type, &done);
     result.Bind(
         LoadObjectField(result.value(), Map::kConstructorOrBackPointerOffset));
     Goto(&loop);
   }
   Bind(&done);
   return result.value();
 }
 
 Node* CodeStubAssembler::LoadNameHashField(Node* name) {
-  CSA_ASSERT(IsName(name));
+  CSA_ASSERT(this, IsName(name));
   return LoadObjectField(name, Name::kHashFieldOffset, MachineType::Uint32());
 }
 
 Node* CodeStubAssembler::LoadNameHash(Node* name, Label* if_hash_not_computed) {
   Node* hash_field = LoadNameHashField(name);
   if (if_hash_not_computed != nullptr) {
     GotoIf(Word32Equal(
                Word32And(hash_field, Int32Constant(Name::kHashNotComputedMask)),
                Int32Constant(0)),
            if_hash_not_computed);
   }
   return Word32Shr(hash_field, Int32Constant(Name::kHashShift));
 }
 
 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);
 }
 
 Node* CodeStubAssembler::LoadWeakCellValueUnchecked(Node* weak_cell) {
   // TODO(ishell): fix callers.
   return LoadObjectField(weak_cell, WeakCell::kValueOffset);
 }
 
 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);
   }
   return value;
 }
 
 Node* CodeStubAssembler::LoadFixedArrayElement(Node* object, Node* index_node,
                                                int additional_offset,
                                                ParameterMode parameter_mode) {
@@ skipping 57 matching lines @@
   if (Is64()) {
     return Load(MachineType::Int32(), object, offset);
   } else {
     return SmiToWord32(Load(MachineType::AnyTagged(), object, offset));
   }
 }
 
 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,
                                         parameter_mode, header_size);
   return LoadDoubleWithHoleCheck(object, offset, if_hole, machine_type);
 }
 
 Node* CodeStubAssembler::LoadDoubleWithHoleCheck(Node* base, Node* offset,
                                                  Label* if_hole,
                                                  MachineType machine_type) {
@@ skipping 45 matching lines @@
                 IntPtrConstant(Context::kHeaderSize - kHeapObjectTag));
   return Store(MachineRepresentation::kTagged, context, offset, value);
 }
 
 Node* CodeStubAssembler::LoadNativeContext(Node* context) {
   return LoadContextElement(context, Context::NATIVE_CONTEXT_INDEX);
 }
 
 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)));
 }
 
 Node* CodeStubAssembler::StoreHeapNumberValue(Node* object, Node* value) {
   return StoreObjectFieldNoWriteBarrier(object, HeapNumber::kValueOffset, value,
                                         MachineRepresentation::kFloat64);
 }
 
 Node* CodeStubAssembler::StoreObjectField(
@@ skipping 55 matching lines @@
   MachineRepresentation rep = MachineRepresentation::kTagged;
   if (barrier_mode == SKIP_WRITE_BARRIER) {
     return StoreNoWriteBarrier(rep, object, offset, value);
   } else {
     return Store(rep, object, offset, value);
   }
 }
 
 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);
   MachineRepresentation rep = MachineRepresentation::kFloat64;
   return StoreNoWriteBarrier(rep, object, offset, value);
 }
 
 Node* CodeStubAssembler::AllocateHeapNumber(MutableMode mode) {
   Node* result = Allocate(HeapNumber::kSize, kNone);
   Heap::RootListIndex heap_map_index =
@@ skipping 127 matching lines @@
     Goto(&if_join);
   }
 
   Bind(&if_join);
   return var_result.value();
 }
 
 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));
   StoreMapNoWriteBarrier(result, map);
   StoreObjectFieldNoWriteBarrier(result, SlicedString::kLengthOffset, length,
                                  MachineRepresentation::kTagged);
   StoreObjectFieldNoWriteBarrier(result, SlicedString::kHashFieldOffset,
                                  Int32Constant(String::kEmptyHashField),
                                  MachineRepresentation::kWord32);
   StoreObjectFieldNoWriteBarrier(result, SlicedString::kParentOffset, parent,
@@ skipping 12 matching lines @@
 Node* CodeStubAssembler::AllocateSlicedTwoByteString(Node* length, Node* parent,
                                                      Node* offset) {
   return AllocateSlicedString(Heap::kSlicedStringMapRootIndex, length, parent,
                               offset);
 }
 
 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));
   StoreMapNoWriteBarrier(result, map);
   StoreObjectFieldNoWriteBarrier(result, ConsString::kLengthOffset, length,
                                  MachineRepresentation::kTagged);
   StoreObjectFieldNoWriteBarrier(result, ConsString::kHashFieldOffset,
                                  Int32Constant(String::kEmptyHashField),
                                  MachineRepresentation::kWord32);
   bool const new_space = !(flags & kPretenured);
@@ skipping 18 matching lines @@
 
 Node* CodeStubAssembler::AllocateTwoByteConsString(Node* length, Node* first,
                                                    Node* second,
                                                    AllocationFlags flags) {
   return AllocateConsString(Heap::kConsStringMapRootIndex, length, first,
                             second, flags);
 }
 
 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);
   Node* right_instance_type = LoadInstanceType(right);
 
   // Compute intersection and difference of instance types.
   Node* anded_instance_types = WordAnd(left_instance_type, right_instance_type);
   Node* xored_instance_types = WordXor(left_instance_type, right_instance_type);
 
   // We create a one-byte cons string if
@@ skipping 34 matching lines @@
 
   Bind(&done);
 
   return result.value();
 }
 
 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
   // unneeded store of elements.
   Node* const result = Allocate(JSRegExpResult::kSize);
 
   // TODO(jgruber): Store map as Heap constant?
   Node* const native_context = LoadNativeContext(context);
   Node* const map =
       LoadContextElement(native_context, Context::REGEXP_RESULT_MAP_INDEX);
@@ skipping 24 matching lines @@
                           Heap::kUndefinedValueRootIndex, parameter_mode);
 
   return result;
 }
 
 Node* CodeStubAssembler::AllocateNameDictionary(int at_least_space_for) {
   return AllocateNameDictionary(IntPtrConstant(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<NameDictionary>(capacity);
   Node* store_size =
       IntPtrAddFoldConstants(WordShl(length, IntPtrConstant(kPointerSizeLog2)),
                              IntPtrConstant(NameDictionary::kHeaderSize));
 
   Node* result = Allocate(store_size);
   Comment("Initialize NameDictionary");
   // Initialize FixedArray fields.
   StoreObjectFieldRoot(result, FixedArray::kMapOffset,
@@ skipping 24 matching lines @@
                              kHeapObjectTag));
   Node* end_address = IntPtrAdd(
       result,
       IntPtrSubFoldConstants(store_size, IntPtrConstant(kHeapObjectTag)));
   StoreFieldsNoWriteBarrier(start_address, end_address, filler);
   return result;
 }
 
 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);
   return object;
 }
 
 void CodeStubAssembler::InitializeJSObjectFromMap(Node* object, Node* map,
                                                   Node* size, Node* properties,
                                                   Node* elements) {
   // 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 {
     StoreObjectFieldNoWriteBarrier(object, JSObject::kPropertiesOffset,
                                    properties);
   }
   if (elements == nullptr) {
     StoreObjectFieldRoot(object, JSObject::kElementsOffset,
                          Heap::kEmptyFixedArrayRootIndex);
   } else {
@@ skipping 12 matching lines @@
       IntPtrAdd(object, IntPtrConstant(start_offset - kHeapObjectTag));
   Node* end_address =
       IntPtrSub(IntPtrAdd(object, size), IntPtrConstant(kHeapObjectTag));
   StoreFieldsNoWriteBarrier(start_address, end_address, filler);
 }
 
 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) {
         a->StoreNoWriteBarrier(MachineRepresentation::kTagged, current, value);
       },
       kPointerSize, IndexAdvanceMode::kPost);
 }
 
 Node* CodeStubAssembler::AllocateUninitializedJSArrayWithoutElements(
     ElementsKind kind, Node* array_map, Node* length, Node* allocation_site) {
@@ skipping 81 matching lines @@
                                                       : IntPtrConstant(0),
       capacity, Heap::kTheHoleValueRootIndex, capacity_mode);
 
   return array;
 }
 
 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.
   Node* array = Allocate(total_size, flags);
   Heap* heap = isolate()->heap();
   Handle<Map> map(IsFastDoubleElementsKind(kind)
                       ? heap->fixed_double_array_map()
                       : heap->fixed_array_map());
   if (flags & kPretenured) {
     StoreObjectField(array, JSObject::kMapOffset, HeapConstant(map));
@@ skipping 747 matching lines @@
       value);
   var_value_map.Bind(UndefinedConstant());
   Goto(&out);  // Never reached.
 
   Bind(&out);
   return var_value_map.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<Map::DictionaryMap>(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));
 }
 
 Node* CodeStubAssembler::IsSpecialReceiverInstanceType(Node* instance_type) {
   STATIC_ASSERT(JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE);
   return Int32LessThanOrEqual(instance_type,
                               Int32Constant(LAST_SPECIAL_RECEIVER_TYPE));
 }
@@ skipping 66 matching lines @@
 Node* CodeStubAssembler::IsDictionary(Node* object) {
   return WordOr(IsHashTable(object), IsUnseededNumberDictionary(object));
 }
 
 Node* CodeStubAssembler::IsUnseededNumberDictionary(Node* object) {
   return WordEqual(LoadMap(object),
                    LoadRoot(Heap::kUnseededNumberDictionaryMapRootIndex));
 }
 
 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);
 
   // We may need to loop in case of cons or sliced strings.
   Variable var_index(this, MachineType::PointerRepresentation());
   Variable var_result(this, MachineRepresentation::kWord32);
   Variable var_string(this, MachineRepresentation::kTagged);
   Variable* loop_vars[] = {&var_index, &var_string};
   Label done_loop(this, &var_result), loop(this, 2, loop_vars);
   var_string.Bind(string);
@@ skipping 511 matching lines @@
   result.Bind(right);
   Goto(&done_native);
 
   Bind(&check_right);
   Node* right_length = LoadStringLength(right);
   GotoIf(WordNotEqual(IntPtrConstant(0), right_length), &cons);
   result.Bind(left);
   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))),
          &runtime);
 
   GotoIf(IntPtrLessThan(new_length,
                         SmiConstant(Smi::FromInt(ConsString::kMinLength))),
          &non_cons);
 
   result.Bind(NewConsString(context, new_length, left, right, flags));
@@ skipping 63 matching lines @@
     IncrementCounter(counters->string_add_native(), 1);
     Goto(&done);
   }
 
   Bind(&done);
   return result.value();
 }
 
 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);
 
   // Let runtime handle non-one-byte {needle_char}.
 
   Node* const one_byte_char_mask = IntPtrConstant(0xFF);
   GotoUnless(WordEqual(WordAnd(needle_char, one_byte_char_mask), needle_char),
              &runtime);
 
@@ skipping 251 matching lines @@
       Goto(&end);
     }
   }
 
   Bind(&end);
   return var_result.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);
   Variable var_result(this, MachineRepresentation::kTagged);
   Label loop(this, &var_input);
   Label end(this);
   var_input.Bind(input);
   Goto(&loop);
   Bind(&loop);
   {
@@ skipping 136 matching lines @@
   {
     result.Bind(CallRuntime(Runtime::kToString, context, input));
     Goto(&done);
   }
 
   Bind(&done);
   return result.value();
 }
 
 Node* CodeStubAssembler::FlattenString(Node* string) {
-  CSA_ASSERT(IsString(string));
+  CSA_ASSERT(this, IsString(string));
   Variable var_result(this, MachineRepresentation::kTagged);
   var_result.Bind(string);
 
   Node* instance_type = LoadInstanceType(string);
 
   // Check if the {string} is not a ConsString (i.e. already flat).
   Label is_cons(this, Label::kDeferred), is_flat_in_cons(this), end(this);
   {
     GotoUnless(Word32Equal(Word32And(instance_type,
                                      Int32Constant(kStringRepresentationMask)),
@@ skipping 213 matching lines @@
   return Select(IntPtrGreaterThanOrEqual(left, right), left, right,
                 MachineType::PointerRepresentation());
 }
 
 template <typename Dictionary>
 void CodeStubAssembler::NameDictionaryLookup(Node* dictionary,
                                              Node* unique_name, Label* if_found,
                                              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");
 
   Node* capacity = SmiUntag(LoadFixedArrayElement(
       dictionary, IntPtrConstant(Dictionary::kCapacityIndex), 0,
       INTPTR_PARAMETERS));
   Node* mask = IntPtrSub(capacity, IntPtrConstant(1));
   Node* hash = ChangeUint32ToWord(LoadNameHash(unique_name));
 
   // See Dictionary::FirstProbe().
@@ skipping 64 matching lines @@
   hash = Word32Xor(hash, Word32Shr(hash, Int32Constant(16)));
   return Word32And(hash, Int32Constant(0x3fffffff));
 }
 
 template <typename Dictionary>
 void CodeStubAssembler::NumberDictionaryLookup(Node* dictionary,
                                                Node* intptr_index,
                                                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");
 
   Node* capacity = SmiUntag(LoadFixedArrayElement(
       dictionary, IntPtrConstant(Dictionary::kCapacityIndex), 0,
       INTPTR_PARAMETERS));
   Node* mask = IntPtrSub(capacity, IntPtrConstant(1));
 
   Node* int32_seed;
   if (Dictionary::ShapeT::UsesSeed) {
@@ skipping 86 matching lines @@
     Label* if_bailout) {
   DCHECK_EQ(MachineRepresentation::kTagged, var_meta_storage->rep());
   DCHECK_EQ(MachineType::PointerRepresentation(), var_name_index->rep());
 
   Label if_objectisspecial(this);
   STATIC_ASSERT(JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE);
   GotoIf(Int32LessThanOrEqual(instance_type,
                               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);
   Branch(IsSetWord32<Map::DictionaryMap>(bit_field3), &if_isslowmap,
          &if_isfastmap);
   Bind(&if_isfastmap);
   {
     Comment("DescriptorArrayLookup");
     Node* nof =
         DecodeWordFromWord32<Map::NumberOfOwnDescriptorsBits>(bit_field3);
@@ skipping 172 matching lines @@
   Bind(&done);
 
   Comment("] LoadPropertyFromFastObject");
 }
 
 void CodeStubAssembler::LoadPropertyFromNameDictionary(Node* dictionary,
                                                        Node* name_index,
                                                        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;
   const int name_to_value_offset =
       (NameDictionary::kEntryValueIndex - NameDictionary::kEntryKeyIndex) *
       kPointerSize;
 
   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));
 
   Comment("] LoadPropertyFromNameDictionary");
 }
 
 void CodeStubAssembler::LoadPropertyFromGlobalDictionary(Node* dictionary,
                                                          Node* name_index,
                                                          Variable* var_details,
                                                          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) *
       kPointerSize;
 
   Node* property_cell =
       LoadFixedArrayElement(dictionary, name_index, name_to_value_offset);
 
   Node* value = LoadObjectField(property_cell, PropertyCell::kValueOffset);
   GotoIf(WordEqual(value, TheHoleConstant()), if_deleted);
@@ skipping 19 matching lines @@
 
   Node* kind = DecodeWord32<PropertyDetails::KindField>(details);
   GotoIf(Word32Equal(kind, Int32Constant(kData)), &done);
 
   // Accessor case.
   {
     Node* accessor_pair = value;
     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);
     // FunctionTemplateInfo getters are not supported yet.
     GotoIf(
         Word32Equal(instance_type, Int32Constant(FUNCTION_TEMPLATE_INFO_TYPE)),
         if_bailout);
 
     // Return undefined if the {getter} is not callable.
     var_value.Bind(UndefinedConstant());
@@ skipping 134 matching lines @@
   }
   Bind(&if_isdictionary);
   {
     Variable var_entry(this, MachineType::PointerRepresentation());
     Node* elements = LoadElements(object);
     NumberDictionaryLookup<SeededNumberDictionary>(
         elements, intptr_index, if_found, &var_entry, if_not_found);
   }
   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);
   }
   Bind(&if_oob);
   {
     // Positive OOB indices mean "not found", negative indices must be
     // converted to property names.
     GotoIf(IntPtrLessThan(intptr_index, IntPtrConstant(0)), if_bailout);
     Goto(if_not_found);
@@ skipping 452 matching lines @@
   // The loop falls through if no handler was found.
   Goto(if_miss);
 }
 
 compiler::Node* CodeStubAssembler::StubCachePrimaryOffset(compiler::Node* name,
                                                           compiler::Node* map) {
   // See v8::internal::StubCache::PrimaryOffset().
   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
   // 4Gb (and not at all if it isn't).
   Node* hash = Int32Add(hash_field, map);
   // Base the offset on a simple combination of name and map.
   hash = Word32Xor(hash, Int32Constant(StubCache::kPrimaryMagic));
   uint32_t mask = (StubCache::kPrimaryTableSize - 1)
                   << StubCache::kCacheIndexShift;
   return ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
@@ skipping 455 matching lines @@
       Return(AllocateHeapNumberWithValue(var_double_value.value()));
     }
 
     Bind(&constant);
     {
       Comment("constant_load");
       Node* descriptors = LoadMapDescriptors(LoadMap(holder));
       Node* descriptor =
           DecodeWord<LoadHandler::DescriptorValueIndexBits>(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);
 
       Label if_accessor_info(this);
       GotoIf(IsSetWord<LoadHandler::IsAccessorInfoBits>(handler_word),
              &if_accessor_info);
       Return(value);
 
       Bind(&if_accessor_info);
@@ skipping 41 matching lines @@
   GotoIf(WordEqual(validity_cell, IntPtrConstant(0)),
          &validity_cell_check_done);
   Node* cell_value = LoadObjectField(validity_cell, Cell::kValueOffset);
   GotoIf(WordNotEqual(cell_value,
                       SmiConstant(Smi::FromInt(Map::kPrototypeChainValid))),
          miss);
   Goto(&validity_cell_check_done);
 
   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);
   GotoUnless(
       IsSetWord<LoadHandler::DoNegativeLookupOnReceiverBits>(handler_flags),
       &check_prototypes);
   {
     // We have a dictionary receiver, do a negative lookup check.
     NameDictionaryNegativeLookup(p->receiver, p->name, miss);
     Goto(&check_prototypes);
   }
 
   Bind(&check_prototypes);
   Node* maybe_holder_cell =
       LoadObjectField(handler, LoadHandler::kHolderCellOffset);
   Label array_handler(this), tuple_handler(this);
   Branch(TaggedIsSmi(maybe_holder_cell), &array_handler, &tuple_handler);
 
   Bind(&tuple_handler);
   {
     Label load_existent(this);
     GotoIf(WordNotEqual(maybe_holder_cell, NullConstant()), &load_existent);
     // This is a handler for a load of a non-existent value.
     Return(UndefinedConstant());
 
     Bind(&load_existent);
     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);
     Goto(if_smi_handler);
   }
 
   Bind(&array_handler);
   {
     Node* length = SmiUntag(maybe_holder_cell);
 
     Variable start_index(this, MachineType::PointerRepresentation());
     start_index.Bind(IntPtrConstant(LoadHandler::kFirstPrototypeIndex));
 
     Label can_access(this);
     GotoUnless(
         IsSetWord<LoadHandler::DoAccessCheckOnReceiverBits>(handler_flags),
         &can_access);
     {
       // Skip this entry of a handler.
       start_index.Bind(IntPtrConstant(LoadHandler::kFirstPrototypeIndex + 1));
 
       int offset =
           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);
       // If the receiver is not a JSGlobalProxy then we miss.
       GotoUnless(IsJSGlobalProxy(p->receiver), miss);
       // For JSGlobalProxy receiver try to compare security tokens of current
       // and expected native contexts.
       Node* expected_token = LoadContextElement(expected_native_context,
                                                 Context::SECURITY_TOKEN_INDEX);
       Node* current_token =
@@ skipping 17 matching lines @@
     Label load_existent(this);
     GotoIf(WordNotEqual(maybe_holder_cell, NullConstant()), &load_existent);
     // This is a handler for a load of a non-existent value.
     Return(UndefinedConstant());
 
     Bind(&load_existent);
     Node* holder = LoadWeakCellValue(maybe_holder_cell);
     // 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);
     Goto(if_smi_handler);
   }
 }
 
 void CodeStubAssembler::CheckPrototype(Node* prototype_cell, Node* name,
                                        Label* miss) {
   Node* maybe_prototype = LoadWeakCellValue(prototype_cell, miss);
 
   Label done(this);
   Label if_property_cell(this), if_dictionary_object(this);
 
   // |maybe_prototype| is either a PropertyCell or a slow-mode prototype.
   Branch(WordEqual(LoadMap(maybe_prototype),
                    LoadRoot(Heap::kGlobalPropertyCellMapRootIndex)),
          &if_property_cell, &if_dictionary_object);
 
   Bind(&if_dictionary_object);
   {
-    CSA_ASSERT(IsDictionaryMap(LoadMap(maybe_prototype)));
+    CSA_ASSERT(this, IsDictionaryMap(LoadMap(maybe_prototype)));
     NameDictionaryNegativeLookup(maybe_prototype, name, miss);
     Goto(&done);
   }
 
   Bind(&if_property_cell);
   {
     // Ensure the property cell still contains the hole.
     Node* value = LoadObjectField(maybe_prototype, PropertyCell::kValueOffset);
     GotoIf(WordNotEqual(value, LoadRoot(Heap::kTheHoleValueRootIndex)), miss);
     Goto(&done);
   }
 
   Bind(&done);
 }
 
 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());
   Label done(this);
   NameDictionaryLookup<NameDictionary>(properties, name, miss, &var_name_index,
                                        &done);
   Bind(&done);
 }
 
 void CodeStubAssembler::LoadIC(const LoadICParameters* p) {
@@ skipping 296 matching lines @@
   Label if_smi_field(this), if_double_field(this), if_heap_object_field(this),
       if_tagged_field(this);
 
   GotoIf(WordEqual(field_representation, IntPtrConstant(StoreHandler::kTagged)),
          &if_tagged_field);
   GotoIf(WordEqual(field_representation,
                    IntPtrConstant(StoreHandler::kHeapObject)),
          &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);
   {
     Comment("store tagged field");
     HandleStoreFieldAndReturn(handler_word, holder, Representation::Tagged(),
                               value, transition_to_field, miss);
   }
 
   Bind(&if_double_field);
@@ skipping 184 matching lines @@
     Comment("KeyedStoreIC_miss");
     TailCallRuntime(Runtime::kKeyedStoreIC_Miss, p->context, p->value, p->slot,
                     p->vector, p->receiver, p->name);
   }
 }
 
 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);
   Return(value);
 
   Bind(&try_handler);
   {
     Node* handler =
         LoadFixedArrayElement(p->vector, p->slot, kPointerSize, SMI_PARAMETERS);
     GotoIf(WordEqual(handler, LoadRoot(Heap::kuninitialized_symbolRootIndex)),
            &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 =
         LoadContextElement(native_context, Context::EXTENSION_INDEX);
     Node* fake_name = IntPtrConstant(0);
     TailCallStub(descriptor, handler, p->context, receiver, fake_name, p->slot,
                  p->vector);
   }
   Bind(&miss);
   {
@@ skipping 11 matching lines @@
 
   Node* delta = IntPtrOrSmiConstant(JSObject::kFieldsAdded, mode);
   Node* new_capacity = IntPtrAdd(length, delta);
 
   // Grow properties array.
   ElementsKind kind = FAST_ELEMENTS;
   DCHECK(kMaxNumberOfDescriptors + JSObject::kFieldsAdded <
          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);
 
   FillFixedArrayWithValue(kind, new_properties, length, new_capacity,
                           Heap::kUndefinedValueRootIndex, mode);
 
   // |new_properties| is guaranteed to be in new space, so we can skip
   // the write barrier.
   CopyFixedArrayElements(kind, properties, new_properties, length,
                          SKIP_WRITE_BARRIER, mode);
@@ skipping 126 matching lines @@
   Node* adjusted_length = IntPtrSub(elements_length, intptr_two);
 
   GotoIf(UintPtrGreaterThanOrEqual(key, adjusted_length), &if_unmapped);
 
   Node* mapped_index = LoadFixedArrayElement(
       elements, IntPtrAdd(key, intptr_two), 0, INTPTR_PARAMETERS);
   Branch(WordEqual(mapped_index, TheHoleConstant()), &if_unmapped, &if_mapped);
 
   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);
     // Assert that we can use LoadFixedArrayElement/StoreFixedArrayElement
     // methods for accessing Context.
     STATIC_ASSERT(Context::kHeaderSize == FixedArray::kHeaderSize);
     DCHECK_EQ(Context::SlotOffset(0) + kHeapObjectTag,
               FixedArray::OffsetOfElementAt(0));
     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,
                              UPDATE_WRITE_BARRIER, INTPTR_PARAMETERS);
     }
     Goto(&end);
   }
 
   Bind(&if_unmapped);
   {
@@ skipping 373 matching lines @@
   }
   Bind(&no_memento_found);
   Comment("] TrapAllocationMemento");
 }
 
 Node* CodeStubAssembler::PageFromAddress(Node* address) {
   return WordAnd(address, IntPtrConstant(~Page::kPageAlignmentMask));
 }
 
 Node* CodeStubAssembler::EnumLength(Node* map) {
-  CSA_ASSERT(IsMap(map));
+  CSA_ASSERT(this, IsMap(map));
   Node* bitfield_3 = LoadMapBitField3(map);
   Node* enum_length = DecodeWordFromWord32<Map::EnumLengthBits>(bitfield_3);
   return SmiTag(enum_length);
 }
 
 void CodeStubAssembler::CheckEnumCache(Node* receiver, Label* use_cache,
                                        Label* use_runtime) {
   Variable current_js_object(this, MachineRepresentation::kTagged);
   current_js_object.Bind(receiver);
 
@@ skipping 244 matching lines @@
           BranchIfSmiLessThan(rhs, lhs, if_true, if_false);
           break;
         case kGreaterThanOrEqual:
           BranchIfSmiLessThanOrEqual(rhs, lhs, if_true, if_false);
           break;
       }
     }
 
     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));
       var_fcmp_rhs.Bind(LoadHeapNumberValue(rhs));
       Goto(&do_fcmp);
     }
   }
 
   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);
     Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);
 
     Bind(&if_rhsissmi);
     {
       // Convert the {lhs} and {rhs} to floating point values, and
       // perform a floating point comparison.
       var_fcmp_lhs.Bind(LoadHeapNumberValue(lhs));
       var_fcmp_rhs.Bind(SmiToFloat64(rhs));
       Goto(&do_fcmp);
     }
 
     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(LoadHeapNumberValue(lhs));
       var_fcmp_rhs.Bind(LoadHeapNumberValue(rhs));
       Goto(&do_fcmp);
     }
   }
 
   Bind(&do_fcmp);
@@ skipping 1278 matching lines @@
 
   GotoIf(IsStringInstanceType(instance_type), &return_string);
 
 #define SIMD128_BRANCH(TYPE, Type, type, lane_count, lane_type) \
   Label return_##type(this);                                    \
   Node* type##_map = HeapConstant(factory()->type##_map());     \
   GotoIf(WordEqual(map, type##_map), &return_##type);
   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);
 
   Bind(&return_number);
   {
     result_var.Bind(HeapConstant(isolate()->factory()->number_string()));
     Goto(&return_result);
   }
 
   Bind(&if_oddball);
@@ skipping 97 matching lines @@
     Bind(&if_overflow);
     {
       var_finc_value.Bind(SmiToFloat64(value));
       Goto(&do_finc);
     }
   }
 
   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));
     Goto(&do_finc);
   }
 
   Bind(&do_finc);
   {
     Node* finc_value = var_finc_value.value();
     Node* one = Float64Constant(1.0);
@@ skipping 34 matching lines @@
 
   // Slow Array iterator map index: (kBaseIndex + kSlowIteratorOffset)
   const int kSlowIteratorOffset =
       Context::GENERIC_ARRAY_VALUE_ITERATOR_MAP_INDEX -
       Context::UINT8_ARRAY_VALUE_ITERATOR_MAP_INDEX;
   STATIC_ASSERT(kSlowIteratorOffset ==
                 (Context::GENERIC_ARRAY_KEY_VALUE_ITERATOR_MAP_INDEX -
                  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());
   Variable var_array_map(this, MachineRepresentation::kTagged);
 
   Label return_result(this);
   Label allocate_iterator(this);
 
   if (mode == IterationKind::kKeys) {
     // There are only two key iterator maps, branch depending on whether or not
@@ skipping 38 matching lines @@
     Bind(&if_isgeneric);
     {
       Label if_isfast(this), if_isslow(this);
       BranchIfFastJSArray(array, context, &if_isfast, &if_isslow);
 
       Bind(&if_isfast);
       {
         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);
         Goto(&allocate_iterator);
       }
 
       Bind(&if_isslow);
       {
         Node* map_index = IntPtrAdd(IntPtrConstant(kBaseMapIndex),
                                     IntPtrConstant(kSlowIteratorOffset));
         var_map_index.Bind(map_index);
         var_array_map.Bind(UndefinedConstant());
         Goto(&allocate_iterator);
       }
     }
 
     Bind(&if_istypedarray);
     {
       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);
     }
   }
 
   Bind(&allocate_iterator);
   {
     Node* map =
         LoadFixedArrayElement(LoadNativeContext(context), var_map_index.value(),
@@ skipping 17 matching lines @@
   StoreObjectFieldNoWriteBarrier(iterator,
                                  JSArrayIterator::kIteratedObjectOffset, array);
   StoreObjectFieldNoWriteBarrier(iterator, JSArrayIterator::kNextIndexOffset,
                                  SmiConstant(Smi::FromInt(0)));
   StoreObjectFieldNoWriteBarrier(
       iterator, JSArrayIterator::kIteratedObjectMapOffset, array_map);
   return iterator;
 }
 
 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());
   Node* was_neutered_mask = Int32Constant(JSArrayBuffer::WasNeutered::kMask);
 
   return Word32NotEqual(Word32And(buffer_bit_field, was_neutered_mask),
                         Int32Constant(0));
 }
 
 CodeStubArguments::CodeStubArguments(CodeStubAssembler* assembler,
@@ skipping 62 matching lines @@
 }
 
 void CodeStubArguments::PopAndReturn(compiler::Node* value) {
   assembler_->PopAndReturn(
       assembler_->IntPtrAddFoldConstants(argc_, assembler_->IntPtrConstant(1)),
       value);
 }
 
 }  // namespace internal
 }  // namespace v8