[cleanpup][ic] Tnodify accessor-assembler

Bug: v8:9810 Change-Id: I30c6265904c43ec86abc91a28d789fe5bfb22694 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1910106 Commit-Queue: Mythri Alle <mythria@chromium.org> Reviewed-by: Santiago Aboy Solanes <solanes@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Cr-Commit-Position: refs/heads/master@{#64934}

[cleanpup][ic] Tnodify accessor-assembler
Bug: v8:9810 Change-Id: I30c6265904c43ec86abc91a28d789fe5bfb22694 Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1910106 Commit-Queue: Mythri Alle <mythria@chromium.org> Reviewed-by: Santiago Aboy Solanes <solanes@chromium.org> Reviewed-by: Igor Sheludko <ishell@chromium.org> Cr-Commit-Position: refs/heads/master@{#64934}
1f1e4cdb · Mythri A · Commit Bot · 53201194 · 1f1e4cdb · 1f1e4cdb
Commit 1f1e4cdb authored Nov 12, 2019 by Mythri A Committed by Commit Bot Nov 13, 2019
4 changed files
--- a/src/ic/accessor-assembler.cc
+++ b/src/ic/accessor-assembler.cc
@@ -30,7 +30,7 @@ using compiler::Node;
 // Loads dataX field from the DataHandler object.
 TNode<MaybeObject> AccessorAssembler::LoadHandlerDataField(
-    SloppyTNode<DataHandler> handler, int data_index) {
+    TNode<DataHandler> handler, int data_index) {
 #ifdef DEBUG
  TNode<Map> handler_map = LoadMap(handler);
  TNode<Uint16T> instance_type = LoadMapInstanceType(handler_map);
@@ -139,8 +139,8 @@ void AccessorAssembler::HandleLoadICHandlerCase(
    ElementSupport support_elements, LoadAccessMode access_mode) {
  Comment("have_handler");
-  VARIABLE(var_holder, MachineRepresentation::kTagged, p->holder());
+  TVARIABLE(Object, var_holder, p->holder());
-  VARIABLE(var_smi_handler, MachineRepresentation::kTagged, handler);
+  TVARIABLE(Object, var_smi_handler, handler);
  Variable* vars[] = {&var_holder, &var_smi_handler};
  Label if_smi_handler(this, 2, vars);
@@ -161,14 +161,14 @@ void AccessorAssembler::HandleLoadICHandlerCase(
  // for the encoding format.
  BIND(&if_smi_handler);
  {
-    HandleLoadICSmiHandlerCase(p, var_holder.value(), var_smi_handler.value(),
+    HandleLoadICSmiHandlerCase(
-                               handler, miss, exit_point, ic_mode,
+        p, var_holder.value(), CAST(var_smi_handler.value()), handler, miss,
-                               on_nonexistent, support_elements, access_mode);
+        exit_point, ic_mode, on_nonexistent, support_elements, access_mode);
  }
  BIND(&call_handler);
  {
-    exit_point->ReturnCallStub(LoadWithVectorDescriptor{}, handler,
+    exit_point->ReturnCallStub(LoadWithVectorDescriptor{}, CAST(handler),
                               p->context(), p->receiver(), p->name(),
                               p->slot(), p->vector());
  }
@@ -212,7 +212,7 @@ void AccessorAssembler::HandleLoadAccessor(
  TNode<Object> data =
      LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);
-  VARIABLE(api_holder, MachineRepresentation::kTagged, p->receiver());
+  TVARIABLE(HeapObject, api_holder, CAST(p->receiver()));
  Label load(this);
  GotoIf(WordEqual(handler_kind, IntPtrConstant(LoadHandler::kApiGetter)),
         &load);
@@ -222,7 +222,7 @@ void AccessorAssembler::HandleLoadAccessor(
      WordEqual(handler_kind,
                IntPtrConstant(LoadHandler::kApiGetterHolderIsPrototype)));
-  api_holder.Bind(LoadMapPrototype(LoadMap(p->receiver())));
+  api_holder = LoadMapPrototype(LoadMap(CAST(p->receiver())));
  Goto(&load);
  BIND(&load);
@@ -232,7 +232,7 @@ void AccessorAssembler::HandleLoadAccessor(
                              api_holder.value(), p->receiver()));
 }
-void AccessorAssembler::HandleLoadField(SloppyTNode<JSObject> holder,
+void AccessorAssembler::HandleLoadField(TNode<JSObject> holder,
                                        TNode<WordT> handler_word,
                                        Variable* var_double_value,
                                        Label* rebox_double, Label* miss,
@@ -301,11 +301,11 @@ TNode<MaybeObject> AccessorAssembler::LoadDescriptorValueOrFieldType(
 }
 void AccessorAssembler::HandleLoadICSmiHandlerCase(
-    const LazyLoadICParameters* p, SloppyTNode<HeapObject> holder,
+    const LazyLoadICParameters* p, TNode<Object> holder, TNode<Smi> smi_handler,
-    SloppyTNode<Smi> smi_handler, SloppyTNode<Object> handler, Label* miss,
+    TNode<Object> handler, Label* miss, ExitPoint* exit_point, ICMode ic_mode,
-    ExitPoint* exit_point, ICMode ic_mode, OnNonExistent on_nonexistent,
+    OnNonExistent on_nonexistent, ElementSupport support_elements,
-    ElementSupport support_elements, LoadAccessMode access_mode) {
+    LoadAccessMode access_mode) {
-  VARIABLE(var_double_value, MachineRepresentation::kFloat64);
+  TVARIABLE(Float64T, var_double_value);
  Label rebox_double(this, &var_double_value);
  TNode<IntPtrT> handler_word = SmiUntag(smi_handler);
@@ -363,7 +363,7 @@ void AccessorAssembler::HandleLoadICSmiHandlerCase(
            IsSetWord<LoadHandler::IsJsArrayBits>(handler_word);
        TNode<Uint32T> elements_kind =
            DecodeWord32FromWord<LoadHandler::ElementsKindBits>(handler_word);
-        EmitElementLoad(holder, elements_kind, var_intptr_index.value(),
+        EmitElementLoad(CAST(holder), elements_kind, var_intptr_index.value(),
                        is_jsarray_condition, &if_hole, &rebox_double,
                        &var_double_value, &unimplemented_elements_kind,
                        &if_oob, miss, exit_point, access_mode);
@@ -393,12 +393,12 @@ void AccessorAssembler::HandleLoadICSmiHandlerCase(
      // in V8, not elements. So we cannot handle them here, except
      // in case of typed arrays, where integer indexed properties
      // aren't looked up in the prototype chain.
-      GotoIf(IsJSTypedArray(holder), &return_undefined);
+      GotoIf(IsJSTypedArray(CAST(holder)), &return_undefined);
      GotoIf(IntPtrLessThan(var_intptr_index.value(), IntPtrConstant(0)), miss);
      // For all other receivers we need to check that the prototype chain
      // doesn't contain any elements.
-      BranchIfPrototypesHaveNoElements(LoadMap(holder), &return_undefined,
+      BranchIfPrototypesHaveNoElements(LoadMap(CAST(holder)), &return_undefined,
                                       miss);
      BIND(&return_undefined);
@@ -457,9 +457,9 @@ void AccessorAssembler::HandleLoadICSmiHandlerCase(
 }
 void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
-    const LazyLoadICParameters* p, TNode<HeapObject> holder,
+    const LazyLoadICParameters* p, TNode<Object> holder,
    TNode<IntPtrT> handler_kind, TNode<WordT> handler_word, Label* rebox_double,
-    Variable* var_double_value, SloppyTNode<Object> handler, Label* miss,
+    Variable* var_double_value, TNode<Object> handler, Label* miss,
    ExitPoint* exit_point, ICMode ic_mode, OnNonExistent on_nonexistent,
    ElementSupport support_elements) {
  Label constant(this), field(this), normal(this, Label::kDeferred),
@@ -536,8 +536,8 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
                                         &var_name_index, miss);
    BIND(&found);
    {
-      VARIABLE(var_details, MachineRepresentation::kWord32);
+      TVARIABLE(Uint32T, var_details);
-      VARIABLE(var_value, MachineRepresentation::kTagged);
+      TVARIABLE(Object, var_value);
      LoadPropertyFromNameDictionary(properties, var_name_index.value(),
                                     &var_details, &var_value);
      TNode<Object> value =
@@ -553,7 +553,7 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
    TNode<IntPtrT> descriptor =
        Signed(DecodeWord<LoadHandler::DescriptorBits>(handler_word));
    TNode<AccessorPair> accessor_pair =
-        CAST(LoadDescriptorValue(LoadMap(holder), descriptor));
+        CAST(LoadDescriptorValue(LoadMap(CAST(holder)), descriptor));
    TNode<Object> getter =
        LoadObjectField(accessor_pair, AccessorPair::kGetterOffset);
    CSA_ASSERT(this, Word32BinaryNot(IsTheHole(getter)));
@@ -618,11 +618,12 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
  BIND(&global);
  {
-    CSA_ASSERT(this, IsPropertyCell(holder));
+    CSA_ASSERT(this, IsPropertyCell(CAST(holder)));
    // Ensure the property cell doesn't contain the hole.
-    TNode<Object> value = LoadObjectField(holder, PropertyCell::kValueOffset);
+    TNode<Object> value =
+        LoadObjectField(CAST(holder), PropertyCell::kValueOffset);
    TNode<Int32T> details = LoadAndUntagToWord32ObjectField(
-        holder, PropertyCell::kPropertyDetailsRawOffset);
+        CAST(holder), PropertyCell::kPropertyDetailsRawOffset);
    GotoIf(IsTheHole(value), miss);
    exit_point->Return(CallGetterIfAccessor(value, details, p->context(),
@@ -654,8 +655,8 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
    Comment("module export");
    TNode<UintPtrT> index =
        DecodeWord<LoadHandler::ExportsIndexBits>(handler_word);
-    TNode<Module> module =
+    TNode<Module> module = CAST(
-        CAST(LoadObjectField(p->receiver(), JSModuleNamespace::kModuleOffset));
+        LoadObjectField(CAST(p->receiver()), JSModuleNamespace::kModuleOffset));
    TNode<ObjectHashTable> exports =
        LoadObjectField<ObjectHashTable>(module, Module::kExportsOffset);
    TNode<Cell> cell = CAST(LoadFixedArrayElement(exports, index));
@@ -678,7 +679,7 @@ void AccessorAssembler::HandleLoadICSmiHandlerLoadNamedCase(
 }
 void AccessorAssembler::HandleLoadICSmiHandlerHasNamedCase(
-    const LazyLoadICParameters* p, TNode<HeapObject> holder,
+    const LazyLoadICParameters* p, TNode<Object> holder,
    TNode<IntPtrT> handler_kind, Label* miss, ExitPoint* exit_point,
    ICMode ic_mode) {
  Label return_true(this), return_false(this), return_lookup(this),
@@ -752,9 +753,10 @@ void AccessorAssembler::HandleLoadICSmiHandlerHasNamedCase(
  BIND(&global);
  {
-    CSA_ASSERT(this, IsPropertyCell(holder));
+    CSA_ASSERT(this, IsPropertyCell(CAST(holder)));
    // Ensure the property cell doesn't contain the hole.
-    TNode<Object> value = LoadObjectField(holder, PropertyCell::kValueOffset);
+    TNode<Object> value =
+        LoadObjectField(CAST(holder), PropertyCell::kValueOffset);
    GotoIf(IsTheHole(value), miss);
    exit_point->Return(TrueConstant());
@@ -847,8 +849,8 @@ TNode<Object> AccessorAssembler::HandleProtoHandler(
        CSA_ASSERT(this, IsWeakOrCleared(data2));
        TNode<Context> expected_native_context =
            CAST(GetHeapObjectAssumeWeak(data2, miss));
-        EmitAccessCheck(expected_native_context, p->context(),
+        EmitAccessCheck(expected_native_context, p->context(), p->receiver(),
-                        CAST(p->receiver()), &done, miss);
+                        &done, miss);
      }
      // Dictionary lookup on receiver is not necessary for Load/StoreGlobalIC
@@ -858,10 +860,10 @@ TNode<Object> AccessorAssembler::HandleProtoHandler(
      {
        DCHECK_EQ(ICMode::kNonGlobalIC, ic_mode);
        CSA_ASSERT(this, Word32BinaryNot(HasInstanceType(
-                             p->receiver(), JS_GLOBAL_OBJECT_TYPE)));
+                             CAST(p->receiver()), JS_GLOBAL_OBJECT_TYPE)));
        TNode<NameDictionary> properties =
-            CAST(LoadSlowProperties(p->receiver()));
+            CAST(LoadSlowProperties(CAST(p->receiver())));
        TVARIABLE(IntPtrT, var_name_index);
        Label found(this, &var_name_index);
        NameDictionaryLookup<NameDictionary>(properties, CAST(p->name()),
@@ -884,12 +886,9 @@ TNode<Object> AccessorAssembler::HandleProtoHandler(
 void AccessorAssembler::HandleLoadICProtoHandler(
    const LazyLoadICParameters* p, TNode<DataHandler> handler,
-    Variable* var_holder, Variable* var_smi_handler, Label* if_smi_handler,
+    TVariable<Object>* var_holder, TVariable<Object>* var_smi_handler,
-    Label* miss, ExitPoint* exit_point, ICMode ic_mode,
+    Label* if_smi_handler, Label* miss, ExitPoint* exit_point, ICMode ic_mode,
    LoadAccessMode access_mode) {
-  DCHECK_EQ(MachineRepresentation::kTagged, var_holder->rep());
-  DCHECK_EQ(MachineRepresentation::kTagged, var_smi_handler->rep());
  TNode<Smi> smi_handler = CAST(HandleProtoHandler<LoadHandler>(
      p, handler,
      // Code sub-handlers are not expected in LoadICs, so no |on_code_handler|.
@@ -899,8 +898,8 @@ void AccessorAssembler::HandleLoadICProtoHandler(
        if (access_mode == LoadAccessMode::kHas) {
          exit_point->Return(TrueConstant());
        } else {
-          VARIABLE(var_details, MachineRepresentation::kWord32);
+          TVARIABLE(Uint32T, var_details);
-          VARIABLE(var_value, MachineRepresentation::kTagged);
+          TVARIABLE(Object, var_value);
          LoadPropertyFromNameDictionary(properties, name_index, &var_details,
                                         &var_value);
          TNode<Object> value =
@@ -943,13 +942,13 @@ void AccessorAssembler::HandleLoadICProtoHandler(
    CSA_ASSERT(this, IsWeakOrCleared(maybe_holder_or_constant));
    TNode<HeapObject> holder =
        GetHeapObjectAssumeWeak(maybe_holder_or_constant, miss);
-    var_holder->Bind(holder);
+    *var_holder = holder;
    Goto(&done);
  }
  BIND(&done);
  {
-    var_smi_handler->Bind(smi_handler);
+    *var_smi_handler = smi_handler;
    Goto(if_smi_handler);
  }
 }
@@ -989,7 +988,7 @@ void AccessorAssembler::JumpIfDataProperty(TNode<Uint32T> details,
 }
 void AccessorAssembler::HandleStoreICNativeDataProperty(
-    const StoreICParameters* p, SloppyTNode<HeapObject> holder,
+    const StoreICParameters* p, TNode<HeapObject> holder,
    TNode<Word32T> handler_word) {
  Comment("native_data_property_store");
  TNode<IntPtrT> descriptor =
@@ -1014,7 +1013,7 @@ void AccessorAssembler::HandleStoreICHandlerCase(
  // for the encoding format.
  BIND(&if_smi_handler);
  {
-    Node* holder = p->receiver();
+    TNode<Object> holder = p->receiver();
    TNode<Int32T> handler_word = SmiToInt32(CAST(handler));
    Label if_fast_smi(this), if_proxy(this), if_interceptor(this),
@@ -1039,7 +1038,7 @@ void AccessorAssembler::HandleStoreICHandlerCase(
           &if_slow);
    CSA_ASSERT(this,
               Word32Equal(handler_kind, Int32Constant(StoreHandler::kNormal)));
-    TNode<NameDictionary> properties = CAST(LoadSlowProperties(holder));
+    TNode<NameDictionary> properties = CAST(LoadSlowProperties(CAST(holder)));
    TVARIABLE(IntPtrT, var_name_index);
    Label dictionary_found(this, &var_name_index);
@@ -1073,18 +1072,18 @@ void AccessorAssembler::HandleStoreICHandlerCase(
             &native_data_property, &data);
      BIND(&accessor);
-      HandleStoreAccessor(p, holder, handler_word);
+      HandleStoreAccessor(p, CAST(holder), handler_word);
      BIND(&native_data_property);
-      HandleStoreICNativeDataProperty(p, holder, handler_word);
+      HandleStoreICNativeDataProperty(p, CAST(holder), handler_word);
      BIND(&data);
      // Handle non-transitioning field stores.
-      HandleStoreICSmiHandlerCase(handler_word, holder, p->value(), miss);
+      HandleStoreICSmiHandlerCase(handler_word, CAST(holder), p->value(), miss);
    }
    BIND(&if_proxy);
-    HandleStoreToProxy(p, holder, miss, support_elements);
+    HandleStoreToProxy(p, CAST(holder), miss, support_elements);
    BIND(&if_interceptor);
    {
@@ -1214,15 +1213,15 @@ void AccessorAssembler::HandleStoreICTransitionMapHandlerCase(
    BIND(&attributes_ok);
  }
-  OverwriteExistingFastDataProperty(p->receiver(), transition_map, descriptors,
+  OverwriteExistingFastDataProperty(CAST(p->receiver()), transition_map,
-                                    last_key_index, details, p->value(), miss,
+                                    descriptors, last_key_index, details,
-                                    true);
+                                    p->value(), miss, true);
 }
 void AccessorAssembler::CheckFieldType(TNode<DescriptorArray> descriptors,
                                       TNode<IntPtrT> name_index,
                                       TNode<Word32T> representation,
-                                       Node* value, Label* bailout) {
+                                       TNode<Object> value, Label* bailout) {
  Label r_smi(this), r_double(this), r_heapobject(this), all_fine(this);
  // Ignore FLAG_track_fields etc. and always emit code for all checks,
  // because this builtin is part of the snapshot and therefore should
@@ -1246,7 +1245,7 @@ void AccessorAssembler::CheckFieldType(TNode<DescriptorArray> descriptors,
  BIND(&r_double);
  {
    GotoIf(TaggedIsSmi(value), &all_fine);
-    Branch(IsHeapNumber(value), &all_fine, bailout);
+    Branch(IsHeapNumber(CAST(value)), &all_fine, bailout);
  }
  BIND(&r_heapobject);
@@ -1271,7 +1270,8 @@ void AccessorAssembler::CheckFieldType(TNode<DescriptorArray> descriptors,
    TNode<Map> field_type_map =
        CAST(GetHeapObjectAssumeWeak(field_type, bailout));
    // FieldType::Class(...) performs a map check.
-    Branch(TaggedEqual(LoadMap(value), field_type_map), &all_fine, bailout);
+    Branch(TaggedEqual(LoadMap(CAST(value)), field_type_map), &all_fine,
+           bailout);
  }
  BIND(&all_fine);
@@ -1283,7 +1283,7 @@ TNode<BoolT> AccessorAssembler::IsPropertyDetailsConst(TNode<Uint32T> details) {
 }
 void AccessorAssembler::OverwriteExistingFastDataProperty(
-    SloppyTNode<HeapObject> object, TNode<Map> object_map,
+    TNode<HeapObject> object, TNode<Map> object_map,
    TNode<DescriptorArray> descriptors, TNode<IntPtrT> descriptor_name_index,
    TNode<Uint32T> details, TNode<Object> value, Label* slow,
    bool do_transitioning_store) {
@@ -1386,7 +1386,7 @@ void AccessorAssembler::OverwriteExistingFastDataProperty(
        // Allocate mutable heap number before extending properties backing
        // store to ensure that heap verifier will not see the heap in
        // inconsistent state.
-        VARIABLE(var_value, MachineRepresentation::kTagged, value);
+        TVARIABLE(Object, var_value, value);
        {
          Label cont(this);
          GotoIf(Word32NotEqual(representation,
@@ -1396,14 +1396,14 @@ void AccessorAssembler::OverwriteExistingFastDataProperty(
            TNode<Float64T> double_value = ChangeNumberToFloat64(CAST(value));
            TNode<HeapNumber> heap_number =
                AllocateHeapNumberWithValue(double_value);
-            var_value.Bind(heap_number);
+            var_value = heap_number;
            Goto(&cont);
          }
          BIND(&cont);
        }
        TNode<PropertyArray> properties =
-            CAST(ExtendPropertiesBackingStore(object, backing_store_index));
+            ExtendPropertiesBackingStore(object, backing_store_index);
        StorePropertyArrayElement(properties, backing_store_index,
                                  var_value.value());
        StoreMap(object, object_map);
@@ -1480,7 +1480,7 @@ void AccessorAssembler::CheckPrototypeValidityCell(
 }
 void AccessorAssembler::HandleStoreAccessor(const StoreICParameters* p,
-                                            SloppyTNode<HeapObject> holder,
+                                            TNode<HeapObject> holder,
                                            TNode<Word32T> handler_word) {
  Comment("accessor_store");
  TNode<IntPtrT> descriptor =
@@ -1594,7 +1594,7 @@ void AccessorAssembler::HandleStoreICProtoHandler(
    CSA_ASSERT(this,
               Word32Equal(handler_kind, Int32Constant(StoreHandler::kProxy)));
-    HandleStoreToProxy(p, holder, miss, support_elements);
+    HandleStoreToProxy(p, CAST(holder), miss, support_elements);
    BIND(&if_slow);
    {
@@ -1626,11 +1626,11 @@ void AccessorAssembler::HandleStoreICProtoHandler(
      // case is covered above by LookupOnReceiver bit handling of the smi
      // handler.
      Label slow(this);
-      TNode<Map> receiver_map = LoadMap(p->receiver());
+      TNode<Map> receiver_map = LoadMap(CAST(p->receiver()));
      InvalidateValidityCellIfPrototype(receiver_map);
      TNode<NameDictionary> properties =
-          CAST(LoadSlowProperties(p->receiver()));
+          CAST(LoadSlowProperties(CAST(p->receiver())));
      Add<NameDictionary>(properties, CAST(p->name()), p->value(), &slow);
      Return(p->value());
@@ -1649,7 +1649,7 @@ void AccessorAssembler::HandleStoreICProtoHandler(
    {
      Comment("api_setter");
      CSA_ASSERT(this, TaggedIsNotSmi(handler));
-      Node* call_handler_info = holder;
+      TNode<CallHandlerInfo> call_handler_info = CAST(holder);
      // Context is stored either in data2 or data3 field depending on whether
      // the access check is enabled for this handler or not.
@@ -1663,14 +1663,14 @@ void AccessorAssembler::HandleStoreICProtoHandler(
          IsCleared(maybe_context), [=] { return SmiConstant(0); },
          [=] { return GetHeapObjectAssumeWeak(maybe_context); });
-      TNode<Foreign> foreign = CAST(LoadObjectField(
+      TNode<Foreign> foreign = LoadObjectField<Foreign>(
-          call_handler_info, CallHandlerInfo::kJsCallbackOffset));
+          call_handler_info, CallHandlerInfo::kJsCallbackOffset);
-      Node* callback = LoadObjectField(foreign, Foreign::kForeignAddressOffset,
+      TNode<RawPtrT> callback =
-                                       MachineType::Pointer());
+          LoadObjectField<RawPtrT>(foreign, Foreign::kForeignAddressOffset);
      TNode<Object> data =
          LoadObjectField(call_handler_info, CallHandlerInfo::kDataOffset);
-      VARIABLE(api_holder, MachineRepresentation::kTagged, p->receiver());
+      TVARIABLE(Object, api_holder, p->receiver());
      Label store(this);
      GotoIf(Word32Equal(handler_kind, Int32Constant(StoreHandler::kApiSetter)),
             &store);
@@ -1680,7 +1680,7 @@ void AccessorAssembler::HandleStoreICProtoHandler(
                     handler_kind,
                     Int32Constant(StoreHandler::kApiSetterHolderIsPrototype)));
-      api_holder.Bind(LoadMapPrototype(LoadMap(p->receiver())));
+      api_holder = LoadMapPrototype(LoadMap(CAST(p->receiver())));
      Goto(&store);
      BIND(&store);
@@ -1693,13 +1693,14 @@ void AccessorAssembler::HandleStoreICProtoHandler(
    BIND(&if_store_global_proxy);
    {
      ExitPoint direct_exit(this);
-      StoreGlobalIC_PropertyCellCase(holder, p->value(), &direct_exit, miss);
+      StoreGlobalIC_PropertyCellCase(CAST(holder), p->value(), &direct_exit,
+                                     miss);
    }
  }
 }
 void AccessorAssembler::HandleStoreToProxy(const StoreICParameters* p,
-                                           Node* proxy, Label* miss,
+                                           TNode<JSProxy> proxy, Label* miss,
                                           ElementSupport support_elements) {
  TVARIABLE(IntPtrT, var_index);
  TVARIABLE(Name, var_unique);
@@ -1733,9 +1734,10 @@ void AccessorAssembler::HandleStoreToProxy(const StoreICParameters* p,
  }
 }
-void AccessorAssembler::HandleStoreICSmiHandlerCase(
+void AccessorAssembler::HandleStoreICSmiHandlerCase(TNode<Word32T> handler_word,
-    SloppyTNode<Word32T> handler_word, SloppyTNode<JSObject> holder,
+                                                    TNode<JSObject> holder,
-    SloppyTNode<Object> value, Label* miss) {
+                                                    TNode<Object> value,
+                                                    Label* miss) {
  Comment("field store");
 #ifdef DEBUG
  TNode<Uint32T> handler_kind =
@@ -1929,21 +1931,20 @@ void AccessorAssembler::HandleStoreFieldAndReturn(
  Return(value);
 }
-Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
+TNode<PropertyArray> AccessorAssembler::ExtendPropertiesBackingStore(
-                                                      Node* index) {
+    TNode<HeapObject> object, TNode<IntPtrT> index) {
  Comment("[ Extend storage");
  ParameterMode mode = OptimalParameterMode();
  // TODO(gsathya): Clean up the type conversions by creating smarter
  // helpers that do the correct op based on the mode.
-  VARIABLE(var_properties, MachineRepresentation::kTaggedPointer);
+  TVARIABLE(HeapObject, var_properties);
-  VARIABLE(var_encoded_hash, MachineRepresentation::kWord32);
+  TVARIABLE(Int32T, var_encoded_hash);
  VARIABLE(var_length, ParameterRepresentation(mode));
  TNode<Object> properties =
      LoadObjectField(object, JSObject::kPropertiesOrHashOffset);
-  var_properties.Bind(properties);
  Label if_smi_hash(this), if_property_array(this), extend_store(this);
  Branch(TaggedIsSmi(properties), &if_smi_hash, &if_property_array);
@@ -1953,18 +1954,19 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
    TNode<Int32T> hash = SmiToInt32(CAST(properties));
    TNode<Int32T> encoded_hash =
        Word32Shl(hash, Int32Constant(PropertyArray::HashField::kShift));
-    var_encoded_hash.Bind(encoded_hash);
+    var_encoded_hash = encoded_hash;
    var_length.Bind(IntPtrOrSmiConstant(0, mode));
-    var_properties.Bind(EmptyFixedArrayConstant());
+    var_properties = EmptyFixedArrayConstant();
    Goto(&extend_store);
  }
  BIND(&if_property_array);
  {
+    var_properties = CAST(properties);
    TNode<Int32T> length_and_hash_int32 = LoadAndUntagToWord32ObjectField(
        var_properties.value(), PropertyArray::kLengthAndHashOffset);
-    var_encoded_hash.Bind(Word32And(
+    var_encoded_hash = Word32And(
-        length_and_hash_int32, Int32Constant(PropertyArray::HashField::kMask)));
+        length_and_hash_int32, Int32Constant(PropertyArray::HashField::kMask));
    TNode<IntPtrT> length_intptr = ChangeInt32ToIntPtr(
        Word32And(length_and_hash_int32,
                  Int32Constant(PropertyArray::LengthField::kMask)));
@@ -1975,8 +1977,7 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
  BIND(&extend_store);
  {
-    VARIABLE(var_new_properties, MachineRepresentation::kTaggedPointer,
+    TVARIABLE(HeapObject, var_new_properties, var_properties.value());
-             var_properties.value());
    Label done(this);
    // Previous property deletion could have left behind unused backing store
    // capacity even for a map that think it doesn't have any unused fields.
@@ -1999,8 +2000,9 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
                       kMaxNumberOfDescriptors + JSObject::kFieldsAdded, mode),
                   mode));
-    Node* new_properties = AllocatePropertyArray(new_capacity, mode);
+    TNode<PropertyArray> new_properties =
-    var_new_properties.Bind(new_properties);
+        CAST(AllocatePropertyArray(new_capacity, mode));
+    var_new_properties = new_properties;
    FillPropertyArrayWithUndefined(new_properties, var_length.value(),
                                   new_capacity, mode);
@@ -2016,33 +2018,32 @@ Node* AccessorAssembler::ExtendPropertiesBackingStore(Node* object,
    TNode<Int32T> new_capacity_int32 =
        TruncateIntPtrToInt32(ParameterToIntPtr(new_capacity, mode));
    TNode<Int32T> new_length_and_hash_int32 =
-        Signed(Word32Or(var_encoded_hash.value(), new_capacity_int32));
+        Word32Or(var_encoded_hash.value(), new_capacity_int32);
    StoreObjectField(new_properties, PropertyArray::kLengthAndHashOffset,
                     SmiFromInt32(new_length_and_hash_int32));
    StoreObjectField(object, JSObject::kPropertiesOrHashOffset, new_properties);
    Comment("] Extend storage");
    Goto(&done);
    BIND(&done);
-    return var_new_properties.value();
+    return CAST(var_new_properties.value());
  }
 }
-void AccessorAssembler::EmitFastElementsBoundsCheck(Node* object,
+void AccessorAssembler::EmitFastElementsBoundsCheck(
-                                                    Node* elements,
+    TNode<JSObject> object, TNode<FixedArrayBase> elements,
-                                                    Node* intptr_index,
+    TNode<IntPtrT> intptr_index, TNode<BoolT> is_jsarray_condition,
-                                                    Node* is_jsarray_condition,
+    Label* miss) {
-                                                    Label* miss) {
+  TVARIABLE(IntPtrT, var_length);
-  VARIABLE(var_length, MachineType::PointerRepresentation());
  Comment("Fast elements bounds check");
  Label if_array(this), length_loaded(this, &var_length);
  GotoIf(is_jsarray_condition, &if_array);
  {
-    var_length.Bind(SmiUntag(LoadFixedArrayBaseLength(elements)));
+    var_length = SmiUntag(LoadFixedArrayBaseLength(elements));
    Goto(&length_loaded);
  }
  BIND(&if_array);
  {
-    var_length.Bind(SmiUntag(LoadFastJSArrayLength(object)));
+    var_length = SmiUntag(LoadFastJSArrayLength(CAST(object)));
    Goto(&length_loaded);
  }
  BIND(&length_loaded);
@@ -2050,9 +2051,9 @@ void AccessorAssembler::EmitFastElementsBoundsCheck(Node* object,
 }
 void AccessorAssembler::EmitElementLoad(
-    Node* object, TNode<Word32T> elements_kind,
+    TNode<HeapObject> object, TNode<Word32T> elements_kind,
-    SloppyTNode<IntPtrT> intptr_index, Node* is_jsarray_condition,
+    TNode<IntPtrT> intptr_index, TNode<BoolT> is_jsarray_condition,
-    Label* if_hole, Label* rebox_double, Variable* var_double_value,
+    Label* if_hole, Label* rebox_double, TVariable<Float64T>* var_double_value,
    Label* unimplemented_elements_kind, Label* out_of_bounds, Label* miss,
    ExitPoint* exit_point, LoadAccessMode access_mode) {
  Label if_typed_array(this), if_fast(this), if_fast_packed(this),
@@ -2065,7 +2066,7 @@ void AccessorAssembler::EmitElementLoad(
  BIND(&if_fast);
  {
    TNode<FixedArrayBase> elements = LoadJSObjectElements(CAST(object));
-    EmitFastElementsBoundsCheck(object, elements, intptr_index,
+    EmitFastElementsBoundsCheck(CAST(object), elements, intptr_index,
                                is_jsarray_condition, out_of_bounds);
    int32_t kinds[] = {
        // Handled by if_fast_packed.
@@ -2116,8 +2117,8 @@ void AccessorAssembler::EmitElementLoad(
      if (access_mode == LoadAccessMode::kHas) {
        exit_point->Return(TrueConstant());
      } else {
-        var_double_value->Bind(LoadFixedDoubleArrayElement(
+        *var_double_value = LoadFixedDoubleArrayElement(
-            CAST(elements), intptr_index, MachineType::Float64()));
+            CAST(elements), intptr_index, MachineType::Float64());
        Goto(rebox_double);
      }
    }
@@ -2131,7 +2132,7 @@ void AccessorAssembler::EmitElementLoad(
      if (access_mode == LoadAccessMode::kHas) {
        exit_point->Return(TrueConstant());
      } else {
-        var_double_value->Bind(value);
+        *var_double_value = value;
        Goto(rebox_double);
      }
    }
@@ -2199,57 +2200,57 @@ void AccessorAssembler::EmitElementLoad(
        BIND(&uint8_elements);
        {
          Comment("UINT8_ELEMENTS");  // Handles UINT8_CLAMPED_ELEMENTS too.
-          Node* element = Load(MachineType::Uint8(), data_ptr, intptr_index);
+          TNode<Int32T> element = Load<Uint8T>(data_ptr, intptr_index);
          exit_point->Return(SmiFromInt32(element));
        }
        BIND(&int8_elements);
        {
          Comment("INT8_ELEMENTS");
-          Node* element = Load(MachineType::Int8(), data_ptr, intptr_index);
+          TNode<Int32T> element = Load<Int8T>(data_ptr, intptr_index);
          exit_point->Return(SmiFromInt32(element));
        }
        BIND(&uint16_elements);
        {
          Comment("UINT16_ELEMENTS");
          TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(1));
-          Node* element = Load(MachineType::Uint16(), data_ptr, index);
+          TNode<Int32T> element = Load<Uint16T>(data_ptr, index);
          exit_point->Return(SmiFromInt32(element));
        }
        BIND(&int16_elements);
        {
          Comment("INT16_ELEMENTS");
          TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(1));
-          Node* element = Load(MachineType::Int16(), data_ptr, index);
+          TNode<Int32T> element = Load<Int16T>(data_ptr, index);
          exit_point->Return(SmiFromInt32(element));
        }
        BIND(&uint32_elements);
        {
          Comment("UINT32_ELEMENTS");
          TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(2));
-          Node* element = Load(MachineType::Uint32(), data_ptr, index);
+          TNode<Uint32T> element = Load<Uint32T>(data_ptr, index);
          exit_point->Return(ChangeUint32ToTagged(element));
        }
        BIND(&int32_elements);
        {
          Comment("INT32_ELEMENTS");
          TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(2));
-          Node* element = Load(MachineType::Int32(), data_ptr, index);
+          TNode<Int32T> element = Load<Int32T>(data_ptr, index);
          exit_point->Return(ChangeInt32ToTagged(element));
        }
        BIND(&float32_elements);
        {
          Comment("FLOAT32_ELEMENTS");
          TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(2));
-          Node* element = Load(MachineType::Float32(), data_ptr, index);
+          TNode<Float32T> element = Load<Float32T>(data_ptr, index);
-          var_double_value->Bind(ChangeFloat32ToFloat64(element));
+          *var_double_value = ChangeFloat32ToFloat64(element);
          Goto(rebox_double);
        }
        BIND(&float64_elements);
        {
          Comment("FLOAT64_ELEMENTS");
          TNode<IntPtrT> index = WordShl(intptr_index, IntPtrConstant(3));
-          Node* element = Load(MachineType::Float64(), data_ptr, index);
+          TNode<Float64T> element = Load<Float64T>(data_ptr, index);
-          var_double_value->Bind(element);
+          *var_double_value = element;
          Goto(rebox_double);
        }
        BIND(&bigint64_elements);
@@ -2269,23 +2270,13 @@ void AccessorAssembler::EmitElementLoad(
  }
 }
-void AccessorAssembler::NameDictionaryNegativeLookup(Node* object,
+void AccessorAssembler::InvalidateValidityCellIfPrototype(
-                                                     SloppyTNode<Name> name,
+    TNode<Map> map, base::Optional<TNode<Uint32T>> maybe_bitfield3) {
-                                                     Label* miss) {
-  CSA_ASSERT(this, IsDictionaryMap(LoadMap(object)));
-  TNode<NameDictionary> properties = CAST(LoadSlowProperties(object));
-  // Ensure the property does not exist in a dictionary-mode object.
-  TVARIABLE(IntPtrT, var_name_index);
-  Label done(this);
-  NameDictionaryLookup<NameDictionary>(properties, name, miss, &var_name_index,
-                                       &done);
-  BIND(&done);
-}
-void AccessorAssembler::InvalidateValidityCellIfPrototype(Node* map,
-                                                          Node* bitfield3) {
  Label is_prototype(this), cont(this);
-  if (bitfield3 == nullptr) {
+  TNode<Uint32T> bitfield3;
+  if (bitfield3) {
+    bitfield3 = maybe_bitfield3.value();
+  } else {
    bitfield3 = LoadMapBitField3(map);
  }
@@ -2308,10 +2299,10 @@ void AccessorAssembler::InvalidateValidityCellIfPrototype(Node* map,
  BIND(&cont);
 }
-void AccessorAssembler::GenericElementLoad(Node* receiver,
+void AccessorAssembler::GenericElementLoad(TNode<HeapObject> receiver,
                                           TNode<Map> receiver_map,
-                                           SloppyTNode<Int32T> instance_type,
+                                           TNode<Int32T> instance_type,
-                                           Node* index, Label* slow) {
+                                           TNode<IntPtrT> index, Label* slow) {
  Comment("integer index");
  ExitPoint direct_exit(this);
@@ -2323,7 +2314,7 @@ void AccessorAssembler::GenericElementLoad(Node* receiver,
  TNode<Int32T> elements_kind = LoadMapElementsKind(receiver_map);
  TNode<BoolT> is_jsarray_condition =
      InstanceTypeEqual(instance_type, JS_ARRAY_TYPE);
-  VARIABLE(var_double_value, MachineRepresentation::kFloat64);
+  TVARIABLE(Float64T, var_double_value);
  Label rebox_double(this, &var_double_value);
  // Unimplemented elements kinds fall back to a runtime call.
@@ -2362,7 +2353,7 @@ void AccessorAssembler::GenericElementLoad(Node* receiver,
    Comment("check if string");
    GotoIfNot(IsStringInstanceType(instance_type), slow);
    Comment("load string character");
-    TNode<IntPtrT> length = LoadStringLengthAsWord(receiver);
+    TNode<IntPtrT> length = LoadStringLengthAsWord(CAST(receiver));
    GotoIfNot(UintPtrLessThan(index, length), slow);
    IncrementCounter(isolate()->counters()->ic_keyed_load_generic_smi(), 1);
    TailCallBuiltin(Builtins::kStringCharAt, NoContextConstant(), receiver,
@@ -2370,16 +2361,19 @@ void AccessorAssembler::GenericElementLoad(Node* receiver,
  }
 }
-void AccessorAssembler::GenericPropertyLoad(
+void AccessorAssembler::GenericPropertyLoad(TNode<HeapObject> receiver,
-    Node* receiver, TNode<Map> receiver_map, SloppyTNode<Int32T> instance_type,
+                                            TNode<Map> receiver_map,
-    const LoadICParameters* p, Label* slow, UseStubCache use_stub_cache) {
+                                            TNode<Int32T> instance_type,
+                                            const LoadICParameters* p,
+                                            Label* slow,
+                                            UseStubCache use_stub_cache) {
  ExitPoint direct_exit(this);
  Comment("key is unique name");
  Label if_found_on_receiver(this), if_property_dictionary(this),
      lookup_prototype_chain(this), special_receiver(this);
-  VARIABLE(var_details, MachineRepresentation::kWord32);
+  TVARIABLE(Uint32T, var_details);
-  VARIABLE(var_value, MachineRepresentation::kTagged);
+  TVARIABLE(Object, var_value);
  TNode<Name> name = CAST(p->name());
@@ -2450,7 +2444,7 @@ void AccessorAssembler::GenericPropertyLoad(
    TVARIABLE(IntPtrT, var_name_index);
    Label dictionary_found(this, &var_name_index);
-    TNode<NameDictionary> properties = CAST(LoadSlowProperties(receiver));
+    TNode<NameDictionary> properties = CAST(LoadSlowProperties(CAST(receiver)));
    NameDictionaryLookup<NameDictionary>(properties, name, &dictionary_found,
                                         &var_name_index,
                                         &lookup_prototype_chain);
@@ -2473,13 +2467,13 @@ void AccessorAssembler::GenericPropertyLoad(
  BIND(&lookup_prototype_chain);
  {
    TVARIABLE(Map, var_holder_map);
-    VARIABLE(var_holder_instance_type, MachineRepresentation::kWord32);
+    TVARIABLE(Int32T, var_holder_instance_type);
    Label return_undefined(this), is_private_symbol(this);
    Variable* merged_variables[] = {&var_holder_map, &var_holder_instance_type};
    Label loop(this, arraysize(merged_variables), merged_variables);
    var_holder_map = receiver_map;
-    var_holder_instance_type.Bind(instance_type);
+    var_holder_instance_type = instance_type;
    GotoIf(IsPrivateSymbol(name), &is_private_symbol);
    Goto(&loop);
@@ -2494,7 +2488,7 @@ void AccessorAssembler::GenericPropertyLoad(
      TNode<Map> proto_map = LoadMap(proto);
      TNode<Uint16T> proto_instance_type = LoadMapInstanceType(proto_map);
      var_holder_map = proto_map;
-      var_holder_instance_type.Bind(proto_instance_type);
+      var_holder_instance_type = proto_instance_type;
      Label next_proto(this), return_value(this, &var_value), goto_slow(this);
      TryGetOwnProperty(p->context(), receiver, proto, proto_map,
                        proto_instance_type, name, &return_value, &var_value,
@@ -2548,7 +2542,8 @@ enum AccessorAssembler::StubCacheTable : int {
  kSecondary = static_cast<int>(StubCache::kSecondary)
 };
-Node* AccessorAssembler::StubCachePrimaryOffset(Node* name, Node* map) {
+TNode<IntPtrT> AccessorAssembler::StubCachePrimaryOffset(TNode<Name> name,
+                                                         TNode<Map> map) {
  // Compute the hash of the name (use entire hash field).
  TNode<Uint32T> hash_field = LoadNameHashField(name);
  CSA_ASSERT(this,
@@ -2567,10 +2562,13 @@ Node* AccessorAssembler::StubCachePrimaryOffset(Node* name, Node* map) {
  TNode<Word32T> hash = Int32Add(hash_field, map32);
  uint32_t mask = (StubCache::kPrimaryTableSize - 1)
                  << StubCache::kCacheIndexShift;
-  return ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
+  TNode<UintPtrT> result =
+      ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
+  return Signed(result);
 }
-Node* AccessorAssembler::StubCacheSecondaryOffset(Node* name, Node* seed) {
+TNode<IntPtrT> AccessorAssembler::StubCacheSecondaryOffset(
+    TNode<Name> name, TNode<IntPtrT> seed) {
  // See v8::internal::StubCache::SecondaryOffset().
  // Use the seed from the primary cache in the secondary cache.
@@ -2579,11 +2577,13 @@ Node* AccessorAssembler::StubCacheSecondaryOffset(Node* name, Node* seed) {
  hash = Int32Add(hash, Int32Constant(StubCache::kSecondaryMagic));
  int32_t mask = (StubCache::kSecondaryTableSize - 1)
                 << StubCache::kCacheIndexShift;
-  return ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
+  TNode<UintPtrT> result =
+      ChangeUint32ToWord(Word32And(hash, Int32Constant(mask)));
+  return Signed(result);
 }
 void AccessorAssembler::TryProbeStubCacheTable(
-    StubCache* stub_cache, StubCacheTable table_id, Node* entry_offset,
+    StubCache* stub_cache, StubCacheTable table_id, TNode<IntPtrT> entry_offset,
    TNode<Object> name, TNode<Map> map, Label* if_handler,
    TVariable<MaybeObject>* var_handler, Label* if_miss) {
  StubCache::Table table = static_cast<StubCache::Table>(table_id);
@@ -2618,8 +2618,9 @@ void AccessorAssembler::TryProbeStubCacheTable(
  Goto(if_handler);
 }
-void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache, Node* receiver,
+void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache,
-                                          TNode<Object> name, Label* if_handler,
+                                          TNode<Object> receiver,
+                                          TNode<Name> name, Label* if_handler,
                                          TVariable<MaybeObject>* var_handler,
                                          Label* if_miss) {
  Label try_secondary(this), miss(this);
@@ -2630,17 +2631,18 @@ void AccessorAssembler::TryProbeStubCache(StubCache* stub_cache, Node* receiver,
  // Check that the {receiver} isn't a smi.
  GotoIf(TaggedIsSmi(receiver), &miss);
-  TNode<Map> receiver_map = LoadMap(receiver);
+  TNode<Map> receiver_map = LoadMap(CAST(receiver));
  // Probe the primary table.
-  Node* primary_offset = StubCachePrimaryOffset(name, receiver_map);
+  TNode<IntPtrT> primary_offset = StubCachePrimaryOffset(name, receiver_map);
  TryProbeStubCacheTable(stub_cache, kPrimary, primary_offset, name,
                         receiver_map, if_handler, var_handler, &try_secondary);
  BIND(&try_secondary);
  {
    // Probe the secondary table.
-    Node* secondary_offset = StubCacheSecondaryOffset(name, primary_offset);
+    TNode<IntPtrT> secondary_offset =
+        StubCacheSecondaryOffset(name, primary_offset);
    TryProbeStubCacheTable(stub_cache, kSecondary, secondary_offset, name,
                           receiver_map, if_handler, var_handler, &miss);
  }
@@ -2792,17 +2794,17 @@ void AccessorAssembler::LoadIC_Noninlined(const LoadICParameters* p,
    // Check megamorphic case.
    GotoIfNot(TaggedEqual(feedback, MegamorphicSymbolConstant()), miss);
-    TryProbeStubCache(isolate()->load_stub_cache(), p->receiver(), p->name(),
+    TryProbeStubCache(isolate()->load_stub_cache(), p->receiver(),
-                      if_handler, var_handler, miss);
+                      CAST(p->name()), if_handler, var_handler, miss);
  }
 }
 void AccessorAssembler::LoadIC_NoFeedback(const LoadICParameters* p,
                                          TNode<Smi> ic_kind) {
  Label miss(this, Label::kDeferred);
-  Node* receiver = p->receiver();
+  TNode<Object> receiver = p->receiver();
  GotoIf(TaggedIsSmi(receiver), &miss);
-  TNode<Map> receiver_map = LoadMap(receiver);
+  TNode<Map> receiver_map = LoadMap(CAST(receiver));
  GotoIf(IsDeprecatedMap(receiver_map), &miss);
  TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
@@ -2821,7 +2823,7 @@ void AccessorAssembler::LoadIC_NoFeedback(const LoadICParameters* p,
    BIND(&not_function_prototype);
  }
-  GenericPropertyLoad(receiver, receiver_map, instance_type, p, &miss,
+  GenericPropertyLoad(CAST(receiver), receiver_map, instance_type, p, &miss,
                      kDontUseStubCache);
  BIND(&miss);
@@ -3147,7 +3149,7 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
  TVARIABLE(Object, var_name, p->name());
  Label if_runtime(this, Label::kDeferred);
-  Node* receiver = p->receiver();
+  TNode<Object> receiver = p->receiver();
  GotoIf(TaggedIsSmi(receiver), &if_runtime);
  GotoIf(IsNullOrUndefined(receiver), &if_runtime);
@@ -3163,9 +3165,9 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
    BIND(&if_unique_name);
    {
      LoadICParameters pp(p, var_unique.value());
-      TNode<Map> receiver_map = LoadMap(receiver);
+      TNode<Map> receiver_map = LoadMap(CAST(receiver));
      TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
-      GenericPropertyLoad(receiver, receiver_map, instance_type, &pp,
+      GenericPropertyLoad(CAST(receiver), receiver_map, instance_type, &pp,
                          &if_runtime);
    }
@@ -3196,9 +3198,9 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
          // experiments with this have shown that it causes too much traffic
          // on the stub cache. We may want to re-evaluate that in the future.
          LoadICParameters pp(p, var_unique.value());
-          TNode<Map> receiver_map = LoadMap(receiver);
+          TNode<Map> receiver_map = LoadMap(CAST(receiver));
          TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
-          GenericPropertyLoad(receiver, receiver_map, instance_type, &pp,
+          GenericPropertyLoad(CAST(receiver), receiver_map, instance_type, &pp,
                              &if_runtime, kDontUseStubCache);
        }
      } else {
@@ -3208,9 +3210,9 @@ void AccessorAssembler::KeyedLoadICGeneric(const LoadICParameters* p) {
    BIND(&if_index);
    {
-      TNode<Map> receiver_map = LoadMap(receiver);
+      TNode<Map> receiver_map = LoadMap(CAST(receiver));
      TNode<Uint16T> instance_type = LoadMapInstanceType(receiver_map);
-      GenericElementLoad(receiver, receiver_map, instance_type,
+      GenericElementLoad(CAST(receiver), receiver_map, instance_type,
                         var_index.value(), &if_runtime);
    }
  }
@@ -3230,7 +3232,7 @@ void AccessorAssembler::KeyedLoadICPolymorphicName(const LoadICParameters* p,
  TVARIABLE(MaybeObject, var_handler);
  Label if_handler(this, &var_handler), miss(this, Label::kDeferred);
-  Node* receiver = p->receiver();
+  TNode<Object> receiver = p->receiver();
  TNode<Map> receiver_map = LoadReceiverMap(receiver);
  TNode<Name> name = CAST(p->name());
  TNode<FeedbackVector> vector = CAST(p->vector());
@@ -3311,8 +3313,8 @@ void AccessorAssembler::StoreIC(const StoreICParameters* p) {
    // Check megamorphic case.
    GotoIfNot(TaggedEqual(strong_feedback, MegamorphicSymbolConstant()), &miss);
-    TryProbeStubCache(isolate()->store_stub_cache(), p->receiver(), p->name(),
+    TryProbeStubCache(isolate()->store_stub_cache(), p->receiver(),
-                      &if_handler, &var_handler, &miss);
+                      CAST(p->name()), &if_handler, &var_handler, &miss);
  }
  BIND(&no_feedback);
@@ -3354,7 +3356,7 @@ void AccessorAssembler::StoreGlobalIC(const StoreICParameters* pp) {
      GotoIf(TaggedEqual(handler, UninitializedSymbolConstant()), &miss);
-      DCHECK_NULL(pp->receiver());
+      DCHECK(pp->receiver_is_null());
      TNode<NativeContext> native_context = LoadNativeContext(pp->context());
      StoreICParameters p(
          pp->context(),
@@ -3386,12 +3388,10 @@ void AccessorAssembler::StoreGlobalIC(const StoreICParameters* pp) {
  }
 }
-void AccessorAssembler::StoreGlobalIC_PropertyCellCase(Node* property_cell,
+void AccessorAssembler::StoreGlobalIC_PropertyCellCase(
-                                                       TNode<Object> value,
+    TNode<PropertyCell> property_cell, TNode<Object> value,
-                                                       ExitPoint* exit_point,
+    ExitPoint* exit_point, Label* miss) {
-                                                       Label* miss) {
  Comment("StoreGlobalIC_TryPropertyCellCase");
-  CSA_ASSERT(this, IsPropertyCell(property_cell));
  // Load the payload of the global parameter cell. A hole indicates that
  // the cell has been invalidated and that the store must be handled by the
@@ -3635,10 +3635,10 @@ void AccessorAssembler::StoreInArrayLiteralIC(const StoreICParameters* p) {
 void AccessorAssembler::GenerateLoadIC() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  LoadICParameters p(context, receiver, name, slot, vector);
@@ -3648,18 +3648,18 @@ void AccessorAssembler::GenerateLoadIC() {
 void AccessorAssembler::GenerateLoadIC_Megamorphic() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  ExitPoint direct_exit(this);
  TVARIABLE(MaybeObject, var_handler);
  Label if_handler(this, &var_handler), miss(this, Label::kDeferred);
-  TryProbeStubCache(isolate()->load_stub_cache(), receiver, name, &if_handler,
+  TryProbeStubCache(isolate()->load_stub_cache(), receiver, CAST(name),
-                    &var_handler, &miss);
+                    &if_handler, &var_handler, &miss);
  BIND(&if_handler);
  LazyLoadICParameters p([=] { return context; }, receiver,
@@ -3674,7 +3674,7 @@ void AccessorAssembler::GenerateLoadIC_Megamorphic() {
 void AccessorAssembler::GenerateLoadIC_Noninlined() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<FeedbackVector> vector = CAST(Parameter(Descriptor::kVector));
@@ -3707,7 +3707,7 @@ void AccessorAssembler::GenerateLoadIC_Noninlined() {
 void AccessorAssembler::GenerateLoadIC_NoFeedback() {
  using Descriptor = LoadNoFeedbackDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<Smi> ic_kind = CAST(Parameter(Descriptor::kICKind));
@@ -3722,9 +3722,9 @@ void AccessorAssembler::GenerateLoadIC_NoFeedback() {
 void AccessorAssembler::GenerateLoadICTrampoline() {
  using Descriptor = LoadDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* slot = Parameter(Descriptor::kSlot);
+  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
@@ -3734,9 +3734,9 @@ void AccessorAssembler::GenerateLoadICTrampoline() {
 void AccessorAssembler::GenerateLoadICTrampoline_Megamorphic() {
  using Descriptor = LoadDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* slot = Parameter(Descriptor::kSlot);
+  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
@@ -3779,7 +3779,7 @@ void AccessorAssembler::GenerateLoadGlobalICTrampoline(TypeofMode typeof_mode) {
  using Descriptor = LoadGlobalDescriptor;
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* slot = Parameter(Descriptor::kSlot);
+  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
@@ -3791,10 +3791,10 @@ void AccessorAssembler::GenerateLoadGlobalICTrampoline(TypeofMode typeof_mode) {
 void AccessorAssembler::GenerateKeyedLoadIC() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  LoadICParameters p(context, receiver, name, slot, vector);
@@ -3804,10 +3804,10 @@ void AccessorAssembler::GenerateKeyedLoadIC() {
 void AccessorAssembler::GenerateKeyedLoadIC_Megamorphic() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  LoadICParameters p(context, receiver, name, slot, vector);
@@ -3817,7 +3817,7 @@ void AccessorAssembler::GenerateKeyedLoadIC_Megamorphic() {
 void AccessorAssembler::GenerateKeyedLoadICTrampoline() {
  using Descriptor = LoadDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
@@ -3830,7 +3830,7 @@ void AccessorAssembler::GenerateKeyedLoadICTrampoline() {
 void AccessorAssembler::GenerateKeyedLoadICTrampoline_Megamorphic() {
  using Descriptor = LoadDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
@@ -3843,10 +3843,10 @@ void AccessorAssembler::GenerateKeyedLoadICTrampoline_Megamorphic() {
 void AccessorAssembler::GenerateKeyedLoadIC_PolymorphicName() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<FeedbackVector> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  LoadICParameters p(context, receiver, name, slot, vector);
@@ -3857,12 +3857,12 @@ void AccessorAssembler::GenerateStoreGlobalIC() {
  using Descriptor = StoreGlobalWithVectorDescriptor;
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
-  StoreICParameters p(context, nullptr, name, value, slot, vector);
+  StoreICParameters p(context, base::nullopt, name, value, slot, vector);
  StoreGlobalIC(&p);
 }
@@ -3870,7 +3870,7 @@ void AccessorAssembler::GenerateStoreGlobalICTrampoline() {
  using Descriptor = StoreGlobalDescriptor;
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
@@ -3881,11 +3881,11 @@ void AccessorAssembler::GenerateStoreGlobalICTrampoline() {
 void AccessorAssembler::GenerateStoreIC() {
  using Descriptor = StoreWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  StoreICParameters p(context, receiver, name, value, slot, vector);
@@ -3895,9 +3895,9 @@ void AccessorAssembler::GenerateStoreIC() {
 void AccessorAssembler::GenerateStoreICTrampoline() {
  using Descriptor = StoreDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
@@ -3909,11 +3909,11 @@ void AccessorAssembler::GenerateStoreICTrampoline() {
 void AccessorAssembler::GenerateKeyedStoreIC() {
  using Descriptor = StoreWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  StoreICParameters p(context, receiver, name, value, slot, vector);
@@ -3923,9 +3923,9 @@ void AccessorAssembler::GenerateKeyedStoreIC() {
 void AccessorAssembler::GenerateKeyedStoreICTrampoline() {
  using Descriptor = StoreDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  TNode<FeedbackVector> vector = LoadFeedbackVectorForStub();
@@ -3937,11 +3937,11 @@ void AccessorAssembler::GenerateKeyedStoreICTrampoline() {
 void AccessorAssembler::GenerateStoreInArrayLiteralIC() {
  using Descriptor = StoreWithVectorDescriptor;
-  Node* array = Parameter(Descriptor::kReceiver);
+  TNode<Object> array = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> index = CAST(Parameter(Descriptor::kName));
-  Node* value = Parameter(Descriptor::kValue);
+  TNode<Object> value = CAST(Parameter(Descriptor::kValue));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  StoreICParameters p(context, array, index, value, slot, vector);
@@ -4172,10 +4172,10 @@ void AccessorAssembler::GenerateCloneObjectIC() {
 void AccessorAssembler::GenerateKeyedHasIC() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  LoadICParameters p(context, receiver, name, slot, vector);
@@ -4185,7 +4185,7 @@ void AccessorAssembler::GenerateKeyedHasIC() {
 void AccessorAssembler::GenerateKeyedHasIC_Megamorphic() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  // TODO(magardn): implement HasProperty handling in KeyedLoadICGeneric
@@ -4196,10 +4196,10 @@ void AccessorAssembler::GenerateKeyedHasIC_Megamorphic() {
 void AccessorAssembler::GenerateKeyedHasIC_PolymorphicName() {
  using Descriptor = LoadWithVectorDescriptor;
-  Node* receiver = Parameter(Descriptor::kReceiver);
+  TNode<Object> receiver = CAST(Parameter(Descriptor::kReceiver));
  TNode<Object> name = CAST(Parameter(Descriptor::kName));
  TNode<Smi> slot = CAST(Parameter(Descriptor::kSlot));
-  Node* vector = Parameter(Descriptor::kVector);
+  TNode<HeapObject> vector = CAST(Parameter(Descriptor::kVector));
  TNode<Context> context = CAST(Parameter(Descriptor::kContext));
  LoadICParameters p(context, receiver, name, slot, vector);

--- a/src/ic/accessor-assembler.h
+++ b/src/ic/accessor-assembler.h
@@ -55,26 +55,30 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  void GenerateStoreInArrayLiteralIC();
-  void TryProbeStubCache(StubCache* stub_cache, Node* receiver,
+  void TryProbeStubCache(StubCache* stub_cache, TNode<Object> receiver,
-                         TNode<Object> name, Label* if_handler,
+                         TNode<Name> name, Label* if_handler,
                         TVariable<MaybeObject>* var_handler, Label* if_miss);
-  Node* StubCachePrimaryOffsetForTesting(Node* name, Node* map) {
+  TNode<IntPtrT> StubCachePrimaryOffsetForTesting(TNode<Name> name,
+                                                  TNode<Map> map) {
    return StubCachePrimaryOffset(name, map);
  }
-  Node* StubCacheSecondaryOffsetForTesting(Node* name, Node* map) {
+  TNode<IntPtrT> StubCacheSecondaryOffsetForTesting(TNode<Name> name,
-    return StubCacheSecondaryOffset(name, map);
+                                                    TNode<IntPtrT> seed) {
+    return StubCacheSecondaryOffset(name, seed);
  }
  struct LoadICParameters {
-    LoadICParameters(TNode<Context> context, Node* receiver, TNode<Object> name,
+    LoadICParameters(TNode<Context> context,
-                     TNode<Smi> slot, Node* vector, Node* holder = nullptr)
+                     base::Optional<TNode<Object>> receiver, TNode<Object> name,
+                     TNode<Smi> slot, TNode<HeapObject> vector,
+                     base::Optional<TNode<Object>> holder = base::nullopt)
        : context_(context),
          receiver_(receiver),
          name_(name),
          slot_(slot),
          vector_(vector),
-          holder_(holder ? holder : receiver) {}
+          holder_(holder ? holder.value() : receiver) {}
    LoadICParameters(const LoadICParameters* p, TNode<Object> unique_name)
        : context_(p->context_),
@@ -85,31 +89,33 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
          holder_(p->holder_) {}
    TNode<Context> context() const { return context_; }
-    Node* receiver() const { return receiver_; }
+    TNode<Object> receiver() const { return receiver_.value(); }
    TNode<Object> name() const { return name_; }
    TNode<Smi> slot() const { return slot_; }
-    Node* vector() const { return vector_; }
+    TNode<HeapObject> vector() const { return vector_; }
-    Node* holder() const { return holder_; }
+    TNode<Object> holder() const { return holder_.value(); }
+    bool receiver_is_null() const { return !receiver_.has_value(); }
   private:
    TNode<Context> context_;
-    Node* receiver_;
+    base::Optional<TNode<Object>> receiver_;
    TNode<Object> name_;
    TNode<Smi> slot_;
-    Node* vector_;
+    TNode<HeapObject> vector_;
-    Node* holder_;
+    base::Optional<TNode<Object>> holder_;
  };
  struct LazyLoadICParameters {
-    LazyLoadICParameters(LazyNode<Context> context, Node* receiver,
+    LazyLoadICParameters(LazyNode<Context> context, TNode<Object> receiver,
                         LazyNode<Object> name, LazyNode<Smi> slot,
-                         Node* vector, Node* holder = nullptr)
+                         TNode<HeapObject> vector,
+                         base::Optional<TNode<Object>> holder = base::nullopt)
        : context_(context),
          receiver_(receiver),
          name_(name),
          slot_(slot),
          vector_(vector),
-          holder_(holder ? holder : receiver) {}
+          holder_(holder ? holder.value() : receiver) {}
    explicit LazyLoadICParameters(const LoadICParameters* p)
        : receiver_(p->receiver()),
@@ -121,19 +127,19 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
    }
    TNode<Context> context() const { return context_(); }
-    Node* receiver() const { return receiver_; }
+    TNode<Object> receiver() const { return receiver_; }
    TNode<Object> name() const { return name_(); }
    TNode<Smi> slot() const { return slot_(); }
-    Node* vector() const { return vector_; }
+    TNode<HeapObject> vector() const { return vector_; }
-    Node* holder() const { return holder_; }
+    TNode<Object> holder() const { return holder_; }
   private:
    LazyNode<Context> context_;
-    Node* receiver_;
+    TNode<Object> receiver_;
    LazyNode<Object> name_;
    LazyNode<Smi> slot_;
-    Node* vector_;
+    TNode<HeapObject> vector_;
-    Node* holder_;
+    TNode<Object> holder_;
  };
  void LoadGlobalIC(TNode<HeapObject> maybe_feedback_vector,
@@ -149,21 +155,22 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
                              ExitPoint* exit_point);
  // Loads dataX field from the DataHandler object.
-  TNode<MaybeObject> LoadHandlerDataField(SloppyTNode<DataHandler> handler,
+  TNode<MaybeObject> LoadHandlerDataField(TNode<DataHandler> handler,
                                          int data_index);
 protected:
  struct StoreICParameters : public LoadICParameters {
-    StoreICParameters(TNode<Context> context, Node* receiver,
+    StoreICParameters(TNode<Context> context,
-                      TNode<Object> name, SloppyTNode<Object> value,
+                      base::Optional<TNode<Object>> receiver,
-                      TNode<Smi> slot, Node* vector)
+                      TNode<Object> name, TNode<Object> value, TNode<Smi> slot,
+                      TNode<HeapObject> vector)
        : LoadICParameters(context, receiver, name, slot, vector),
          value_(value) {}
-    SloppyTNode<Object> value() const { return value_; }
+    TNode<Object> value() const { return value_; }
   private:
-    SloppyTNode<Object> value_;
+    TNode<Object> value_;
  };
  enum class LoadAccessMode { kLoad, kHas };
@@ -186,9 +193,10 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  void JumpIfDataProperty(TNode<Uint32T> details, Label* writable,
                          Label* readonly);
-  void InvalidateValidityCellIfPrototype(Node* map, Node* bitfield3 = nullptr);
+  void InvalidateValidityCellIfPrototype(
+      TNode<Map> map, base::Optional<TNode<Uint32T>> bitfield3 = base::nullopt);
-  void OverwriteExistingFastDataProperty(SloppyTNode<HeapObject> object,
+  void OverwriteExistingFastDataProperty(TNode<HeapObject> object,
                                         TNode<Map> object_map,
                                         TNode<DescriptorArray> descriptors,
                                         TNode<IntPtrT> descriptor_name_index,
@@ -198,7 +206,7 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  void CheckFieldType(TNode<DescriptorArray> descriptors,
                      TNode<IntPtrT> name_index, TNode<Word32T> representation,
-                      Node* value, Label* bailout);
+                      TNode<Object> value, Label* bailout);
 private:
  // Stub generation entry points.
@@ -226,7 +234,8 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
                                  LoadAccessMode access_mode);
  void StoreIC(const StoreICParameters* p);
  void StoreGlobalIC(const StoreICParameters* p);
-  void StoreGlobalIC_PropertyCellCase(Node* property_cell, TNode<Object> value,
+  void StoreGlobalIC_PropertyCellCase(TNode<PropertyCell> property_cell,
+                                      TNode<Object> value,
                                      ExitPoint* exit_point, Label* miss);
  void KeyedStoreIC(const StoreICParameters* p);
  void StoreInArrayLiteralIC(const StoreICParameters* p);
@@ -250,15 +259,18 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
      ElementSupport support_elements = kOnlyProperties,
      LoadAccessMode access_mode = LoadAccessMode::kLoad);
-  void HandleLoadICSmiHandlerCase(
+  void HandleLoadICSmiHandlerCase(const LazyLoadICParameters* p,
-      const LazyLoadICParameters* p, SloppyTNode<HeapObject> holder,
+                                  TNode<Object> holder, TNode<Smi> smi_handler,
-      SloppyTNode<Smi> smi_handler, SloppyTNode<Object> handler, Label* miss,
+                                  TNode<Object> handler, Label* miss,
-      ExitPoint* exit_point, ICMode ic_mode, OnNonExistent on_nonexistent,
+                                  ExitPoint* exit_point, ICMode ic_mode,
-      ElementSupport support_elements, LoadAccessMode access_mode);
+                                  OnNonExistent on_nonexistent,
+                                  ElementSupport support_elements,
+                                  LoadAccessMode access_mode);
  void HandleLoadICProtoHandler(const LazyLoadICParameters* p,
                                TNode<DataHandler> handler,
-                                Variable* var_holder, Variable* var_smi_handler,
+                                TVariable<Object>* var_holder,
+                                TVariable<Object>* var_smi_handler,
                                Label* if_smi_handler, Label* miss,
                                ExitPoint* exit_point, ICMode ic_mode,
                                LoadAccessMode access_mode);
@@ -273,7 +285,7 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
                          TNode<WordT> handler_word, TNode<DataHandler> handler,
                          TNode<IntPtrT> handler_kind, ExitPoint* exit_point);
-  void HandleLoadField(SloppyTNode<JSObject> holder, TNode<WordT> handler_word,
+  void HandleLoadField(TNode<JSObject> holder, TNode<WordT> handler_word,
                       Variable* var_double_value, Label* rebox_double,
                       Label* miss, ExitPoint* exit_point);
@@ -282,15 +294,14 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
                       Label* can_access, Label* miss);
  void HandleLoadICSmiHandlerLoadNamedCase(
-      const LazyLoadICParameters* p, TNode<HeapObject> holder,
+      const LazyLoadICParameters* p, TNode<Object> holder,
      TNode<IntPtrT> handler_kind, TNode<WordT> handler_word,
-      Label* rebox_double, Variable* var_double_value,
+      Label* rebox_double, Variable* var_double_value, TNode<Object> handler,
-      SloppyTNode<Object> handler, Label* miss, ExitPoint* exit_point,
+      Label* miss, ExitPoint* exit_point, ICMode ic_mode,
-      ICMode ic_mode, OnNonExistent on_nonexistent,
+      OnNonExistent on_nonexistent, ElementSupport support_elements);
-      ElementSupport support_elements);
  void HandleLoadICSmiHandlerHasNamedCase(const LazyLoadICParameters* p,
-                                          TNode<HeapObject> holder,
+                                          TNode<Object> holder,
                                          TNode<IntPtrT> handler_kind,
                                          Label* miss, ExitPoint* exit_point,
                                          ICMode ic_mode);
@@ -322,9 +333,9 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
                                 TNode<StoreHandler> handler, Label* miss,
                                 ICMode ic_mode,
                                 ElementSupport support_elements);
-  void HandleStoreICSmiHandlerCase(SloppyTNode<Word32T> handler_word,
+  void HandleStoreICSmiHandlerCase(TNode<Word32T> handler_word,
-                                   SloppyTNode<JSObject> holder,
+                                   TNode<JSObject> holder, TNode<Object> value,
-                                   SloppyTNode<Object> value, Label* miss);
+                                   Label* miss);
  void HandleStoreFieldAndReturn(TNode<Word32T> handler_word,
                                 TNode<JSObject> holder, TNode<Object> value,
                                 base::Optional<TNode<Float64T>> double_value,
@@ -333,25 +344,24 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  void CheckPrototypeValidityCell(TNode<Object> maybe_validity_cell,
                                  Label* miss);
  void HandleStoreICNativeDataProperty(const StoreICParameters* p,
-                                       SloppyTNode<HeapObject> holder,
+                                       TNode<HeapObject> holder,
                                       TNode<Word32T> handler_word);
-  void HandleStoreToProxy(const StoreICParameters* p, Node* proxy, Label* miss,
+  void HandleStoreToProxy(const StoreICParameters* p, TNode<JSProxy> proxy,
-                          ElementSupport support_elements);
+                          Label* miss, ElementSupport support_elements);
-  void HandleStoreAccessor(const StoreICParameters* p,
+  void HandleStoreAccessor(const StoreICParameters* p, TNode<HeapObject> holder,
-                           SloppyTNode<HeapObject> holder,
                           TNode<Word32T> handler_word);
  // KeyedLoadIC_Generic implementation.
-  void GenericElementLoad(Node* receiver, TNode<Map> receiver_map,
+  void GenericElementLoad(TNode<HeapObject> receiver, TNode<Map> receiver_map,
-                          SloppyTNode<Int32T> instance_type, Node* index,
+                          TNode<Int32T> instance_type, TNode<IntPtrT> index,
                          Label* slow);
  enum UseStubCache { kUseStubCache, kDontUseStubCache };
-  void GenericPropertyLoad(Node* receiver, TNode<Map> receiver_map,
+  void GenericPropertyLoad(TNode<HeapObject> receiver, TNode<Map> receiver_map,
-                           SloppyTNode<Int32T> instance_type,
+                           TNode<Int32T> instance_type,
                           const LoadICParameters* p, Label* slow,
                           UseStubCache use_stub_cache = kUseStubCache);
@@ -380,20 +390,21 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  // Extends properties backing store by JSObject::kFieldsAdded elements,
  // returns updated properties backing store.
-  Node* ExtendPropertiesBackingStore(Node* object, Node* index);
+  TNode<PropertyArray> ExtendPropertiesBackingStore(TNode<HeapObject> object,
+                                                    TNode<IntPtrT> index);
-  void EmitFastElementsBoundsCheck(Node* object, Node* elements,
-                                   Node* intptr_index,
+  void EmitFastElementsBoundsCheck(TNode<JSObject> object,
-                                   Node* is_jsarray_condition, Label* miss);
+                                   TNode<FixedArrayBase> elements,
-  void EmitElementLoad(Node* object, TNode<Word32T> elements_kind,
+                                   TNode<IntPtrT> intptr_index,
-                       SloppyTNode<IntPtrT> key, Node* is_jsarray_condition,
+                                   TNode<BoolT> is_jsarray_condition,
+                                   Label* miss);
+  void EmitElementLoad(TNode<HeapObject> object, TNode<Word32T> elements_kind,
+                       TNode<IntPtrT> key, TNode<BoolT> is_jsarray_condition,
                       Label* if_hole, Label* rebox_double,
-                       Variable* var_double_value,
+                       TVariable<Float64T>* var_double_value,
                       Label* unimplemented_elements_kind, Label* out_of_bounds,
                       Label* miss, ExitPoint* exit_point,
                       LoadAccessMode access_mode = LoadAccessMode::kLoad);
-  void NameDictionaryNegativeLookup(Node* object, SloppyTNode<Name> name,
-                                    Label* miss);
  TNode<BoolT> IsPropertyDetailsConst(TNode<Uint32T> details);
  // Stub cache access helpers.
@@ -402,11 +413,12 @@ class V8_EXPORT_PRIVATE AccessorAssembler : public CodeStubAssembler {
  // including stub cache header.
  enum StubCacheTable : int;
-  Node* StubCachePrimaryOffset(Node* name, Node* map);
+  TNode<IntPtrT> StubCachePrimaryOffset(TNode<Name> name, TNode<Map> map);
-  Node* StubCacheSecondaryOffset(Node* name, Node* seed);
+  TNode<IntPtrT> StubCacheSecondaryOffset(TNode<Name> name,
+                                          TNode<IntPtrT> seed);
  void TryProbeStubCacheTable(StubCache* stub_cache, StubCacheTable table_id,
-                              Node* entry_offset, TNode<Object> name,
+                              TNode<IntPtrT> entry_offset, TNode<Object> name,
                              TNode<Map> map, Label* if_handler,
                              TVariable<MaybeObject>* var_handler,
                              Label* if_miss);
@@ -445,7 +457,7 @@ class ExitPoint {
  }
  template <class... TArgs>
-  void ReturnCallRuntime(Runtime::FunctionId function, Node* context,
+  void ReturnCallRuntime(Runtime::FunctionId function, TNode<Context> context,
                         TArgs... args) {
    if (IsDirect()) {
      asm_->TailCallRuntime(function, context, args...);
@@ -455,7 +467,8 @@ class ExitPoint {
  }
  template <class... TArgs>
-  void ReturnCallStub(Callable const& callable, Node* context, TArgs... args) {
+  void ReturnCallStub(Callable const& callable, TNode<Context> context,
+                      TArgs... args) {
    if (IsDirect()) {
      asm_->TailCallStub(callable, context, args...);
    } else {
@@ -464,8 +477,9 @@ class ExitPoint {
  }
  template <class... TArgs>
-  void ReturnCallStub(const CallInterfaceDescriptor& descriptor, Node* target,
+  void ReturnCallStub(const CallInterfaceDescriptor& descriptor,
-                      Node* context, TArgs... args) {
+                      TNode<Code> target, TNode<Context> context,
+                      TArgs... args) {
    if (IsDirect()) {
      asm_->TailCallStub(descriptor, target, context, args...);
    } else {

--- a/src/ic/keyed-store-generic.cc
+++ b/src/ic/keyed-store-generic.cc
@@ -1023,7 +1023,7 @@ void KeyedStoreGenericAssembler::KeyedStoreGeneric(
  {
    Comment("key is unique name");
    StoreICParameters p(context, receiver, var_unique.value(), value, {},
-                        nullptr);
+                        UndefinedConstant());
    ExitPoint direct_exit(this);
    EmitGenericPropertyStore(CAST(receiver), receiver_map, &p, &direct_exit,
                             &slow, language_mode);
@@ -1112,7 +1112,8 @@ void KeyedStoreGenericAssembler::SetProperty(TNode<Context> context,
                                             TNode<Name> unique_name,
                                             TNode<Object> value,
                                             LanguageMode language_mode) {
-  StoreICParameters p(context, receiver, unique_name, value, {}, nullptr);
+  StoreICParameters p(context, receiver, unique_name, value, {},
+                      UndefinedConstant());
  Label done(this), slow(this, Label::kDeferred);
  ExitPoint exit_point(this, [&](TNode<Object> result) { Goto(&done); });

--- a/test/cctest/test-accessor-assembler.cc
+++ b/test/cctest/test-accessor-assembler.cc
@@ -28,9 +28,10 @@ void TestStubCacheOffsetCalculation(StubCache::Table table) {
  AccessorAssembler m(data.state());
  {
-    Node* name = m.Parameter(0);
+    TNode<Name> name = m.CAST(m.Parameter(0));
-    Node* map = m.Parameter(1);
+    TNode<Map> map = m.CAST(m.Parameter(1));
-    Node* primary_offset = m.StubCachePrimaryOffsetForTesting(name, map);
+    TNode<IntPtrT> primary_offset =
+        m.StubCachePrimaryOffsetForTesting(name, map);
    Node* result;
    if (table == StubCache::kPrimary) {
      result = primary_offset;
@@ -59,7 +60,6 @@ void TestStubCacheOffsetCalculation(StubCache::Table table) {
  };
  Handle<Map> maps[] = {
-      Handle<Map>(Map(), isolate),
      factory->cell_map(),
      Map::Create(isolate, 0),
      factory->meta_map(),
@@ -128,8 +128,8 @@ TEST(TryProbeStubCache) {
  stub_cache.Clear();
  {
-    Node* receiver = m.Parameter(0);
+    TNode<Object> receiver = m.CAST(m.Parameter(0));
-    TNode<Object> name = m.CAST(m.Parameter(1));
+    TNode<Name> name = m.CAST(m.Parameter(1));
    TNode<MaybeObject> expected_handler =
        m.UncheckedCast<MaybeObject>(m.Parameter(2));