tint/resolver: Optimize constant evaluation methods
Materialize() was re-evaluating the constant values for the incoming
semantic expression, despite this already being evaluated. Just use the
sem::Expression::ConstantValue().
resolver.cc already has all the semantic pointers, so pass them in
instead of pointlessly hitting the ast -> sem map.
Change-Id: If2bc7cd10f79079fb811e9d83c5150dd3c0c244c
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/95764
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: Dan Sinclair <dsinclair@chromium.org>
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index 4f47096..42cd0bb 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -1306,11 +1306,11 @@
if (!validator_.Materialize(target_ty, src_ty, decl->source)) {
return nullptr;
}
- auto expr_val = EvaluateConstantValue(decl, expr->Type());
+ auto expr_val = expr->ConstantValue();
if (!expr_val) {
TINT_ICE(Resolver, builder_->Diagnostics())
- << decl->source << "EvaluateConstantValue(" << decl->TypeInfo().name
- << ") returned invalid value";
+ << decl->source << "Materialize(" << decl->TypeInfo().name
+ << ") called on expression with no constant value";
return nullptr;
}
auto materialized_val = ConvertValue(expr_val, target_ty, decl->source);
@@ -1422,7 +1422,7 @@
ty = builder_->create<sem::Reference>(ty, ref->StorageClass(), ref->Access());
}
- auto val = EvaluateConstantValue(expr, ty);
+ auto val = EvaluateIndexValue(obj, idx);
bool has_side_effects = idx->HasSideEffects() || obj->HasSideEffects();
auto* sem = builder_->create<sem::IndexAccessorExpression>(
expr, ty, obj, idx, current_statement_, std::move(val), has_side_effects,
@@ -1441,7 +1441,7 @@
return nullptr;
}
- auto val = EvaluateConstantValue(expr, ty);
+ auto val = EvaluateBitcastValue(inner, ty);
auto* sem = builder_->create<sem::Expression>(expr, ty, current_statement_, std::move(val),
inner->HasSideEffects());
@@ -1489,9 +1489,9 @@
if (!MaterializeArguments(args, call_target)) {
return nullptr;
}
- auto val = EvaluateConstantValue(expr, call_target->ReturnType());
+ auto val = EvaluateCtorOrConvValue(args, call_target->ReturnType());
return builder_->create<sem::Call>(expr, call_target, std::move(args), current_statement_,
- std::move(val), has_side_effects);
+ val, has_side_effects);
};
// ct_ctor_or_conv is a helper for building either a sem::TypeConstructor or sem::TypeConversion
@@ -1528,10 +1528,9 @@
if (!MaterializeArguments(args, call_target)) {
return nullptr;
}
- auto val = EvaluateConstantValue(expr, call_target->ReturnType());
+ auto val = EvaluateCtorOrConvValue(args, arr);
return builder_->create<sem::Call>(expr, call_target, std::move(args),
- current_statement_, std::move(val),
- has_side_effects);
+ current_statement_, val, has_side_effects);
},
[&](const sem::Struct* str) -> sem::Call* {
auto* call_target = utils::GetOrCreate(
@@ -1551,7 +1550,7 @@
if (!MaterializeArguments(args, call_target)) {
return nullptr;
}
- auto val = EvaluateConstantValue(expr, call_target->ReturnType());
+ auto val = EvaluateCtorOrConvValue(args, str);
return builder_->create<sem::Call>(expr, call_target, std::move(args),
current_statement_, std::move(val),
has_side_effects);
@@ -1857,7 +1856,7 @@
return nullptr;
}
- auto val = EvaluateConstantValue(literal, ty);
+ auto val = EvaluateLiteralValue(literal, ty);
return builder_->create<sem::Expression>(literal, ty, current_statement_, std::move(val),
/* has_side_effects */ false);
}
@@ -2077,10 +2076,10 @@
}
}
- auto val = EvaluateConstantValue(expr, op.result);
+ auto* val = EvaluateBinaryValue(lhs, rhs, op);
bool has_side_effects = lhs->HasSideEffects() || rhs->HasSideEffects();
- auto* sem = builder_->create<sem::Expression>(expr, op.result, current_statement_,
- std::move(val), has_side_effects);
+ auto* sem = builder_->create<sem::Expression>(expr, op.result, current_statement_, val,
+ has_side_effects);
sem->Behaviors() = lhs->Behaviors() + rhs->Behaviors();
return sem;
@@ -2095,6 +2094,7 @@
const sem::Type* ty = nullptr;
const sem::Variable* source_var = nullptr;
+ const sem::Constant* val = nullptr;
switch (unary->op) {
case ast::UnaryOp::kAddressOf:
@@ -2147,12 +2147,12 @@
}
}
ty = op.result;
+ val = EvaluateUnaryValue(expr, op);
break;
}
}
- auto val = EvaluateConstantValue(unary, ty);
- auto* sem = builder_->create<sem::Expression>(unary, ty, current_statement_, std::move(val),
+ auto* sem = builder_->create<sem::Expression>(unary, ty, current_statement_, val,
expr->HasSideEffects(), source_var);
sem->Behaviors() = expr->Behaviors();
return sem;
