Import Tint changes from Dawn
Changes:
- f7055d7b2bf881a73601273d78470c0cb7fefba1 [tint][ir] Rename Unary::Kind to UnaryOp by Ben Clayton <bclayton@google.com>
GitOrigin-RevId: f7055d7b2bf881a73601273d78470c0cb7fefba1
Change-Id: I109ae9b58d4a9a879fb161bdf1a9a82783c2765c
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/157400
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
diff --git a/src/tint/lang/core/ir/builder.h b/src/tint/lang/core/ir/builder.h
index c122ca7..6020902 100644
--- a/src/tint/lang/core/ir/builder.h
+++ b/src/tint/lang/core/ir/builder.h
@@ -606,15 +606,15 @@
return Binary(BinaryOp::kModulo, type, std::forward<LHS>(lhs), std::forward<RHS>(rhs));
}
- /// Creates an op for `kind val`
- /// @param kind the kind of operation
+ /// Creates an op for `op val`
+ /// @param op the unary operator
/// @param type the result type of the binary expression
/// @param val the value of the operation
/// @returns the operation
template <typename VAL>
- ir::Unary* Unary(enum Unary::Kind kind, const core::type::Type* type, VAL&& val) {
+ ir::Unary* Unary(UnaryOp op, const core::type::Type* type, VAL&& val) {
auto* value = Value(std::forward<VAL>(val));
- return Append(ir.instructions.Create<ir::Unary>(InstructionResult(type), kind, value));
+ return Append(ir.instructions.Create<ir::Unary>(InstructionResult(type), op, value));
}
/// Creates a Complement operation
@@ -623,7 +623,7 @@
/// @returns the operation
template <typename VAL>
ir::Unary* Complement(const core::type::Type* type, VAL&& val) {
- return Unary(ir::Unary::Kind::kComplement, type, std::forward<VAL>(val));
+ return Unary(ir::UnaryOp::kComplement, type, std::forward<VAL>(val));
}
/// Creates a Negation operation
@@ -632,7 +632,7 @@
/// @returns the operation
template <typename VAL>
ir::Unary* Negation(const core::type::Type* type, VAL&& val) {
- return Unary(ir::Unary::Kind::kNegation, type, std::forward<VAL>(val));
+ return Unary(ir::UnaryOp::kNegation, type, std::forward<VAL>(val));
}
/// Creates a Not operation
diff --git a/src/tint/lang/core/ir/disassembler.cc b/src/tint/lang/core/ir/disassembler.cc
index 60166e6..09d5c75 100644
--- a/src/tint/lang/core/ir/disassembler.cc
+++ b/src/tint/lang/core/ir/disassembler.cc
@@ -864,11 +864,11 @@
SourceMarker sm(this);
EmitValueWithType(u);
out_ << " = ";
- switch (u->Kind()) {
- case Unary::Kind::kComplement:
+ switch (u->Op()) {
+ case UnaryOp::kComplement:
out_ << "complement";
break;
- case Unary::Kind::kNegation:
+ case UnaryOp::kNegation:
out_ << "negation";
break;
}
diff --git a/src/tint/lang/core/ir/unary.cc b/src/tint/lang/core/ir/unary.cc
index bbf58e1..2b81d7b 100644
--- a/src/tint/lang/core/ir/unary.cc
+++ b/src/tint/lang/core/ir/unary.cc
@@ -34,7 +34,7 @@
namespace tint::core::ir {
-Unary::Unary(InstructionResult* result, enum Kind k, Value* val) : kind_(k) {
+Unary::Unary(InstructionResult* result, UnaryOp op, Value* val) : op_(op) {
AddOperand(Unary::kValueOperandOffset, val);
AddResult(result);
}
@@ -44,7 +44,7 @@
Unary* Unary::Clone(CloneContext& ctx) {
auto* new_result = ctx.Clone(Result());
auto* val = ctx.Remap(Val());
- return ctx.ir.instructions.Create<Unary>(new_result, kind_, val);
+ return ctx.ir.instructions.Create<Unary>(new_result, op_, val);
}
} // namespace tint::core::ir
diff --git a/src/tint/lang/core/ir/unary.h b/src/tint/lang/core/ir/unary.h
index 8ef3f5c..c25f5fc 100644
--- a/src/tint/lang/core/ir/unary.h
+++ b/src/tint/lang/core/ir/unary.h
@@ -35,23 +35,23 @@
namespace tint::core::ir {
+/// A unary operator.
+enum class UnaryOp {
+ kComplement,
+ kNegation,
+};
+
/// A unary instruction in the IR.
class Unary final : public Castable<Unary, OperandInstruction<1, 1>> {
public:
/// The offset in Operands() for the value
static constexpr size_t kValueOperandOffset = 0;
- /// The kind of instruction.
- enum class Kind {
- kComplement,
- kNegation,
- };
-
/// Constructor
/// @param result the result value
- /// @param kind the kind of unary instruction
+ /// @param op the unary operator
/// @param val the input value for the instruction
- Unary(InstructionResult* result, enum Kind kind, Value* val);
+ Unary(InstructionResult* result, UnaryOp op, Value* val);
~Unary() override;
/// @copydoc Instruction::Clone()
@@ -60,14 +60,14 @@
/// @returns the value for the instruction
Value* Val() { return operands_[kValueOperandOffset]; }
- /// @returns the kind of unary instruction
- enum Kind Kind() { return kind_; }
+ /// @returns the unary operator
+ UnaryOp Op() { return op_; }
/// @returns the friendly name for the instruction
std::string FriendlyName() override { return "unary"; }
private:
- enum Kind kind_;
+ UnaryOp op_;
};
} // namespace tint::core::ir
diff --git a/src/tint/lang/core/ir/unary_test.cc b/src/tint/lang/core/ir/unary_test.cc
index 770866d..bbdccdd 100644
--- a/src/tint/lang/core/ir/unary_test.cc
+++ b/src/tint/lang/core/ir/unary_test.cc
@@ -44,7 +44,7 @@
auto* inst = b.Complement(mod.Types().i32(), 4_i);
ASSERT_TRUE(inst->Is<Unary>());
- EXPECT_EQ(inst->Kind(), Unary::Kind::kComplement);
+ EXPECT_EQ(inst->Op(), UnaryOp::kComplement);
ASSERT_TRUE(inst->Val()->Is<Constant>());
auto lhs = inst->Val()->As<Constant>()->Value();
@@ -56,7 +56,7 @@
auto* inst = b.Negation(mod.Types().i32(), 4_i);
ASSERT_TRUE(inst->Is<Unary>());
- EXPECT_EQ(inst->Kind(), Unary::Kind::kNegation);
+ EXPECT_EQ(inst->Op(), UnaryOp::kNegation);
ASSERT_TRUE(inst->Val()->Is<Constant>());
auto lhs = inst->Val()->As<Constant>()->Value();
@@ -67,7 +67,7 @@
TEST_F(IR_UnaryTest, Usage) {
auto* inst = b.Negation(mod.Types().i32(), 4_i);
- EXPECT_EQ(inst->Kind(), Unary::Kind::kNegation);
+ EXPECT_EQ(inst->Op(), UnaryOp::kNegation);
ASSERT_NE(inst->Val(), nullptr);
EXPECT_THAT(inst->Val()->Usages(), testing::UnorderedElementsAre(Usage{inst, 0u}));
@@ -99,7 +99,7 @@
EXPECT_NE(nullptr, new_inst->Result());
EXPECT_NE(inst->Result(), new_inst->Result());
- EXPECT_EQ(Unary::Kind::kComplement, new_inst->Kind());
+ EXPECT_EQ(UnaryOp::kComplement, new_inst->Op());
auto new_val = new_inst->Val()->As<Constant>()->Value();
ASSERT_TRUE(new_val->Is<core::constant::Scalar<i32>>());
diff --git a/src/tint/lang/core/ir/validator_test.cc b/src/tint/lang/core/ir/validator_test.cc
index 2209af9..d9f6abf 100644
--- a/src/tint/lang/core/ir/validator_test.cc
+++ b/src/tint/lang/core/ir/validator_test.cc
@@ -1332,7 +1332,7 @@
TEST_F(IR_ValidatorTest, Unary_Result_Nullptr) {
auto* bin =
- mod.instructions.Create<ir::Unary>(nullptr, ir::Unary::Kind::kNegation, b.Constant(2_i));
+ mod.instructions.Create<ir::Unary>(nullptr, ir::UnaryOp::kNegation, b.Constant(2_i));
auto* f = b.Function("my_func", ty.void_());
diff --git a/src/tint/lang/spirv/writer/printer/printer.cc b/src/tint/lang/spirv/writer/printer/printer.cc
index 69fd6a8..0bd3b7a 100644
--- a/src/tint/lang/spirv/writer/printer/printer.cc
+++ b/src/tint/lang/spirv/writer/printer/printer.cc
@@ -1761,11 +1761,11 @@
auto id = Value(unary);
auto* ty = unary->Result()->Type();
spv::Op op = spv::Op::Max;
- switch (unary->Kind()) {
- case core::ir::Unary::Kind::kComplement:
+ switch (unary->Op()) {
+ case core::ir::UnaryOp::kComplement:
op = spv::Op::OpNot;
break;
- case core::ir::Unary::Kind::kNegation:
+ case core::ir::UnaryOp::kNegation:
if (ty->is_float_scalar_or_vector()) {
op = spv::Op::OpFNegate;
} else if (ty->is_signed_integer_scalar_or_vector()) {
diff --git a/src/tint/lang/spirv/writer/unary_test.cc b/src/tint/lang/spirv/writer/unary_test.cc
index f88b25d..72fff71 100644
--- a/src/tint/lang/spirv/writer/unary_test.cc
+++ b/src/tint/lang/spirv/writer/unary_test.cc
@@ -39,7 +39,7 @@
/// The element type to test.
TestElementType type;
/// The unary operation.
- enum core::ir::Unary::Kind kind;
+ enum core::ir::UnaryOp op;
/// The expected SPIR-V instruction.
std::string spirv_inst;
/// The expected SPIR-V result type name.
@@ -54,7 +54,7 @@
auto* func = b.Function("foo", ty.void_());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Unary(params.kind, MakeScalarType(params.type), arg);
+ auto* result = b.Unary(params.op, MakeScalarType(params.type), arg);
b.Return(func);
mod.SetName(result, "result");
});
@@ -69,7 +69,7 @@
auto* func = b.Function("foo", ty.void_());
func->SetParams({arg});
b.Append(func->Block(), [&] {
- auto* result = b.Unary(params.kind, MakeVectorType(params.type), arg);
+ auto* result = b.Unary(params.op, MakeVectorType(params.type), arg);
b.Return(func);
mod.SetName(result, "result");
});
@@ -80,11 +80,11 @@
INSTANTIATE_TEST_SUITE_P(
SpirvWriterTest_Unary,
Arithmetic,
- testing::Values(UnaryTestCase{kI32, core::ir::Unary::Kind::kComplement, "OpNot", "int"},
- UnaryTestCase{kU32, core::ir::Unary::Kind::kComplement, "OpNot", "uint"},
- UnaryTestCase{kI32, core::ir::Unary::Kind::kNegation, "OpSNegate", "int"},
- UnaryTestCase{kF32, core::ir::Unary::Kind::kNegation, "OpFNegate", "float"},
- UnaryTestCase{kF16, core::ir::Unary::Kind::kNegation, "OpFNegate", "half"}));
+ testing::Values(UnaryTestCase{kI32, core::ir::UnaryOp::kComplement, "OpNot", "int"},
+ UnaryTestCase{kU32, core::ir::UnaryOp::kComplement, "OpNot", "uint"},
+ UnaryTestCase{kI32, core::ir::UnaryOp::kNegation, "OpSNegate", "int"},
+ UnaryTestCase{kF32, core::ir::UnaryOp::kNegation, "OpFNegate", "float"},
+ UnaryTestCase{kF16, core::ir::UnaryOp::kNegation, "OpFNegate", "half"}));
} // namespace
} // namespace tint::spirv::writer
diff --git a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
index df929b2..5dc9a62 100644
--- a/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
+++ b/src/tint/lang/wgsl/writer/ir_to_program/ir_to_program.cc
@@ -653,11 +653,11 @@
void Unary(core::ir::Unary* u) {
const ast::Expression* expr = nullptr;
- switch (u->Kind()) {
- case core::ir::Unary::Kind::kComplement:
+ switch (u->Op()) {
+ case core::ir::UnaryOp::kComplement:
expr = b.Complement(Expr(u->Val()));
break;
- case core::ir::Unary::Kind::kNegation:
+ case core::ir::UnaryOp::kNegation:
expr = b.Negation(Expr(u->Val()));
break;
}
