encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-20 18:29:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move sem::Constant to constant::Constant

Browse Source 
This CL splits the base constant code out of sem into their own folder.
This will allow re-using the constants in the IR. The concrete
implementations from the resolver will move in followup CLs.

Bug: tint:1718
Change-Id: Ic370db76dce34e3e6eca56a9c2a8df607492b4a6
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/113802
Reviewed-by: Ben Clayton <bclayton@google.com>
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
This commit is contained in:
dan sinclair
2022-12-13 14:17:50 +00:00
committed by Dawn LUCI CQ
parent 28483ef6dc
commit 10182c46d9
38 changed files with 457 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

456
src/tint/resolver/const_eval.cc
View File

File diff suppressed because it is too large Load Diff

232
src/tint/resolver/const_eval.h
View File

@@ -30,8 +30,10 @@ class Source;
namespace tint::ast {
class LiteralExpression;
} // namespace tint::ast
namespace tint::sem {
namespace tint::constant {
class Constant;
} // namespace tint::constant
namespace tint::sem {
class Expression;
} // namespace tint::sem
namespace tint::type {
@@ -48,18 +50,20 @@ class ConstEval {
public:
/// The result type of a method that may raise a diagnostic error and the caller should abort
/// resolving. Can be one of three distinct values:
/// * A non-null sem::Constant pointer. Returned when a expression resolves to a creation time
/// * A non-null constant::Constant pointer. Returned when a expression resolves to a creation
/// time
/// value.
/// * A null sem::Constant pointer. Returned when a expression cannot resolve to a creation time
/// * A null constant::Constant pointer. Returned when a expression cannot resolve to a creation
/// time
/// value, but is otherwise legal.
/// * `utils::Failure`. Returned when there was a resolver error. In this situation the method
/// will have already reported a diagnostic error message, and the caller should abort
/// resolving.
using Result = utils::Result<const sem::Constant*>;
using Result = utils::Result<const constant::Constant*>;
/// Typedef for a constant evaluation function
using Function = Result (ConstEval::*)(const type::Type* result_ty,
utils::VectorRef<const sem::Constant*>,
utils::VectorRef<const constant::Constant*>,
const Source&);
/// Constructor
@@ -109,7 +113,7 @@ class ConstEval {
/// @param value the value being converted
/// @param source the source location
/// @return the converted value, or null if the value cannot be calculated
Result Convert(const type::Type* ty, const sem::Constant* value, const Source& source);
Result Convert(const type::Type* ty, const constant::Constant* value, const Source& source);
////////////////////////////////////////////////////////////////////////////////////////////////
// Constant value evaluation methods, to be indirectly called via the intrinsic table
@@ -121,7 +125,7 @@ class ConstEval {
/// @param source the source location
/// @return the converted value, or null if the value cannot be calculated
Result Conv(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Zero value type initializer
@@ -130,7 +134,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result Zero(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Identity value type initializer
@@ -139,7 +143,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result Identity(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Vector splat initializer
@@ -148,7 +152,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result VecSplat(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Vector initializer using scalars
@@ -157,7 +161,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result VecInitS(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Vector initializer using a mix of scalars and smaller vectors
@@ -166,7 +170,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result VecInitM(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Matrix initializer using scalar values
@@ -175,7 +179,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result MatInitS(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Matrix initializer using column vectors
@@ -184,7 +188,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result MatInitV(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
////////////////////////////////////////////////////////////////////////////
@@ -197,7 +201,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpComplement(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Unary minus operator '-'
@@ -206,7 +210,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpUnaryMinus(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Unary not operator '!'
@@ -215,7 +219,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpNot(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
////////////////////////////////////////////////////////////////////////////
@@ -228,7 +232,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpPlus(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Minus operator '-'
@@ -237,7 +241,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMinus(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Multiply operator '*' for the same type on the LHS and RHS
@@ -246,7 +250,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiply(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Multiply operator '*' for matCxR<T> * vecC<T>
@@ -255,7 +259,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiplyMatVec(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Multiply operator '*' for vecR<T> * matCxR<T>
@@ -264,7 +268,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiplyVecMat(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Multiply operator '*' for matKxR<T> * matCxK<T>
@@ -273,7 +277,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiplyMatMat(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Divide operator '/'
@@ -282,7 +286,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpDivide(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Modulo operator '%'
@@ -291,7 +295,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpModulo(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Equality operator '=='
@@ -300,7 +304,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpEqual(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Inequality operator '!='
@@ -309,7 +313,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpNotEqual(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Less than operator '<'
@@ -318,7 +322,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLessThan(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Greater than operator '>'
@@ -327,7 +331,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpGreaterThan(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Less than or equal operator '<='
@@ -336,7 +340,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLessThanEqual(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Greater than or equal operator '>='
@@ -345,7 +349,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpGreaterThanEqual(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Logical and operator '&&'
@@ -354,7 +358,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLogicalAnd(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Logical or operator '||'
@@ -363,7 +367,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLogicalOr(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Bitwise and operator '&'
@@ -372,7 +376,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpAnd(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Bitwise or operator '|'
@@ -381,7 +385,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpOr(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Bitwise xor operator '^'
@@ -390,7 +394,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpXor(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Bitwise shift left operator '<<'
@@ -399,7 +403,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpShiftLeft(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// Bitwise shift right operator '<<'
@@ -408,7 +412,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpShiftRight(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
////////////////////////////////////////////////////////////////////////////
@@ -421,7 +425,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result abs(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// acos builtin
@@ -430,7 +434,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result acos(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// acosh builtin
@@ -439,7 +443,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result acosh(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// all builtin
@@ -448,7 +452,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result all(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// any builtin
@@ -457,7 +461,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result any(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// asin builtin
@@ -466,7 +470,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result asin(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// asinh builtin
@@ -475,7 +479,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result asinh(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// atan builtin
@@ -484,7 +488,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result atan(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// atanh builtin
@@ -493,7 +497,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result atanh(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// atan2 builtin
@@ -502,7 +506,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result atan2(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// ceil builtin
@@ -511,7 +515,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result ceil(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// clamp builtin
@@ -520,7 +524,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result clamp(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// cos builtin
@@ -529,7 +533,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result cos(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// cosh builtin
@@ -538,7 +542,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result cosh(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// countLeadingZeros builtin
@@ -547,7 +551,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result countLeadingZeros(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// countOneBits builtin
@@ -556,7 +560,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result countOneBits(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// countTrailingZeros builtin
@@ -565,7 +569,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result countTrailingZeros(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// cross builtin
@@ -574,7 +578,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result cross(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// degrees builtin
@@ -583,7 +587,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result degrees(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// determinant builtin
@@ -592,7 +596,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result determinant(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// distance builtin
@@ -601,7 +605,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result distance(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// dot builtin
@@ -610,7 +614,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result dot(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// exp builtin
@@ -619,7 +623,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result exp(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// exp2 builtin
@@ -628,7 +632,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result exp2(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// extractBits builtin
@@ -637,7 +641,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result extractBits(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// faceForward builtin
@@ -646,7 +650,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result faceForward(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// firstLeadingBit builtin
@@ -655,7 +659,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result firstLeadingBit(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// firstTrailingBit builtin
@@ -664,7 +668,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result firstTrailingBit(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// floor builtin
@@ -673,7 +677,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result floor(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// fma builtin
@@ -682,7 +686,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result fma(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// frexp builtin
@@ -691,7 +695,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result frexp(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// insertBits builtin
@@ -700,7 +704,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result insertBits(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// inverseSqrt builtin
@@ -709,7 +713,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result inverseSqrt(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// length builtin
@@ -718,7 +722,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result length(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// log builtin
@@ -727,7 +731,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result log(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// log2 builtin
@@ -736,7 +740,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result log2(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// max builtin
@@ -745,7 +749,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result max(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// min builtin
@@ -754,7 +758,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result min(const type::Type* ty, // NOLINT(build/include_what_you_use) -- confused by min
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// mix builtin
@@ -763,7 +767,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result mix(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// modf builtin
@@ -772,7 +776,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result modf(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// normalize builtin
@@ -781,7 +785,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result normalize(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// pack2x16float builtin
@@ -790,7 +794,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack2x16float(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// pack2x16snorm builtin
@@ -799,7 +803,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack2x16snorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// pack2x16unorm builtin
@@ -808,7 +812,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack2x16unorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// pack4x8snorm builtin
@@ -817,7 +821,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack4x8snorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// pack4x8unorm builtin
@@ -826,7 +830,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack4x8unorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// radians builtin
@@ -835,7 +839,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result radians(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// reflect builtin
@@ -844,7 +848,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result reflect(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// refract builtin
@@ -853,7 +857,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result refract(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// reverseBits builtin
@@ -862,7 +866,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result reverseBits(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// round builtin
@@ -871,7 +875,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result round(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// saturate builtin
@@ -880,7 +884,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result saturate(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// select builtin with single bool third arg
@@ -889,7 +893,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result select_bool(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// select builtin with vector of bool third arg
@@ -898,7 +902,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result select_boolvec(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// sign builtin
@@ -907,7 +911,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sign(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// sin builtin
@@ -916,7 +920,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sin(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// sinh builtin
@@ -925,7 +929,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sinh(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// smoothstep builtin
@@ -934,7 +938,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result smoothstep(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// step builtin
@@ -943,7 +947,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result step(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// sqrt builtin
@@ -952,7 +956,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sqrt(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// tan builtin
@@ -961,7 +965,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result tan(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// tanh builtin
@@ -970,7 +974,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result tanh(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// transpose builtin
@@ -979,7 +983,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result transpose(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// trunc builtin
@@ -988,7 +992,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result trunc(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// unpack2x16float builtin
@@ -997,7 +1001,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack2x16float(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// unpack2x16snorm builtin
@@ -1006,7 +1010,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack2x16snorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// unpack2x16unorm builtin
@@ -1015,7 +1019,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack2x16unorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// unpack4x8snorm builtin
@@ -1024,7 +1028,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack4x8snorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// unpack4x8unorm builtin
@@ -1033,7 +1037,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack4x8unorm(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
/// quantizeToF16 builtin
@@ -1042,7 +1046,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result quantizeToF16(const type::Type* ty,
utils::VectorRef<const sem::Constant*> args,
utils::VectorRef<const constant::Constant*> args,
const Source& source);
private:
@@ -1339,14 +1343,14 @@ class ConstEval {
/// @param v1 the first vector
/// @param v2 the second vector
/// @returns the dot product
Result Dot(const Source& source, const sem::Constant* v1, const sem::Constant* v2);
Result Dot(const Source& source, const constant::Constant* v1, const constant::Constant* v2);
/// Returns the length of c0
/// @param source the source location
/// @param ty the return type
/// @param c0 the constant to calculate the length of
/// @returns the length of c0
Result Length(const Source& source, const type::Type* ty, const sem::Constant* c0);
Result Length(const Source& source, const type::Type* ty, const constant::Constant* c0);
/// Returns the product of v1 and v2
/// @param source the source location
@@ -1356,8 +1360,8 @@ class ConstEval {
/// @returns the product of v1 and v2
Result Mul(const Source& source,
const type::Type* ty,
const sem::Constant* v1,
const sem::Constant* v2);
const constant::Constant* v1,
const constant::Constant* v2);
/// Returns the difference between v2 and v1
/// @param source the source location
@@ -1367,8 +1371,8 @@ class ConstEval {
/// @returns the difference between v2 and v1
Result Sub(const Source& source,
const type::Type* ty,
const sem::Constant* v1,
const sem::Constant* v2);
const constant::Constant* v1,
const constant::Constant* v2);
ProgramBuilder& builder;
};

15
src/tint/resolver/const_eval_binary_op_test.cc
View File

@@ -99,7 +99,7 @@ TEST_P(ResolverConstEvalBinaryOpTest, Test) {
auto& expected = expected_case.value;
auto* sem = Sem().Get(expr);
const sem::Constant* value = sem->ConstantValue();
const constant::Constant* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());
@@ -892,19 +892,20 @@ TEST_F(ResolverConstEvalTest, NotAndOrOfVecs) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
auto* sem = Sem().Get(expr);
const sem::Constant* value = sem->ConstantValue();
const constant::Constant* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());
auto* expected_sem = Sem().Get(expected_expr);
const sem::Constant* expected_value = expected_sem->ConstantValue();
const constant::Constant* expected_value = expected_sem->ConstantValue();
ASSERT_NE(expected_value, nullptr);
EXPECT_TYPE(expected_value->Type(), expected_sem->Type());
ForEachElemPair(value, expected_value, [&](const sem::Constant* a, const sem::Constant* b) {
EXPECT_EQ(a->As<bool>(), b->As<bool>());
return HasFailure() ? Action::kStop : Action::kContinue;
});
ForEachElemPair(value, expected_value,
[&](const constant::Constant* a, const constant::Constant* b) {
EXPECT_EQ(a->As<bool>(), b->As<bool>());
return HasFailure() ? Action::kStop : Action::kContinue;
});
}
template <typename T>

2
src/tint/resolver/const_eval_builtin_test.cc
View File

@@ -162,7 +162,7 @@ TEST_P(ResolverConstEvalBuiltinTest, Test) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
const sem::Constant* value = sem->ConstantValue();
const constant::Constant* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());

13
src/tint/resolver/const_eval_test.h
View File

@@ -36,9 +36,10 @@ inline const auto kPiOver4 = T(UnwrapNumber<T>(0.785398163397448309616));
template <typename T>
inline const auto k3PiOver4 = T(UnwrapNumber<T>(2.356194490192344928846));
/// Walks the sem::Constant @p c, accumulating all the inner-most scalar values into @p args
/// Walks the constant::Constant @p c, accumulating all the inner-most scalar values into @p args
template <size_t N>
inline void CollectScalars(const sem::Constant* c, utils::Vector<builder::Scalar, N>& scalars) {
inline void CollectScalars(const constant::Constant* c,
utils::Vector<builder::Scalar, N>& scalars) {
Switch(
c->Type(), //
[&](const type::AbstractInt*) { scalars.Push(c->As<AInt>()); },
@@ -56,8 +57,8 @@ inline void CollectScalars(const sem::Constant* c, utils::Vector<builder::Scalar
});
}
/// Walks the sem::Constant @p c, returning all the inner-most scalar values.
inline utils::Vector<builder::Scalar, 16> ScalarsFrom(const sem::Constant* c) {
/// Walks the constant::Constant @p c, returning all the inner-most scalar values.
inline utils::Vector<builder::Scalar, 16> ScalarsFrom(const constant::Constant* c) {
utils::Vector<builder::Scalar, 16> out;
CollectScalars(c, out);
return out;
@@ -88,7 +89,7 @@ struct CheckConstantFlags {
/// @param got_constant the constant value evaluated by the resolver
/// @param expected_value the expected value for the test
/// @param flags optional flags for controlling the comparisons
inline void CheckConstant(const sem::Constant* got_constant,
inline void CheckConstant(const constant::Constant* got_constant,
const builder::Value& expected_value,
CheckConstantFlags flags = {}) {
auto values_flat = ScalarsFrom(got_constant);
@@ -257,7 +258,7 @@ using builder::Vec;
// TODO(amaiorano): Move to Constant.h?
enum class Action { kStop, kContinue };
template <typename Func>
inline Action ForEachElemPair(const sem::Constant* a, const sem::Constant* b, Func&& f) {
inline Action ForEachElemPair(const constant::Constant* a, const constant::Constant* b, Func&& f) {
EXPECT_EQ(a->Type(), b->Type());
size_t i = 0;
while (true) {

2
src/tint/resolver/const_eval_unary_op_test.cc
View File

@@ -57,7 +57,7 @@ TEST_P(ResolverConstEvalUnaryOpTest, Test) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = Sem().Get(expr);
const sem::Constant* value = sem->ConstantValue();
const constant::Constant* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());

26
src/tint/resolver/resolver.cc
View File

@@ -1285,7 +1285,7 @@ sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, cons
ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "case selector"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
const sem::Constant* const_value = nullptr;
const constant::Constant* const_value = nullptr;
if (!sel->IsDefault()) {
// The sem statement was created in the switch when attempting to determine the
// common type.
@@ -1804,7 +1804,7 @@ const sem::Expression* Resolver::Materialize(const sem::Expression* expr,
return nullptr;
}
const sem::Constant* materialized_val = nullptr;
const constant::Constant* materialized_val = nullptr;
if (!skip_const_eval_.Contains(decl)) {
auto expr_val = expr->ConstantValue();
if (!expr_val) {
@@ -1856,7 +1856,9 @@ bool Resolver::ShouldMaterializeArgument(const type::Type* parameter_ty) const {
return param_el_ty && !param_el_ty->Is<type::AbstractNumeric>();
}
bool Resolver::Convert(const sem::Constant*& c, const type::Type* target_ty, const Source& source) {
bool Resolver::Convert(const constant::Constant*& c,
const type::Type* target_ty,
const Source& source) {
auto r = const_eval_.Convert(target_ty, c, source);
if (!r) {
return false;
@@ -1866,7 +1868,7 @@ bool Resolver::Convert(const sem::Constant*& c, const type::Type* target_ty, con
}
template <size_t N>
utils::Result<utils::Vector<const sem::Constant*, N>> Resolver::ConvertArguments(
utils::Result<utils::Vector<const constant::Constant*, N>> Resolver::ConvertArguments(
const utils::Vector<const sem::Expression*, N>& args,
const sem::CallTarget* target) {
auto const_args = utils::Transform(args, [](auto* arg) { return arg->ConstantValue(); });
@@ -1924,7 +1926,7 @@ sem::Expression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* exp
ty = builder_->create<type::Reference>(ty, ref->AddressSpace(), ref->Access());
}
const sem::Constant* val = nullptr;
const constant::Constant* val = nullptr;
auto stage = sem::EarliestStage(obj->Stage(), idx->Stage());
if (stage == sem::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = sem::EvaluationStage::kNotEvaluated;
@@ -1955,7 +1957,7 @@ sem::Expression* Resolver::Bitcast(const ast::BitcastExpression* expr) {
RegisterLoadIfNeeded(inner);
const sem::Constant* val = nullptr;
const constant::Constant* val = nullptr;
// TODO(crbug.com/tint/1582): short circuit 'expr' once const eval of Bitcast is implemented.
if (auto r = const_eval_.Bitcast(ty, inner)) {
val = r.Get();
@@ -2017,7 +2019,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
return nullptr;
}
const sem::Constant* value = nullptr;
const constant::Constant* value = nullptr;
auto stage = sem::EarliestStage(ctor_or_conv.target->Stage(), args_stage);
if (stage == sem::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = sem::EvaluationStage::kNotEvaluated;
@@ -2047,7 +2049,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
}
auto stage = args_stage; // The evaluation stage of the call
const sem::Constant* value = nullptr; // The constant value for the call
const constant::Constant* value = nullptr; // The constant value for the call
if (stage == sem::EvaluationStage::kConstant) {
if (auto r = const_eval_.ArrayOrStructInit(ty, args)) {
value = r.Get();
@@ -2341,7 +2343,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr,
// If the builtin is @const, and all arguments have constant values, evaluate the builtin
// now.
const sem::Constant* value = nullptr;
const constant::Constant* value = nullptr;
auto stage = sem::EarliestStage(arg_stage, builtin.sem->Stage());
if (stage == sem::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = sem::EvaluationStage::kNotEvaluated;
@@ -2559,7 +2561,7 @@ sem::Expression* Resolver::Literal(const ast::LiteralExpression* literal) {
return nullptr;
}
const sem::Constant* val = nullptr;
const constant::Constant* val = nullptr;
if (auto r = const_eval_.Literal(ty, literal)) {
val = r.Get();
} else {
@@ -2827,7 +2829,7 @@ sem::Expression* Resolver::Binary(const ast::BinaryExpression* expr) {
RegisterLoadIfNeeded(lhs);
RegisterLoadIfNeeded(rhs);
const sem::Constant* value = nullptr;
const constant::Constant* value = nullptr;
if (stage == sem::EvaluationStage::kConstant) {
if (op.const_eval_fn) {
if (skip_const_eval_.Contains(expr)) {
@@ -2872,7 +2874,7 @@ sem::Expression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) {
const type::Type* ty = nullptr;
const sem::Variable* root_ident = nullptr;
const sem::Constant* value = nullptr;
const constant::Constant* value = nullptr;
auto stage = sem::EvaluationStage::kRuntime;
switch (unary->op) {

6
src/tint/resolver/resolver.h
View File

@@ -23,6 +23,7 @@
#include <utility>
#include <vector>
#include "src/tint/constant/constant.h"
#include "src/tint/program_builder.h"
#include "src/tint/resolver/const_eval.h"
#include "src/tint/resolver/dependency_graph.h"
@@ -32,7 +33,6 @@
#include "src/tint/scope_stack.h"
#include "src/tint/sem/binding_point.h"
#include "src/tint/sem/block_statement.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/struct.h"
#include "src/tint/utils/bitset.h"
@@ -197,13 +197,13 @@ class Resolver {
/// Converts `c` to `target_ty`
/// @returns true on success, false on failure.
bool Convert(const sem::Constant*& c, const type::Type* target_ty, const Source& source);
bool Convert(const constant::Constant*& c, const type::Type* target_ty, const Source& source);
/// Transforms `args` to a vector of constants, and converts each constant to the call target's
/// parameter type.
/// @returns the vector of constants, `utils::Failure` on failure.
template <size_t N>
utils::Result<utils::Vector<const sem::Constant*, N>> ConvertArguments(
utils::Result<utils::Vector<const constant::Constant*, N>> ConvertArguments(
const utils::Vector<const sem::Expression*, N>& args,
const sem::CallTarget* target);