encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Move sem::Constant to constant::Constant 

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/tint/BUILD.gn
View File

@ -366,6 +366,7 @@ libtint_source_set("libtint_core_all_src") {
"castable.h",
"clone_context.cc",
"clone_context.h",
"constant/constant.h",
"debug.cc",
"debug.h",
"demangler.cc",
@ -421,7 +422,6 @@ libtint_source_set("libtint_core_all_src") {
"sem/builtin_type.h",
"sem/call.h",
"sem/call_target.h",
"sem/constant.h",
"sem/evaluation_stage.h",
"sem/expression.h",
"sem/for_loop_statement.h",
@ -649,8 +649,6 @@ libtint_source_set("libtint_sem_src") {
"sem/call.h",
"sem/call_target.cc",
"sem/call_target.h",
"sem/constant.cc",
"sem/constant.h",
"sem/evaluation_stage.h",
"sem/expression.cc",
"sem/expression.h",
@ -758,8 +756,17 @@ libtint_source_set("libtint_type_src") {
public_deps = [ ":libtint_core_all_src" ]
}
libtint_source_set("libtint_constant_src") {
sources = [
"constant/constant.cc",
"constant/constant.h",
]
public_deps = [ ":libtint_core_all_src" ]
}
libtint_source_set("libtint_core_src") {
public_deps = [
":libtint_constant_src",
":libtint_core_all_src",
":libtint_sem_src",
":libtint_type_src",

4
src/tint/CMakeLists.txt
View File

@ -254,6 +254,8 @@ list(APPEND TINT_LIB_SRCS
castable.h
clone_context.cc
clone_context.h
constant/constant.cc
constant/constant.h
demangler.cc
demangler.h
inspector/entry_point.cc
@ -306,8 +308,6 @@ list(APPEND TINT_LIB_SRCS
sem/call_target.h
sem/call.cc
sem/call.h
sem/constant.cc
sem/constant.h
sem/evaluation_stage.h
sem/expression.cc
sem/expression.h

6
src/tint/sem/constant.cc → src/tint/constant/constant.cc
View File

@ -12,12 +12,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#include "src/tint/sem/constant.h"
#include "src/tint/constant/constant.h"
namespace tint::sem {
namespace tint::constant {
Constant::Constant() = default;
Constant::~Constant() = default;
} // namespace tint::sem
} // namespace tint::constant

12
src/tint/sem/constant.h → src/tint/constant/constant.h
View File

@ -1,4 +1,4 @@
// Copyright 2021 The Tint Authors.
// Copyright 2022 The Tint Authors.
//
// Licensed under the Apache License, Version 2.0(the "License");
// you may not use this file except in compliance with the License.
@ -12,15 +12,15 @@
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef SRC_TINT_SEM_CONSTANT_H_
#define SRC_TINT_SEM_CONSTANT_H_
#ifndef SRC_TINT_CONSTANT_CONSTANT_H_
#define SRC_TINT_CONSTANT_CONSTANT_H_
#include <variant>
#include "src/tint/number.h"
#include "src/tint/type/type.h"
namespace tint::sem {
namespace tint::constant {
/// Constant is the interface to a compile-time evaluated expression value.
class Constant {
@ -73,6 +73,6 @@ class Constant {
}
};
} // namespace tint::sem
} // namespace tint::constant
#endif // SRC_TINT_SEM_CONSTANT_H_
#endif // SRC_TINT_CONSTANT_CONSTANT_H_

6
src/tint/program.h
View File

@ -19,8 +19,8 @@
#include <unordered_set>
#include "src/tint/ast/function.h"
#include "src/tint/constant/constant.h"
#include "src/tint/program_id.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/info.h"
#include "src/tint/symbol_table.h"
#include "src/tint/type/manager.h"
@ -44,8 +44,8 @@ class Program {
/// SemNodeAllocator is an alias to BlockAllocator<sem::Node>
using SemNodeAllocator = utils::BlockAllocator<sem::Node>;
/// ConstantAllocator is an alias to BlockAllocator<sem::Constant>
using ConstantAllocator = utils::BlockAllocator<sem::Constant>;
/// ConstantAllocator is an alias to BlockAllocator<constant::Constant>
using ConstantAllocator = utils::BlockAllocator<constant::Constant>;
/// Constructor
Program();

10
src/tint/program_builder.h
View File

@ -87,11 +87,11 @@
#include "src/tint/ast/void.h"
#include "src/tint/ast/while_statement.h"
#include "src/tint/ast/workgroup_attribute.h"
#include "src/tint/constant/constant.h"
#include "src/tint/number.h"
#include "src/tint/program.h"
#include "src/tint/program_id.h"
#include "src/tint/sem/array_count.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/struct.h"
#include "src/tint/type/array.h"
#include "src/tint/type/bool.h"
@ -265,8 +265,8 @@ class ProgramBuilder {
/// SemNodeAllocator is an alias to BlockAllocator<sem::Node>
using SemNodeAllocator = utils::BlockAllocator<sem::Node>;
/// ConstantAllocator is an alias to BlockAllocator<sem::Constant>
using ConstantAllocator = utils::BlockAllocator<sem::Constant>;
/// ConstantAllocator is an alias to BlockAllocator<constant::Constant>
using ConstantAllocator = utils::BlockAllocator<constant::Constant>;
/// Constructor
ProgramBuilder();
@ -465,12 +465,12 @@ class ProgramBuilder {
return sem_nodes_.Create<T>(std::forward<ARGS>(args)...);
}
/// Creates a new sem::Constant owned by the ProgramBuilder.
/// Creates a new constant::Constant owned by the ProgramBuilder.
/// When the ProgramBuilder is destructed, the sem::Node will also be destructed.
/// @param args the arguments to pass to the constructor
/// @returns the node pointer
template <typename T, typename... ARGS>
traits::EnableIf<traits::IsTypeOrDerived<T, sem::Constant>, T>* create(ARGS&&... args) {
traits::EnableIf<traits::IsTypeOrDerived<T, constant::Constant>, T>* create(ARGS&&... args) {
AssertNotMoved();
return constant_nodes_.Create<T>(std::forward<ARGS>(args)...);
}

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);

2
src/tint/sem/call.cc
View File

@ -26,7 +26,7 @@ Call::Call(const ast::CallExpression* declaration,
EvaluationStage stage,
utils::VectorRef<const sem::Expression*> arguments,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
bool has_side_effects)
: Base(declaration, target->ReturnType(), stage, statement, constant, has_side_effects),
target_(target),

2
src/tint/sem/call.h
View File

@ -41,7 +41,7 @@ class Call final : public Castable<Call, Expression> {
EvaluationStage stage,
utils::VectorRef<const sem::Expression*> arguments,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
bool has_side_effects);
/// Destructor

2
src/tint/sem/expression.cc
View File

@ -26,7 +26,7 @@ Expression::Expression(const ast::Expression* declaration,
const type::Type* type,
EvaluationStage stage,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
bool has_side_effects,
const Variable* root_ident /* = nullptr */)
: declaration_(declaration),

8
src/tint/sem/expression.h
View File

@ -16,8 +16,8 @@
#define SRC_TINT_SEM_EXPRESSION_H_
#include "src/tint/ast/expression.h"
#include "src/tint/constant/constant.h"
#include "src/tint/sem/behavior.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/evaluation_stage.h"
#include "src/tint/sem/node.h"
@ -44,7 +44,7 @@ class Expression : public Castable<Expression, Node> {
const type::Type* type,
EvaluationStage stage,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
bool has_side_effects,
const Variable* root_ident = nullptr);
@ -64,7 +64,7 @@ class Expression : public Castable<Expression, Node> {
const Statement* Stmt() const { return statement_; }
/// @return the constant value of this expression
const Constant* ConstantValue() const { return constant_; }
const constant::Constant* ConstantValue() const { return constant_; }
/// Returns the variable or parameter that this expression derives from.
/// For reference and pointer expressions, this will either be the originating
@ -95,7 +95,7 @@ class Expression : public Castable<Expression, Node> {
const type::Type* const type_;
const EvaluationStage stage_;
const Statement* const statement_;
const Constant* const constant_;
const constant::Constant* const constant_;
sem::Behaviors behaviors_{sem::Behavior::kNext};
const bool has_side_effects_;
};

4
src/tint/sem/expression_test.cc
View File

@ -23,13 +23,13 @@ using namespace tint::number_suffixes; // NOLINT
namespace tint::sem {
namespace {
class MockConstant : public sem::Constant {
class MockConstant : public constant::Constant {
public:
explicit MockConstant(const type::Type* ty) : type(ty) {}
~MockConstant() override {}
const type::Type* Type() const override { return type; }
std::variant<std::monostate, AInt, AFloat> Value() const override { return {}; }
const Constant* Index(size_t) const override { return {}; }
const constant::Constant* Index(size_t) const override { return {}; }
bool AllZero() const override { return {}; }
bool AnyZero() const override { return {}; }
bool AllEqual() const override { return {}; }

2
src/tint/sem/index_accessor_expression.cc
View File

@ -28,7 +28,7 @@ IndexAccessorExpression::IndexAccessorExpression(const ast::IndexAccessorExpress
const Expression* object,
const Expression* index,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
bool has_side_effects,
const Variable* root_ident /* = nullptr */)
: Base(declaration, type, stage, statement, constant, has_side_effects, root_ident),

2
src/tint/sem/index_accessor_expression.h
View File

@ -45,7 +45,7 @@ class IndexAccessorExpression final : public Castable<IndexAccessorExpression, E
const Expression* object,
const Expression* index,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
bool has_side_effects,
const Variable* root_ident = nullptr);

2
src/tint/sem/materialize.cc
View File

@ -20,7 +20,7 @@ namespace tint::sem {
Materialize::Materialize(const Expression* expr,
const Statement* statement,
const type::Type* type,
const Constant* constant)
const constant::Constant* constant)
: Base(/* declaration */ expr->Declaration(),
/* type */ type,
/* stage */ constant ? EvaluationStage::kConstant : EvaluationStage::kNotEvaluated,

2
src/tint/sem/materialize.h
View File

@ -35,7 +35,7 @@ class Materialize final : public Castable<Materialize, Expression> {
Materialize(const Expression* expr,
const Statement* statement,
const type::Type* type,
const Constant* constant);
const constant::Constant* constant);
/// Destructor
~Materialize() override;

6
src/tint/sem/member_accessor_expression.cc
View File

@ -27,7 +27,7 @@ MemberAccessorExpression::MemberAccessorExpression(const ast::MemberAccessorExpr
const type::Type* type,
EvaluationStage stage,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
const Expression* object,
bool has_side_effects,
const Variable* root_ident /* = nullptr */)
@ -39,7 +39,7 @@ MemberAccessorExpression::~MemberAccessorExpression() = default;
StructMemberAccess::StructMemberAccess(const ast::MemberAccessorExpression* declaration,
const type::Type* type,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
const Expression* object,
const StructMember* member,
bool has_side_effects,
@ -59,7 +59,7 @@ StructMemberAccess::~StructMemberAccess() = default;
Swizzle::Swizzle(const ast::MemberAccessorExpression* declaration,
const type::Type* type,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
const Expression* object,
utils::VectorRef<uint32_t> indices,
bool has_side_effects,

6
src/tint/sem/member_accessor_expression.h
View File

@ -52,7 +52,7 @@ class MemberAccessorExpression : public Castable<MemberAccessorExpression, Expre
const type::Type* type,
EvaluationStage stage,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
const Expression* object,
bool has_side_effects,
const Variable* root_ident = nullptr);
@ -78,7 +78,7 @@ class StructMemberAccess final : public Castable<StructMemberAccess, MemberAcces
StructMemberAccess(const ast::MemberAccessorExpression* declaration,
const type::Type* type,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
const Expression* object,
const StructMember* member,
bool has_side_effects,
@ -110,7 +110,7 @@ class Swizzle final : public Castable<Swizzle, MemberAccessorExpression> {
Swizzle(const ast::MemberAccessorExpression* declaration,
const type::Type* type,
const Statement* statement,
const Constant* constant,
const constant::Constant* constant,
const Expression* object,
utils::VectorRef<uint32_t> indices,
bool has_side_effects,

2
src/tint/sem/switch_statement.cc
View File

@ -49,7 +49,7 @@ const ast::CaseStatement* CaseStatement::Declaration() const {
return static_cast<const ast::CaseStatement*>(Base::Declaration());
}
CaseSelector::CaseSelector(const ast::CaseSelector* decl, const Constant* val)
CaseSelector::CaseSelector(const ast::CaseSelector* decl, const constant::Constant* val)
: Base(), decl_(decl), val_(val) {}
CaseSelector::~CaseSelector() = default;

10
src/tint/sem/switch_statement.h
View File

@ -25,10 +25,12 @@ class CaseStatement;
class CaseSelector;
class SwitchStatement;
} // namespace tint::ast
namespace tint::constant {
class Constant;
} // namespace tint::constant
namespace tint::sem {
class CaseStatement;
class CaseSelector;
class Constant;
class Expression;
} // namespace tint::sem
@ -101,7 +103,7 @@ class CaseSelector final : public Castable<CaseSelector, Node> {
/// Constructor
/// @param decl the selector declaration
/// @param val the case selector value, nullptr for a default selector
explicit CaseSelector(const ast::CaseSelector* decl, const Constant* val = nullptr);
explicit CaseSelector(const ast::CaseSelector* decl, const constant::Constant* val = nullptr);
/// Destructor
~CaseSelector() override;
@ -113,11 +115,11 @@ class CaseSelector final : public Castable<CaseSelector, Node> {
const ast::CaseSelector* Declaration() const;
/// @returns the selector constant value, or nullptr if this is the default selector
const Constant* Value() const { return val_; }
const constant::Constant* Value() const { return val_; }
private:
const ast::CaseSelector* const decl_;
const Constant* const val_;
const constant::Constant* const val_;
};
} // namespace tint::sem

6
src/tint/sem/variable.cc
View File

@ -33,7 +33,7 @@ Variable::Variable(const ast::Variable* declaration,
EvaluationStage stage,
ast::AddressSpace address_space,
ast::Access access,
const Constant* constant_value)
const constant::Constant* constant_value)
: declaration_(declaration),
type_(type),
stage_(stage),
@ -49,7 +49,7 @@ LocalVariable::LocalVariable(const ast::Variable* declaration,
ast::AddressSpace address_space,
ast::Access access,
const sem::Statement* statement,
const Constant* constant_value)
const constant::Constant* constant_value)
: Base(declaration, type, stage, address_space, access, constant_value),
statement_(statement) {}
@ -60,7 +60,7 @@ GlobalVariable::GlobalVariable(const ast::Variable* declaration,
EvaluationStage stage,
ast::AddressSpace address_space,
ast::Access access,
const Constant* constant_value,
const constant::Constant* constant_value,
sem::BindingPoint binding_point,
std::optional<uint32_t> location)
: Base(declaration, type, stage, address_space, access, constant_value),

10
src/tint/sem/variable.h
View File

@ -59,7 +59,7 @@ class Variable : public Castable<Variable, Node> {
EvaluationStage stage,
ast::AddressSpace address_space,
ast::Access access,
const Constant* constant_value);
const constant::Constant* constant_value);
/// Destructor
~Variable() override;
@ -80,7 +80,7 @@ class Variable : public Castable<Variable, Node> {
ast::Access Access() const { return access_; }
/// @return the constant value of this expression
const Constant* ConstantValue() const { return constant_value_; }
const constant::Constant* ConstantValue() const { return constant_value_; }
/// @returns the variable initializer expression, or nullptr if the variable
/// does not have one.
@ -102,7 +102,7 @@ class Variable : public Castable<Variable, Node> {
const EvaluationStage stage_;
const ast::AddressSpace address_space_;
const ast::Access access_;
const Constant* constant_value_;
const constant::Constant* constant_value_;
const Expression* initializer_ = nullptr;
std::vector<const VariableUser*> users_;
};
@ -124,7 +124,7 @@ class LocalVariable final : public Castable<LocalVariable, Variable> {
ast::AddressSpace address_space,
ast::Access access,
const sem::Statement* statement,
const Constant* constant_value);
const constant::Constant* constant_value);
/// Destructor
~LocalVariable() override;
@ -164,7 +164,7 @@ class GlobalVariable final : public Castable<GlobalVariable, Variable> {
EvaluationStage stage,
ast::AddressSpace address_space,
ast::Access access,
const Constant* constant_value,
const constant::Constant* constant_value,
sem::BindingPoint binding_point = {},
std::optional<uint32_t> location = std::nullopt);

2
src/tint/tint.natvis
View File

@ -256,7 +256,7 @@
<DisplayString>vec{width_}&lt;{*subtype_}&gt;</DisplayString>
</Type>
<Type Name="tint::sem::Constant">
<Type Name="tint::constant::Constant">
<DisplayString>Type={*Type()} Value={Value()}</DisplayString>
</Type>

4
src/tint/writer/glsl/generator_impl.cc
View File

@ -26,10 +26,10 @@
#include "src/tint/ast/internal_attribute.h"
#include "src/tint/ast/interpolate_attribute.h"
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/constant/constant.h"
#include "src/tint/debug.h"
#include "src/tint/sem/block_statement.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/member_accessor_expression.h"
#include "src/tint/sem/module.h"
@ -2294,7 +2294,7 @@ bool GeneratorImpl::EmitEntryPointFunction(const ast::Function* func) {
return true;
}
bool GeneratorImpl::EmitConstant(std::ostream& out, const sem::Constant* constant) {
bool GeneratorImpl::EmitConstant(std::ostream& out, const constant::Constant* constant) {
return Switch(
constant->Type(), //
[&](const type::Bool*) {

2
src/tint/writer/glsl/generator_impl.h
View File

@ -363,7 +363,7 @@ class GeneratorImpl : public TextGenerator {
/// @param out the output stream
/// @param constant the constant value to emit
/// @returns true if the constant value was successfully emitted
bool EmitConstant(std::ostream& out, const sem::Constant* constant);
bool EmitConstant(std::ostream& out, const constant::Constant* constant);
/// Handles a literal
/// @param out the output stream
/// @param lit the literal to emit

4
src/tint/writer/hlsl/generator_impl.cc
View File

@ -27,10 +27,10 @@
#include "src/tint/ast/internal_attribute.h"
#include "src/tint/ast/interpolate_attribute.h"
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/constant/constant.h"
#include "src/tint/debug.h"
#include "src/tint/sem/block_statement.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/member_accessor_expression.h"
#include "src/tint/sem/module.h"
@ -3263,7 +3263,7 @@ bool GeneratorImpl::EmitEntryPointFunction(const ast::Function* func) {
}
bool GeneratorImpl::EmitConstant(std::ostream& out,
const sem::Constant* constant,
const constant::Constant* constant,
bool is_variable_initializer) {
return Switch(
constant->Type(), //

2
src/tint/writer/hlsl/generator_impl.h
View File

@ -352,7 +352,7 @@ class GeneratorImpl : public TextGenerator {
/// initializer
/// @returns true if the constant value was successfully emitted
bool EmitConstant(std::ostream& out,
const sem::Constant* constant,
const constant::Constant* constant,
bool is_variable_initializer);
/// Handles a literal
/// @param out the output stream

4
src/tint/writer/msl/generator_impl.cc
View File

@ -31,8 +31,8 @@
#include "src/tint/ast/module.h"
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/ast/void.h"
#include "src/tint/constant/constant.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/member_accessor_expression.h"
#include "src/tint/sem/module.h"
@ -1658,7 +1658,7 @@ bool GeneratorImpl::EmitZeroValue(std::ostream& out, const type::Type* type) {
});
}
bool GeneratorImpl::EmitConstant(std::ostream& out, const sem::Constant* constant) {
bool GeneratorImpl::EmitConstant(std::ostream& out, const constant::Constant* constant) {
return Switch(
constant->Type(), //
[&](const type::Bool*) {

2
src/tint/writer/msl/generator_impl.h
View File

@ -260,7 +260,7 @@ class GeneratorImpl : public TextGenerator {
/// @param out the output stream
/// @param constant the constant value to emit
/// @returns true if the constant value was successfully emitted
bool EmitConstant(std::ostream& out, const sem::Constant* constant);
bool EmitConstant(std::ostream& out, const constant::Constant* constant);
/// Handles a literal
/// @param out the output of the expression stream
/// @param lit the literal to emit

4
src/tint/writer/spirv/builder.cc
View File

@ -22,9 +22,9 @@
#include "src/tint/ast/id_attribute.h"
#include "src/tint/ast/internal_attribute.h"
#include "src/tint/ast/traverse_expressions.h"
#include "src/tint/constant/constant.h"
#include "src/tint/sem/builtin.h"
#include "src/tint/sem/call.h"
#include "src/tint/sem/constant.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/materialize.h"
#include "src/tint/sem/member_accessor_expression.h"
@ -1641,7 +1641,7 @@ uint32_t Builder::GenerateLiteralIfNeeded(const ast::LiteralExpression* lit) {
return GenerateConstantIfNeeded(constant);
}
uint32_t Builder::GenerateConstantIfNeeded(const sem::Constant* constant) {
uint32_t Builder::GenerateConstantIfNeeded(const constant::Constant* constant) {
if (constant->AllZero()) {
return GenerateConstantNullIfNeeded(constant->Type());
}

2
src/tint/writer/spirv/builder.h
View File

@ -559,7 +559,7 @@ class Builder {
/// Generates a constant value if needed
/// @param constant the constant to generate.
/// @returns the ID on success or 0 on failure
uint32_t GenerateConstantIfNeeded(const sem::Constant* constant);
uint32_t GenerateConstantIfNeeded(const constant::Constant* constant);
/// Generates a scalar constant if needed
/// @param constant the constant to generate.