[CSA] TNodify Bytecode operands and constant pool loading

TNodified from interpreter-generator:
 * SwitchOnSmiNoFeedback
 * CreateFunctionContext
 * CreateEvalContext
 * SwitchOnGeneratorState
since they were using some of the interpreter-assembler now TNodified
methods.

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

src/builtins/base.tq

@@ -2530,6 +2530,7 @@ extern macro Signed(RawPtr): intptr;
 extern macro TruncateIntPtrToInt32(intptr): int32;
 extern macro SmiTag(intptr): Smi;
 extern macro SmiFromInt32(int32): Smi;
+extern macro SmiFromUint32(uint32): Smi;
 extern macro SmiUntag(Smi): intptr;
 extern macro SmiToInt32(Smi): int32;
 extern macro RoundIntPtrToFloat64(intptr): float64;
@@ -2691,7 +2692,7 @@ Convert<Number, uint32>(ui: uint32): Number {
   return ChangeUint32ToTagged(ui);
 }
 Convert<Smi, uint32>(ui: uint32): Smi {
-  return SmiFromInt32(Signed(ui));
+  return SmiFromUint32(ui);
 }
 Convert<uintptr, uint32>(ui: uint32): uintptr {
   return ChangeUint32ToWord(ui);

src/codegen/code-stub-assembler.cc

@@ -595,6 +595,12 @@ TNode<Smi> CodeStubAssembler::SmiFromInt32(SloppyTNode<Int32T> value) {
   return smi;
 }
 
+TNode<Smi> CodeStubAssembler::SmiFromUint32(TNode<Uint32T> value) {
+  CSA_ASSERT(this, IntPtrLessThan(ChangeUint32ToWord(value),
+                                  IntPtrConstant(Smi::kMaxValue)));
+  return SmiFromInt32(Signed(value));
+}
+
 TNode<BoolT> CodeStubAssembler::IsValidPositiveSmi(TNode<IntPtrT> value) {
   intptr_t constant_value;
   if (ToIntPtrConstant(value, &constant_value)) {

src/codegen/code-stub-assembler.h

@@ -557,6 +557,7 @@ class V8_EXPORT_PRIVATE CodeStubAssembler
   TNode<Float64T> SmiToFloat64(SloppyTNode<Smi> value);
   TNode<Smi> SmiFromIntPtr(SloppyTNode<IntPtrT> value) { return SmiTag(value); }
   TNode<Smi> SmiFromInt32(SloppyTNode<Int32T> value);
+  TNode<Smi> SmiFromUint32(TNode<Uint32T> value);
   TNode<IntPtrT> SmiToIntPtr(SloppyTNode<Smi> value) { return SmiUntag(value); }
   TNode<Int32T> SmiToInt32(SloppyTNode<Smi> value);
 

src/interpreter/interpreter-assembler.cc

@@ -562,7 +562,7 @@ TNode<Uint32T> InterpreterAssembler::BytecodeOperandCount(int operand_index) {
   return BytecodeUnsignedOperand(operand_index, operand_size);
 }
 
-Node* InterpreterAssembler::BytecodeOperandFlag(int operand_index) {
+TNode<Uint32T> InterpreterAssembler::BytecodeOperandFlag(int operand_index) {
   DCHECK_EQ(OperandType::kFlag8,
             Bytecodes::GetOperandType(bytecode_, operand_index));
   OperandSize operand_size =
@@ -579,15 +579,16 @@ TNode<Uint32T> InterpreterAssembler::BytecodeOperandUImm(int operand_index) {
   return BytecodeUnsignedOperand(operand_index, operand_size);
 }
 
-Node* InterpreterAssembler::BytecodeOperandUImmWord(int operand_index) {
+TNode<UintPtrT> InterpreterAssembler::BytecodeOperandUImmWord(
+    int operand_index) {
   return ChangeUint32ToWord(BytecodeOperandUImm(operand_index));
 }
 
-Node* InterpreterAssembler::BytecodeOperandUImmSmi(int operand_index) {
-  return SmiFromInt32(Signed(BytecodeOperandUImm(operand_index)));
+TNode<Smi> InterpreterAssembler::BytecodeOperandUImmSmi(int operand_index) {
+  return SmiFromUint32(BytecodeOperandUImm(operand_index));
 }
 
-Node* InterpreterAssembler::BytecodeOperandImm(int operand_index) {
+TNode<Int32T> InterpreterAssembler::BytecodeOperandImm(int operand_index) {
   DCHECK_EQ(OperandType::kImm,
             Bytecodes::GetOperandType(bytecode_, operand_index));
   OperandSize operand_size =
@@ -595,15 +596,17 @@ Node* InterpreterAssembler::BytecodeOperandImm(int operand_index) {
   return BytecodeSignedOperand(operand_index, operand_size);
 }
 
-Node* InterpreterAssembler::BytecodeOperandImmIntPtr(int operand_index) {
+TNode<IntPtrT> InterpreterAssembler::BytecodeOperandImmIntPtr(
+    int operand_index) {
   return ChangeInt32ToIntPtr(BytecodeOperandImm(operand_index));
 }
 
-Node* InterpreterAssembler::BytecodeOperandImmSmi(int operand_index) {
+TNode<Smi> InterpreterAssembler::BytecodeOperandImmSmi(int operand_index) {
   return SmiFromInt32(BytecodeOperandImm(operand_index));
 }
 
-Node* InterpreterAssembler::BytecodeOperandIdxInt32(int operand_index) {
+TNode<Uint32T> InterpreterAssembler::BytecodeOperandIdxInt32(
+    int operand_index) {
   DCHECK_EQ(OperandType::kIdx,
             Bytecodes::GetOperandType(bytecode_, operand_index));
   OperandSize operand_size =
@@ -611,15 +614,15 @@ Node* InterpreterAssembler::BytecodeOperandIdxInt32(int operand_index) {
   return BytecodeUnsignedOperand(operand_index, operand_size);
 }
 
-Node* InterpreterAssembler::BytecodeOperandIdx(int operand_index) {
+TNode<UintPtrT> InterpreterAssembler::BytecodeOperandIdx(int operand_index) {
   return ChangeUint32ToWord(BytecodeOperandIdxInt32(operand_index));
 }
 
-Node* InterpreterAssembler::BytecodeOperandIdxSmi(int operand_index) {
-  return SmiTag(BytecodeOperandIdx(operand_index));
+TNode<Smi> InterpreterAssembler::BytecodeOperandIdxSmi(int operand_index) {
+  return SmiTag(Signed(BytecodeOperandIdx(operand_index)));
 }
 
-Node* InterpreterAssembler::BytecodeOperandConstantPoolIdx(
+TNode<UintPtrT> InterpreterAssembler::BytecodeOperandConstantPoolIdx(
     int operand_index, LoadSensitivity needs_poisoning) {
   DCHECK_EQ(OperandType::kIdx,
             Bytecodes::GetOperandType(bytecode_, operand_index));
@@ -629,7 +632,7 @@ Node* InterpreterAssembler::BytecodeOperandConstantPoolIdx(
       BytecodeUnsignedOperand(operand_index, operand_size, needs_poisoning));
 }
 
-Node* InterpreterAssembler::BytecodeOperandReg(
+TNode<IntPtrT> InterpreterAssembler::BytecodeOperandReg(
     int operand_index, LoadSensitivity needs_poisoning) {
   DCHECK(Bytecodes::IsRegisterOperandType(
       Bytecodes::GetOperandType(bytecode_, operand_index)));
@@ -639,7 +642,8 @@ Node* InterpreterAssembler::BytecodeOperandReg(
       BytecodeSignedOperand(operand_index, operand_size, needs_poisoning));
 }
 
-Node* InterpreterAssembler::BytecodeOperandRuntimeId(int operand_index) {
+TNode<Uint32T> InterpreterAssembler::BytecodeOperandRuntimeId(
+    int operand_index) {
   DCHECK_EQ(OperandType::kRuntimeId,
             Bytecodes::GetOperandType(bytecode_, operand_index));
   OperandSize operand_size =
@@ -648,7 +652,7 @@ Node* InterpreterAssembler::BytecodeOperandRuntimeId(int operand_index) {
   return BytecodeUnsignedOperand(operand_index, operand_size);
 }
 
-Node* InterpreterAssembler::BytecodeOperandNativeContextIndex(
+TNode<UintPtrT> InterpreterAssembler::BytecodeOperandNativeContextIndex(
     int operand_index) {
   DCHECK_EQ(OperandType::kNativeContextIndex,
             Bytecodes::GetOperandType(bytecode_, operand_index));
@@ -658,7 +662,8 @@ Node* InterpreterAssembler::BytecodeOperandNativeContextIndex(
       BytecodeUnsignedOperand(operand_index, operand_size));
 }
 
-Node* InterpreterAssembler::BytecodeOperandIntrinsicId(int operand_index) {
+TNode<Uint32T> InterpreterAssembler::BytecodeOperandIntrinsicId(
+    int operand_index) {
   DCHECK_EQ(OperandType::kIntrinsicId,
             Bytecodes::GetOperandType(bytecode_, operand_index));
   OperandSize operand_size =
@@ -667,7 +672,7 @@ Node* InterpreterAssembler::BytecodeOperandIntrinsicId(int operand_index) {
   return BytecodeUnsignedOperand(operand_index, operand_size);
 }
 
-Node* InterpreterAssembler::LoadConstantPoolEntry(Node* index) {
+TNode<Object> InterpreterAssembler::LoadConstantPoolEntry(TNode<WordT> index) {
   TNode<FixedArray> constant_pool = CAST(LoadObjectField(
       BytecodeArrayTaggedPointer(), BytecodeArray::kConstantPoolOffset));
   return UnsafeLoadFixedArrayElement(
@@ -675,13 +680,13 @@ Node* InterpreterAssembler::LoadConstantPoolEntry(Node* index) {
 }
 
 TNode<IntPtrT> InterpreterAssembler::LoadAndUntagConstantPoolEntry(
-    Node* index) {
-  return SmiUntag(LoadConstantPoolEntry(index));
+    TNode<WordT> index) {
+  return SmiUntag(CAST(LoadConstantPoolEntry(index)));
 }
 
-Node* InterpreterAssembler::LoadConstantPoolEntryAtOperandIndex(
+TNode<Object> InterpreterAssembler::LoadConstantPoolEntryAtOperandIndex(
     int operand_index) {
-  Node* index =
+  TNode<UintPtrT> index =
       BytecodeOperandConstantPoolIdx(operand_index, LoadSensitivity::kSafe);
   return LoadConstantPoolEntry(index);
 }
@@ -689,7 +694,7 @@ Node* InterpreterAssembler::LoadConstantPoolEntryAtOperandIndex(
 TNode<IntPtrT>
 InterpreterAssembler::LoadAndUntagConstantPoolEntryAtOperandIndex(
     int operand_index) {
-  return SmiUntag(LoadConstantPoolEntryAtOperandIndex(operand_index));
+  return SmiUntag(CAST(LoadConstantPoolEntryAtOperandIndex(operand_index)));
 }
 
 TNode<HeapObject> InterpreterAssembler::LoadFeedbackVector() {
@@ -1804,7 +1809,7 @@ void InterpreterAssembler::ToNumberOrNumeric(Object::Conversion mode) {
   BIND(&if_done);
 
   // Record the type feedback collected for {object}.
-  Node* slot_index = BytecodeOperandIdx(0);
+  TNode<UintPtrT> slot_index = BytecodeOperandIdx(0);
   TNode<HeapObject> maybe_feedback_vector = LoadFeedbackVector();
 
   UpdateFeedback(var_type_feedback.value(), maybe_feedback_vector, slot_index);

src/interpreter/interpreter-assembler.h

@@ -28,44 +28,44 @@ class V8_EXPORT_PRIVATE InterpreterAssembler : public CodeStubAssembler {
   compiler::TNode<Uint32T> BytecodeOperandCount(int operand_index);
   // Returns the 32-bit unsigned flag for bytecode operand |operand_index|
   // in the current bytecode.
-  compiler::Node* BytecodeOperandFlag(int operand_index);
+  compiler::TNode<Uint32T> BytecodeOperandFlag(int operand_index);
   // Returns the 32-bit zero-extended index immediate for bytecode operand
   // |operand_index| in the current bytecode.
-  compiler::Node* BytecodeOperandIdxInt32(int operand_index);
+  compiler::TNode<Uint32T> BytecodeOperandIdxInt32(int operand_index);
   // Returns the word zero-extended index immediate for bytecode operand
   // |operand_index| in the current bytecode.
-  compiler::Node* BytecodeOperandIdx(int operand_index);
+  compiler::TNode<UintPtrT> BytecodeOperandIdx(int operand_index);
   // Returns the smi index immediate for bytecode operand |operand_index|
   // in the current bytecode.
-  compiler::Node* BytecodeOperandIdxSmi(int operand_index);
+  compiler::TNode<Smi> BytecodeOperandIdxSmi(int operand_index);
   // Returns the 32-bit unsigned immediate for bytecode operand |operand_index|
   // in the current bytecode.
   compiler::TNode<Uint32T> BytecodeOperandUImm(int operand_index);
   // Returns the word-size unsigned immediate for bytecode operand
   // |operand_index| in the current bytecode.
-  compiler::Node* BytecodeOperandUImmWord(int operand_index);
+  compiler::TNode<UintPtrT> BytecodeOperandUImmWord(int operand_index);
   // Returns the unsigned smi immediate for bytecode operand |operand_index| in
   // the current bytecode.
-  compiler::Node* BytecodeOperandUImmSmi(int operand_index);
+  compiler::TNode<Smi> BytecodeOperandUImmSmi(int operand_index);
   // Returns the 32-bit signed immediate for bytecode operand |operand_index|
   // in the current bytecode.
-  compiler::Node* BytecodeOperandImm(int operand_index);
+  compiler::TNode<Int32T> BytecodeOperandImm(int operand_index);
   // Returns the word-size signed immediate for bytecode operand |operand_index|
   // in the current bytecode.
-  compiler::Node* BytecodeOperandImmIntPtr(int operand_index);
+  compiler::TNode<IntPtrT> BytecodeOperandImmIntPtr(int operand_index);
   // Returns the smi immediate for bytecode operand |operand_index| in the
   // current bytecode.
-  compiler::Node* BytecodeOperandImmSmi(int operand_index);
+  compiler::TNode<Smi> BytecodeOperandImmSmi(int operand_index);
   // Returns the 32-bit unsigned runtime id immediate for bytecode operand
   // |operand_index| in the current bytecode.
-  compiler::Node* BytecodeOperandRuntimeId(int operand_index);
-  // Returns the 32-bit unsigned native context index immediate for bytecode
+  compiler::TNode<Uint32T> BytecodeOperandRuntimeId(int operand_index);
+  // Returns the word zero-extended native context index immediate for bytecode
   // operand |operand_index| in the current bytecode.
-  compiler::Node* BytecodeOperandNativeContextIndex(int operand_index);
+  compiler::TNode<UintPtrT> BytecodeOperandNativeContextIndex(
+      int operand_index);
   // Returns the 32-bit unsigned intrinsic id immediate for bytecode operand
   // |operand_index| in the current bytecode.
-  compiler::Node* BytecodeOperandIntrinsicId(int operand_index);
-
+  compiler::TNode<Uint32T> BytecodeOperandIntrinsicId(int operand_index);
   // Accumulator.
   compiler::TNode<Object> GetAccumulator();
   void SetAccumulator(SloppyTNode<Object> value);
@@ -136,14 +136,15 @@ class V8_EXPORT_PRIVATE InterpreterAssembler : public CodeStubAssembler {
 
   // Load constant at the index specified in operand |operand_index| from the
   // constant pool.
-  compiler::Node* LoadConstantPoolEntryAtOperandIndex(int operand_index);
+  compiler::TNode<Object> LoadConstantPoolEntryAtOperandIndex(
+      int operand_index);
   // Load and untag constant at the index specified in operand |operand_index|
   // from the constant pool.
   TNode<IntPtrT> LoadAndUntagConstantPoolEntryAtOperandIndex(int operand_index);
   // Load constant at |index| in the constant pool.
-  compiler::Node* LoadConstantPoolEntry(compiler::Node* index);
+  compiler::TNode<Object> LoadConstantPoolEntry(compiler::TNode<WordT> index);
   // Load and untag constant at |index| in the constant pool.
-  TNode<IntPtrT> LoadAndUntagConstantPoolEntry(compiler::Node* index);
+  TNode<IntPtrT> LoadAndUntagConstantPoolEntry(compiler::TNode<WordT> index);
 
   // Load the FeedbackVector for the current function. The retuned node could be
   // undefined.
@@ -362,13 +363,13 @@ class V8_EXPORT_PRIVATE InterpreterAssembler : public CodeStubAssembler {
   // Returns the word-size sign-extended register index for bytecode operand
   // |operand_index| in the current bytecode. Value is not poisoned on
   // speculation since the value loaded from the register is poisoned instead.
-  compiler::Node* BytecodeOperandReg(
+  compiler::TNode<IntPtrT> BytecodeOperandReg(
       int operand_index,
       LoadSensitivity needs_poisoning = LoadSensitivity::kCritical);
 
   // Returns the word zero-extended index immediate for bytecode operand
   // |operand_index| in the current bytecode for use when loading a .
-  compiler::Node* BytecodeOperandConstantPoolIdx(
+  compiler::TNode<UintPtrT> BytecodeOperandConstantPoolIdx(
       int operand_index,
       LoadSensitivity needs_poisoning = LoadSensitivity::kCritical);
 

test/unittests/interpreter/interpreter-assembler-unittest.cc

@@ -444,7 +444,7 @@ TARGET_TEST_F(InterpreterAssemblerTest, LoadConstantPoolEntry) {
     InterpreterAssemblerForTest m(&state, bytecode);
     {
       TNode<IntPtrT> index = m.IntPtrConstant(2);
-      Node* load_constant = m.LoadConstantPoolEntry(index);
+      TNode<Object> load_constant = m.LoadConstantPoolEntry(index);
 #ifdef V8_COMPRESS_POINTERS
       Matcher<Node*> constant_pool_matcher =
           IsChangeCompressedToTagged(m.IsLoadFromObject(
@@ -474,7 +474,8 @@ TARGET_TEST_F(InterpreterAssemblerTest, LoadConstantPoolEntry) {
     }
     {
       Node* index = m.Parameter(2);
-      Node* load_constant = m.LoadConstantPoolEntry(index);
+      TNode<Object> load_constant =
+          m.LoadConstantPoolEntry(m.ReinterpretCast<IntPtrT>(index));
 #if V8_COMPRESS_POINTERS
       Matcher<Node*> constant_pool_matcher =
           IsChangeCompressedToTagged(m.IsLoadFromObject(