[csa][cleanup] TNodify To<Int32,Int64,IntPtr,Smi>Constant

BUG=v8:6949,v8:11074

Change-Id: Ia5a52dcf42559d97eb6fd4a24f4abd3c40226017
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2531792
Commit-Queue: Ross McIlroy <rmcilroy@chromium.org>
Reviewed-by: Santiago Aboy Solanes <solanes@chromium.org>
Cr-Commit-Position: refs/heads/master@{#71160}

src/builtins/builtins-string-gen.cc

@@ -1942,8 +1942,8 @@ void StringBuiltinsAssembler::CopyStringCharacters(
   int to_index_constant = 0, from_index_constant = 0;
   bool index_same = (from_encoding == to_encoding) &&
                     (from_index == to_index ||
-                     (ToInt32Constant(from_index, &from_index_constant) &&
-                      ToInt32Constant(to_index, &to_index_constant) &&
+                     (TryToInt32Constant(from_index, &from_index_constant) &&
+                      TryToInt32Constant(to_index, &to_index_constant) &&
                       from_index_constant == to_index_constant));
   BuildFastLoop<IntPtrT>(
       vars, from_offset, limit_offset,

src/codegen/code-stub-assembler.cc

@@ -292,7 +292,7 @@ TNode<RawPtrT> CodeStubAssembler::IntPtrOrSmiConstant<RawPtrT>(int value) {
 bool CodeStubAssembler::TryGetIntPtrOrSmiConstantValue(
     TNode<Smi> maybe_constant, int* value) {
   Smi smi_constant;
-  if (ToSmiConstant(maybe_constant, &smi_constant)) {
+  if (TryToSmiConstant(maybe_constant, &smi_constant)) {
     *value = Smi::ToInt(smi_constant);
     return true;
   }
@@ -302,7 +302,7 @@ bool CodeStubAssembler::TryGetIntPtrOrSmiConstantValue(
 bool CodeStubAssembler::TryGetIntPtrOrSmiConstantValue(
     TNode<IntPtrT> maybe_constant, int* value) {
   int32_t int32_constant;
-    if (ToInt32Constant(maybe_constant, &int32_constant)) {
+  if (TryToInt32Constant(maybe_constant, &int32_constant)) {
     *value = int32_constant;
     return true;
   }
@@ -322,7 +322,7 @@ TNode<IntPtrT> CodeStubAssembler::IntPtrRoundUpToPowerOfTwo32(
 
 TNode<BoolT> CodeStubAssembler::WordIsPowerOfTwo(SloppyTNode<IntPtrT> value) {
   intptr_t constant;
-  if (ToIntPtrConstant(value, &constant)) {
+  if (TryToIntPtrConstant(value, &constant)) {
     return BoolConstant(base::bits::IsPowerOfTwo(constant));
   }
   // value && !(value & (value - 1))
@@ -628,7 +628,7 @@ TNode<Smi> CodeStubAssembler::SmiFromUint32(TNode<Uint32T> value) {
 
 TNode<BoolT> CodeStubAssembler::IsValidPositiveSmi(TNode<IntPtrT> value) {
   intptr_t constant_value;
-  if (ToIntPtrConstant(value, &constant_value)) {
+  if (TryToIntPtrConstant(value, &constant_value)) {
     return (static_cast<uintptr_t>(constant_value) <=
             static_cast<uintptr_t>(Smi::kMaxValue))
                ? Int32TrueConstant()
@@ -640,7 +640,8 @@ TNode<BoolT> CodeStubAssembler::IsValidPositiveSmi(TNode<IntPtrT> value) {
 
 TNode<Smi> CodeStubAssembler::SmiTag(SloppyTNode<IntPtrT> value) {
   int32_t constant_value;
-  if (ToInt32Constant(value, &constant_value) && Smi::IsValid(constant_value)) {
+  if (TryToInt32Constant(value, &constant_value) &&
+      Smi::IsValid(constant_value)) {
     return SmiConstant(constant_value);
   }
   if (COMPRESS_POINTERS_BOOL) {
@@ -653,7 +654,7 @@ TNode<Smi> CodeStubAssembler::SmiTag(SloppyTNode<IntPtrT> value) {
 
 TNode<IntPtrT> CodeStubAssembler::SmiUntag(SloppyTNode<Smi> value) {
   intptr_t constant_value;
-  if (ToIntPtrConstant(value, &constant_value)) {
+  if (TryToIntPtrConstant(value, &constant_value)) {
     return IntPtrConstant(constant_value >> (kSmiShiftSize + kSmiTagSize));
   }
   TNode<IntPtrT> raw_bits = BitcastTaggedToWordForTagAndSmiBits(value);
@@ -1086,7 +1087,7 @@ TNode<HeapObject> CodeStubAssembler::AllocateRaw(TNode<IntPtrT> size_in_bytes,
 
   intptr_t size_in_bytes_constant;
   bool size_in_bytes_is_constant = false;
-  if (ToIntPtrConstant(size_in_bytes, &size_in_bytes_constant)) {
+  if (TryToIntPtrConstant(size_in_bytes, &size_in_bytes_constant)) {
     size_in_bytes_is_constant = true;
     CHECK(Internals::IsValidSmi(size_in_bytes_constant));
     CHECK_GT(size_in_bytes_constant, 0);
@@ -1243,7 +1244,7 @@ TNode<HeapObject> CodeStubAssembler::Allocate(TNode<IntPtrT> size_in_bytes,
       !new_space || !allow_large_objects || FLAG_young_generation_large_objects;
   if (!allow_large_objects) {
     intptr_t size_constant;
-    if (ToIntPtrConstant(size_in_bytes, &size_constant)) {
+    if (TryToIntPtrConstant(size_in_bytes, &size_constant)) {
       CHECK_LE(size_constant, kMaxRegularHeapObjectSize);
     } else {
       CSA_ASSERT(this, IsRegularHeapObjectSize(size_in_bytes));
@@ -2055,7 +2056,7 @@ void CodeStubAssembler::FixedArrayBoundsCheck(TNode<FixedArrayBase> array,
   DCHECK(IsAligned(additional_offset, kTaggedSize));
   TNode<Smi> effective_index;
   Smi constant_index;
-  bool index_is_constant = ToSmiConstant(index, &constant_index);
+  bool index_is_constant = TryToSmiConstant(index, &constant_index);
   if (index_is_constant) {
     effective_index = SmiConstant(Smi::ToInt(constant_index) +
                                   additional_offset / kTaggedSize);
@@ -2735,7 +2736,7 @@ void CodeStubAssembler::StoreObjectField(TNode<HeapObject> object,
                                          TNode<IntPtrT> offset,
                                          TNode<Object> value) {
   int const_offset;
-  if (ToInt32Constant(offset, &const_offset)) {
+  if (TryToInt32Constant(offset, &const_offset)) {
     StoreObjectField(object, const_offset, value);
   } else {
     Store(object, IntPtrSub(offset, IntPtrConstant(kHeapObjectTag)), value);
@@ -3593,7 +3594,7 @@ CodeStubAssembler::AllocateUninitializedJSArrayWithElements(
   Label out(this), empty(this), nonempty(this);
 
   int capacity_int;
-  if (ToInt32Constant(capacity, &capacity_int)) {
+  if (TryToInt32Constant(capacity, &capacity_int)) {
     if (capacity_int == 0) {
       TNode<FixedArray> empty_array = EmptyFixedArrayConstant();
       array = AllocateJSArray(array_map, empty_array, length, allocation_site,
@@ -7630,8 +7631,8 @@ TNode<IntPtrT> CodeStubAssembler::IntPtrMax(SloppyTNode<IntPtrT> left,
                                             SloppyTNode<IntPtrT> right) {
   intptr_t left_constant;
   intptr_t right_constant;
-  if (ToIntPtrConstant(left, &left_constant) &&
-      ToIntPtrConstant(right, &right_constant)) {
+  if (TryToIntPtrConstant(left, &left_constant) &&
+      TryToIntPtrConstant(right, &right_constant)) {
     return IntPtrConstant(std::max(left_constant, right_constant));
   }
   return SelectConstant<IntPtrT>(IntPtrGreaterThanOrEqual(left, right), left,
@@ -7642,8 +7643,8 @@ TNode<IntPtrT> CodeStubAssembler::IntPtrMin(SloppyTNode<IntPtrT> left,
                                             SloppyTNode<IntPtrT> right) {
   intptr_t left_constant;
   intptr_t right_constant;
-  if (ToIntPtrConstant(left, &left_constant) &&
-      ToIntPtrConstant(right, &right_constant)) {
+  if (TryToIntPtrConstant(left, &left_constant) &&
+      TryToIntPtrConstant(right, &right_constant)) {
     return IntPtrConstant(std::min(left_constant, right_constant));
   }
   return SelectConstant<IntPtrT>(IntPtrLessThanOrEqual(left, right), left,
@@ -7654,8 +7655,8 @@ TNode<UintPtrT> CodeStubAssembler::UintPtrMin(TNode<UintPtrT> left,
                                               TNode<UintPtrT> right) {
   intptr_t left_constant;
   intptr_t right_constant;
-  if (ToIntPtrConstant(left, &left_constant) &&
-      ToIntPtrConstant(right, &right_constant)) {
+  if (TryToIntPtrConstant(left, &left_constant) &&
+      TryToIntPtrConstant(right, &right_constant)) {
     return UintPtrConstant(std::min(static_cast<uintptr_t>(left_constant),
                                     static_cast<uintptr_t>(right_constant)));
   }
@@ -9295,7 +9296,7 @@ TNode<IntPtrT> CodeStubAssembler::ElementOffsetFromIndex(
     int const kSmiShiftBits = kSmiShiftSize + kSmiTagSize;
     element_size_shift -= kSmiShiftBits;
     Smi smi_index;
-    constant_index = ToSmiConstant(smi_index_node, &smi_index);
+    constant_index = TryToSmiConstant(smi_index_node, &smi_index);
     if (constant_index) {
       index = smi_index.value();
     } else {
@@ -9309,10 +9310,10 @@ TNode<IntPtrT> CodeStubAssembler::ElementOffsetFromIndex(
         ReinterpretCast<TaggedIndex>(index_node);
     element_size_shift -= kSmiTagSize;
     intptr_index_node = BitcastTaggedToWordForTagAndSmiBits(tagged_index_node);
-    constant_index = ToIntPtrConstant(intptr_index_node, &index);
+    constant_index = TryToIntPtrConstant(intptr_index_node, &index);
   } else {
     intptr_index_node = ReinterpretCast<IntPtrT>(index_node);
-    constant_index = ToIntPtrConstant(intptr_index_node, &index);
+    constant_index = TryToIntPtrConstant(intptr_index_node, &index);
   }
   if (constant_index) {
     return IntPtrConstant(base_size + element_size * index);
@@ -10387,7 +10388,7 @@ TNode<TIndex> CodeStubAssembler::BuildFastLoop(const VariableList& vars,
   // loop actually iterates.
   TNode<BoolT> first_check = IntPtrOrSmiEqual(var.value(), end_index);
   int32_t first_check_val;
-  if (ToInt32Constant(first_check, &first_check_val)) {
+  if (TryToInt32Constant(first_check, &first_check_val)) {
     if (first_check_val) return var.value();
     Goto(&loop);
   } else {
@@ -10435,23 +10436,24 @@ void CodeStubAssembler::BuildFastArrayForEach(
   CSA_SLOW_ASSERT(this, Word32Or(IsFixedArrayWithKind(array, kind),
                                  IsPropertyArray(array)));
 
-  int32_t first_val;
-  bool constant_first = ToInt32Constant(first_element_inclusive, &first_val);
-  int32_t last_val;
-  bool constent_last = ToInt32Constant(last_element_exclusive, &last_val);
+  intptr_t first_val;
+  bool constant_first =
+      TryToIntPtrConstant(first_element_inclusive, &first_val);
+  intptr_t last_val;
+  bool constent_last = TryToIntPtrConstant(last_element_exclusive, &last_val);
   if (constant_first && constent_last) {
-    int delta = last_val - first_val;
+    intptr_t delta = last_val - first_val;
     DCHECK_GE(delta, 0);
     if (delta <= kElementLoopUnrollThreshold) {
       if (direction == ForEachDirection::kForward) {
-        for (int i = first_val; i < last_val; ++i) {
+        for (intptr_t i = first_val; i < last_val; ++i) {
           TNode<IntPtrT> index = IntPtrConstant(i);
           TNode<IntPtrT> offset = ElementOffsetFromIndex(
               index, kind, FixedArray::kHeaderSize - kHeapObjectTag);
           body(array, offset);
         }
       } else {
-        for (int i = last_val - 1; i >= first_val; --i) {
+        for (intptr_t i = last_val - 1; i >= first_val; --i) {
           TNode<IntPtrT> index = IntPtrConstant(i);
           TNode<IntPtrT> offset = ElementOffsetFromIndex(
               index, kind, FixedArray::kHeaderSize - kHeapObjectTag);

src/codegen/code-stub-assembler.h

@@ -341,9 +341,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   TNode<TIndex> TaggedToParameter(TNode<Smi> value);
 
   bool ToParameterConstant(TNode<Smi> node, intptr_t* out) {
-    Smi constant;
-    if (ToSmiConstant(node, &constant)) {
-      *out = static_cast<intptr_t>(constant.value());
+    if (TryToIntPtrConstant(node, out)) {
       return true;
     }
     return false;
@@ -351,7 +349,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
 
   bool ToParameterConstant(TNode<IntPtrT> node, intptr_t* out) {
     intptr_t constant;
-    if (ToIntPtrConstant(node, &constant)) {
+    if (TryToIntPtrConstant(node, &constant)) {
       *out = constant;
       return true;
     }
@@ -1508,7 +1506,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
                                       SloppyTNode<IntPtrT> offset,
                                       TNode<T> value) {
     int const_offset;
-    if (ToInt32Constant(offset, &const_offset)) {
+    if (TryToInt32Constant(offset, &const_offset)) {
       return StoreObjectFieldNoWriteBarrier<T>(object, const_offset, value);
     }
     StoreNoWriteBarrier(MachineRepresentationOf<T>::value, object,

src/compiler/code-assembler.cc

@@ -315,7 +315,8 @@ TNode<Float64T> CodeAssembler::Float64Constant(double value) {
   return UncheckedCast<Float64T>(jsgraph()->Float64Constant(value));
 }
 
-bool CodeAssembler::ToInt32Constant(Node* node, int32_t* out_value) {
+bool CodeAssembler::TryToInt32Constant(TNode<IntegralT> node,
+                                       int32_t* out_value) {
   {
     Int64Matcher m(node);
     if (m.HasResolvedValue() &&
@@ -337,16 +338,22 @@ bool CodeAssembler::ToInt32Constant(Node* node, int32_t* out_value) {
   return false;
 }
 
-bool CodeAssembler::ToInt64Constant(Node* node, int64_t* out_value) {
+bool CodeAssembler::TryToInt64Constant(TNode<IntegralT> node,
+                                       int64_t* out_value) {
   Int64Matcher m(node);
   if (m.HasResolvedValue()) *out_value = m.ResolvedValue();
   return m.HasResolvedValue();
 }
 
-bool CodeAssembler::ToSmiConstant(Node* node, Smi* out_value) {
+bool CodeAssembler::TryToSmiConstant(TNode<Smi> tnode, Smi* out_value) {
+  Node* node = tnode;
   if (node->opcode() == IrOpcode::kBitcastWordToTaggedSigned) {
     node = node->InputAt(0);
   }
+  return TryToSmiConstant(ReinterpretCast<IntPtrT>(tnode), out_value);
+}
+
+bool CodeAssembler::TryToSmiConstant(TNode<IntegralT> node, Smi* out_value) {
   IntPtrMatcher m(node);
   if (m.HasResolvedValue()) {
     intptr_t value = m.ResolvedValue();
@@ -358,11 +365,17 @@ bool CodeAssembler::ToSmiConstant(Node* node, Smi* out_value) {
   return false;
 }
 
-bool CodeAssembler::ToIntPtrConstant(Node* node, intptr_t* out_value) {
+bool CodeAssembler::TryToIntPtrConstant(TNode<Smi> tnode, intptr_t* out_value) {
+  Node* node = tnode;
   if (node->opcode() == IrOpcode::kBitcastWordToTaggedSigned ||
       node->opcode() == IrOpcode::kBitcastWordToTagged) {
     node = node->InputAt(0);
   }
+  return TryToIntPtrConstant(ReinterpretCast<IntPtrT>(tnode), out_value);
+}
+
+bool CodeAssembler::TryToIntPtrConstant(TNode<IntegralT> node,
+                                        intptr_t* out_value) {
   IntPtrMatcher m(node);
   if (m.HasResolvedValue()) *out_value = m.ResolvedValue();
   return m.HasResolvedValue();
@@ -577,13 +590,13 @@ TNode<Word32T> CodeAssembler::Word32Sar(SloppyTNode<Word32T> value, int shift) {
     return UncheckedCast<BoolT>(raw_assembler()->Name(left, right));      \
   }
 
-CODE_ASSEMBLER_COMPARE(IntPtrEqual, WordT, intptr_t, ToIntPtrConstant, ==)
-CODE_ASSEMBLER_COMPARE(WordEqual, WordT, intptr_t, ToIntPtrConstant, ==)
-CODE_ASSEMBLER_COMPARE(WordNotEqual, WordT, intptr_t, ToIntPtrConstant, !=)
-CODE_ASSEMBLER_COMPARE(Word32Equal, Word32T, int32_t, ToInt32Constant, ==)
-CODE_ASSEMBLER_COMPARE(Word32NotEqual, Word32T, int32_t, ToInt32Constant, !=)
-CODE_ASSEMBLER_COMPARE(Word64Equal, Word64T, int64_t, ToInt64Constant, ==)
-CODE_ASSEMBLER_COMPARE(Word64NotEqual, Word64T, int64_t, ToInt64Constant, !=)
+CODE_ASSEMBLER_COMPARE(IntPtrEqual, WordT, intptr_t, TryToIntPtrConstant, ==)
+CODE_ASSEMBLER_COMPARE(WordEqual, WordT, intptr_t, TryToIntPtrConstant, ==)
+CODE_ASSEMBLER_COMPARE(WordNotEqual, WordT, intptr_t, TryToIntPtrConstant, !=)
+CODE_ASSEMBLER_COMPARE(Word32Equal, Word32T, int32_t, TryToInt32Constant, ==)
+CODE_ASSEMBLER_COMPARE(Word32NotEqual, Word32T, int32_t, TryToInt32Constant, !=)
+CODE_ASSEMBLER_COMPARE(Word64Equal, Word64T, int64_t, TryToInt64Constant, ==)
+CODE_ASSEMBLER_COMPARE(Word64NotEqual, Word64T, int64_t, TryToInt64Constant, !=)
 #undef CODE_ASSEMBLER_COMPARE
 
 TNode<UintPtrT> CodeAssembler::ChangeUint32ToWord(TNode<Word32T> value) {
@@ -1202,7 +1215,7 @@ void CodeAssembler::GotoIfNot(TNode<IntegralT> condition, Label* false_label) {
 void CodeAssembler::Branch(TNode<IntegralT> condition, Label* true_label,
                            Label* false_label) {
   int32_t constant;
-  if (ToInt32Constant(condition, &constant)) {
+  if (TryToInt32Constant(condition, &constant)) {
     if ((true_label->is_used() || true_label->is_bound()) &&
         (false_label->is_used() || false_label->is_bound())) {
       return Goto(constant ? true_label : false_label);
@@ -1218,7 +1231,7 @@ void CodeAssembler::Branch(TNode<BoolT> condition,
                            const std::function<void()>& true_body,
                            const std::function<void()>& false_body) {
   int32_t constant;
-  if (ToInt32Constant(condition, &constant)) {
+  if (TryToInt32Constant(condition, &constant)) {
     return constant ? true_body() : false_body();
   }
 
@@ -1235,7 +1248,7 @@ void CodeAssembler::Branch(TNode<BoolT> condition,
 void CodeAssembler::Branch(TNode<BoolT> condition, Label* true_label,
                            const std::function<void()>& false_body) {
   int32_t constant;
-  if (ToInt32Constant(condition, &constant)) {
+  if (TryToInt32Constant(condition, &constant)) {
     return constant ? Goto(true_label) : false_body();
   }
 
@@ -1249,7 +1262,7 @@ void CodeAssembler::Branch(TNode<BoolT> condition,
                            const std::function<void()>& true_body,
                            Label* false_label) {
   int32_t constant;
-  if (ToInt32Constant(condition, &constant)) {
+  if (TryToInt32Constant(condition, &constant)) {
     return constant ? true_body() : Goto(false_label);
   }
 

src/compiler/code-assembler.h

@@ -565,10 +565,12 @@ class V8_EXPORT_PRIVATE CodeAssembler {
     return value ? Int32TrueConstant() : Int32FalseConstant();
   }
 
-  bool ToInt32Constant(Node* node, int32_t* out_value);
-  bool ToInt64Constant(Node* node, int64_t* out_value);
-  bool ToIntPtrConstant(Node* node, intptr_t* out_value);
-  bool ToSmiConstant(Node* node, Smi* out_value);
+  bool TryToInt32Constant(TNode<IntegralT> node, int32_t* out_value);
+  bool TryToInt64Constant(TNode<IntegralT> node, int64_t* out_value);
+  bool TryToIntPtrConstant(TNode<IntegralT> node, intptr_t* out_value);
+  bool TryToIntPtrConstant(TNode<Smi> tnode, intptr_t* out_value);
+  bool TryToSmiConstant(TNode<IntegralT> node, Smi* out_value);
+  bool TryToSmiConstant(TNode<Smi> node, Smi* out_value);
 
   bool IsUndefinedConstant(TNode<Object> node);
   bool IsNullConstant(TNode<Object> node);

test/cctest/compiler/test-code-assembler.cc

@@ -22,9 +22,9 @@ namespace {
 template <class T>
 using TVariable = TypedCodeAssemblerVariable<T>;
 
-TNode<Smi> SmiTag(CodeAssembler* m, Node* value) {
+TNode<Smi> SmiTag(CodeAssembler* m, TNode<IntPtrT> value) {
   int32_t constant_value;
-  if (m->ToInt32Constant(value, &constant_value) &&
+  if (m->TryToInt32Constant(value, &constant_value) &&
       Smi::IsValid(constant_value)) {
     return m->SmiConstant(Smi::FromInt(constant_value));
   }
@@ -51,7 +51,7 @@ TEST(SimpleSmiReturn) {
   Isolate* isolate(CcTest::InitIsolateOnce());
   CodeAssemblerTester asm_tester(isolate);
   CodeAssembler m(asm_tester.state());
-  m.Return(SmiTag(&m, m.Int32Constant(37)));
+  m.Return(SmiTag(&m, m.IntPtrConstant(37)));
   FunctionTester ft(asm_tester.GenerateCode());
   CHECK_EQ(37, ft.CallChecked<Smi>()->value());
 }
@@ -83,7 +83,7 @@ TEST(SimpleCallRuntime1Arg) {
   CodeAssembler m(asm_tester.state());
   TNode<Context> context =
       m.HeapConstant(Handle<Context>(isolate->native_context()));
-  TNode<Smi> b = SmiTag(&m, m.Int32Constant(0));
+  TNode<Smi> b = SmiTag(&m, m.IntPtrConstant(0));
   m.Return(m.CallRuntime(Runtime::kIsSmi, context, b));
   FunctionTester ft(asm_tester.GenerateCode());
   CHECK(ft.CallChecked<Oddball>().is_identical_to(
@@ -96,7 +96,7 @@ TEST(SimpleTailCallRuntime1Arg) {
   CodeAssembler m(asm_tester.state());
   TNode<Context> context =
       m.HeapConstant(Handle<Context>(isolate->native_context()));
-  TNode<Smi> b = SmiTag(&m, m.Int32Constant(0));
+  TNode<Smi> b = SmiTag(&m, m.IntPtrConstant(0));
   m.TailCallRuntime(Runtime::kIsSmi, context, b);
   FunctionTester ft(asm_tester.GenerateCode());
   CHECK(ft.CallChecked<Oddball>().is_identical_to(
@@ -109,8 +109,8 @@ TEST(SimpleCallRuntime2Arg) {
   CodeAssembler m(asm_tester.state());
   TNode<Context> context =
       m.HeapConstant(Handle<Context>(isolate->native_context()));
-  TNode<Smi> a = SmiTag(&m, m.Int32Constant(2));
-  TNode<Smi> b = SmiTag(&m, m.Int32Constant(4));
+  TNode<Smi> a = SmiTag(&m, m.IntPtrConstant(2));
+  TNode<Smi> b = SmiTag(&m, m.IntPtrConstant(4));
   m.Return(m.CallRuntime(Runtime::kAdd, context, a, b));
   FunctionTester ft(asm_tester.GenerateCode());
   CHECK_EQ(6, ft.CallChecked<Smi>()->value());
@@ -122,8 +122,8 @@ TEST(SimpleTailCallRuntime2Arg) {
   CodeAssembler m(asm_tester.state());
   TNode<Context> context =
       m.HeapConstant(Handle<Context>(isolate->native_context()));
-  TNode<Smi> a = SmiTag(&m, m.Int32Constant(2));
-  TNode<Smi> b = SmiTag(&m, m.Int32Constant(4));
+  TNode<Smi> a = SmiTag(&m, m.IntPtrConstant(2));
+  TNode<Smi> b = SmiTag(&m, m.IntPtrConstant(4));
   m.TailCallRuntime(Runtime::kAdd, context, a, b);
   FunctionTester ft(asm_tester.GenerateCode());
   CHECK_EQ(6, ft.CallChecked<Smi>()->value());
@@ -155,7 +155,7 @@ TEST(SimpleCallJSFunction0Arg) {
     auto function = m.Parameter<JSFunction>(1);
     auto context = m.Parameter<Context>(kContextOffset);
 
-    auto receiver = SmiTag(&m, m.Int32Constant(42));
+    auto receiver = SmiTag(&m, m.IntPtrConstant(42));
 
     Callable callable = CodeFactory::Call(isolate);
     TNode<Object> result = m.CallJS(callable, context, function, receiver);
@@ -178,8 +178,8 @@ TEST(SimpleCallJSFunction1Arg) {
     auto function = m.Parameter<JSFunction>(1);
     auto context = m.Parameter<Context>(kContextOffset);
 
-    Node* receiver = SmiTag(&m, m.Int32Constant(42));
-    Node* a = SmiTag(&m, m.Int32Constant(13));
+    Node* receiver = SmiTag(&m, m.IntPtrConstant(42));
+    Node* a = SmiTag(&m, m.IntPtrConstant(13));
 
     Callable callable = CodeFactory::Call(isolate);
     TNode<Object> result = m.CallJS(callable, context, function, receiver, a);
@@ -202,9 +202,9 @@ TEST(SimpleCallJSFunction2Arg) {
     auto function = m.Parameter<JSFunction>(1);
     auto context = m.Parameter<Context>(kContextOffset);
 
-    Node* receiver = SmiTag(&m, m.Int32Constant(42));
-    Node* a = SmiTag(&m, m.Int32Constant(13));
-    Node* b = SmiTag(&m, m.Int32Constant(153));
+    Node* receiver = SmiTag(&m, m.IntPtrConstant(42));
+    Node* a = SmiTag(&m, m.IntPtrConstant(13));
+    Node* b = SmiTag(&m, m.IntPtrConstant(153));
 
     Callable callable = CodeFactory::Call(isolate);
     TNode<Object> result =
@@ -372,25 +372,25 @@ TEST(TestToConstant) {
   CodeAssembler m(asm_tester.state());
   int32_t value32;
   int64_t value64;
-  Node* a = m.Int32Constant(5);
-  CHECK(m.ToInt32Constant(a, &value32));
-  CHECK(m.ToInt64Constant(a, &value64));
+  TNode<Int32T> a = m.Int32Constant(5);
+  CHECK(m.TryToInt32Constant(a, &value32));
+  CHECK(m.TryToInt64Constant(a, &value64));
 
-  a = m.Int64Constant(static_cast<int64_t>(1) << 32);
-  CHECK(!m.ToInt32Constant(a, &value32));
-  CHECK(m.ToInt64Constant(a, &value64));
+  TNode<Int64T> b = m.Int64Constant(static_cast<int64_t>(1) << 32);
+  CHECK(!m.TryToInt32Constant(b, &value32));
+  CHECK(m.TryToInt64Constant(b, &value64));
 
-  a = m.Int64Constant(13);
-  CHECK(m.ToInt32Constant(a, &value32));
-  CHECK(m.ToInt64Constant(a, &value64));
+  b = m.Int64Constant(13);
+  CHECK(m.TryToInt32Constant(b, &value32));
+  CHECK(m.TryToInt64Constant(b, &value64));
 
-  a = UndefinedConstant(&m);
-  CHECK(!m.ToInt32Constant(a, &value32));
-  CHECK(!m.ToInt64Constant(a, &value64));
+  TNode<Int32T> c = m.Word32Shl(m.Int32Constant(13), m.Int32Constant(14));
+  CHECK(!m.TryToInt32Constant(c, &value32));
+  CHECK(!m.TryToInt64Constant(c, &value64));
 
-  a = UndefinedConstant(&m);
-  CHECK(!m.ToInt32Constant(a, &value32));
-  CHECK(!m.ToInt64Constant(a, &value64));
+  TNode<IntPtrT> d = m.ReinterpretCast<IntPtrT>(UndefinedConstant(&m));
+  CHECK(!m.TryToInt32Constant(d, &value32));
+  CHECK(!m.TryToInt64Constant(d, &value64));
 }
 
 TEST(DeferredCodePhiHints) {