Skip to content

Commit

Permalink
remove all matches that aren't the bare minimum for the test case
Browse files Browse the repository at this point in the history
  • Loading branch information
@schell
schell committed Jun 13, 2024
1 parent ca9fa56 commit f6c97c7
Show file tree
Hide file tree
Showing 2 changed files with 4 additions and 170 deletions.
162 changes: 4 additions & 158 deletions naga/src/front/atomic_upgrade.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,6 +12,8 @@ pub enum Error {
MissingHandle(crate::arena::BadHandle),
#[error("no function context")]
NoFunction,
#[error("encountered an unsupported expression")]
Unsupported,
}

impl From<Error> for crate::front::spv::Error {
Expand Down Expand Up @@ -283,7 +285,6 @@ impl<'a> UpgradeState<'a> {
}
}

// Upgrade the expression, recursing int we reach...
fn upgrade_expression(
&mut self,
maybe_fn_handle: Option<Handle<Function>>,
Expand All @@ -300,174 +301,19 @@ impl<'a> UpgradeState<'a> {

padding.debug("expr: ", &expr);
let new_expr = match expr.clone() {
l @ Expression::Literal(_) => l,
Expression::Constant(h) => Expression::Constant(self.upgrade_constant(h)?),
Expression::Override(h) => Expression::Override(self.upgrade_override(h)?),
Expression::ZeroValue(ty) => Expression::ZeroValue(self.upgrade_type(ty)?),
Expression::Compose { ty, components } => Expression::Compose {
ty: self.upgrade_type(ty)?,
components: {
let mut new_components = vec![];
for component in components.into_iter() {
new_components.push(self.upgrade_expression(maybe_fn_handle, component)?);
}
new_components
},
},
Expression::Access { base, index } => Expression::Access {
base: self.upgrade_expression(maybe_fn_handle, base)?,
index: self.upgrade_expression(maybe_fn_handle, index)?,
},
Expression::AccessIndex { base, index } => Expression::AccessIndex {
base: self.upgrade_expression(maybe_fn_handle, base)?,
index,
},
Expression::Splat { size, value } => Expression::Splat {
size,
value: self.upgrade_expression(maybe_fn_handle, value)?,
},
Expression::Swizzle {
size,
vector,
pattern,
} => Expression::Swizzle {
size,
vector: self.upgrade_expression(maybe_fn_handle, vector)?,
pattern,
},
f @ Expression::FunctionArgument(_) => f,
Expression::GlobalVariable(var) => {
Expression::GlobalVariable(self.upgrade_global_variable(var)?)
}
Expression::LocalVariable(var) => Expression::LocalVariable(
self.upgrade_local_variable(maybe_fn_handle.ok_or(Error::NoFunction)?, var)?,
),
Expression::Load { pointer } => Expression::Load {
pointer: self.upgrade_expression(maybe_fn_handle, pointer)?,
},
Expression::ImageSample {
image,
sampler,
gather,
coordinate,
array_index,
offset,
level,
depth_ref,
} => Expression::ImageSample {
image: self.upgrade_expression(maybe_fn_handle, image)?,
sampler: self.upgrade_expression(maybe_fn_handle, sampler)?,
gather,
coordinate: self.upgrade_expression(maybe_fn_handle, coordinate)?,
array_index: self.upgrade_opt_expression(maybe_fn_handle, array_index)?,
offset: self.upgrade_opt_expression(maybe_fn_handle, offset)?,
level: match level {
crate::SampleLevel::Exact(h) => {
crate::SampleLevel::Exact(self.upgrade_expression(maybe_fn_handle, h)?)
}
crate::SampleLevel::Bias(h) => {
crate::SampleLevel::Bias(self.upgrade_expression(maybe_fn_handle, h)?)
}
crate::SampleLevel::Gradient { x, y } => crate::SampleLevel::Gradient {
x: self.upgrade_expression(maybe_fn_handle, x)?,
y: self.upgrade_expression(maybe_fn_handle, y)?,
},
n => n,
},
depth_ref: self.upgrade_opt_expression(maybe_fn_handle, depth_ref)?,
},
Expression::ImageLoad {
image,
coordinate,
array_index,
sample,
level,
} => Expression::ImageLoad {
image: self.upgrade_expression(maybe_fn_handle, image)?,
coordinate: self.upgrade_expression(maybe_fn_handle, coordinate)?,
array_index: self.upgrade_opt_expression(maybe_fn_handle, array_index)?,
sample: self.upgrade_opt_expression(maybe_fn_handle, sample)?,
level: self.upgrade_opt_expression(maybe_fn_handle, level)?,
},
Expression::ImageQuery { image, query } => Expression::ImageQuery {
image: self.upgrade_expression(maybe_fn_handle, image)?,
query: match query {
crate::ImageQuery::Size { level } => crate::ImageQuery::Size {
level: self.upgrade_opt_expression(maybe_fn_handle, level)?,
},
n => n,
},
},
Expression::Unary { op, expr } => Expression::Unary {
op,
expr: self.upgrade_expression(maybe_fn_handle, expr)?,
},
Expression::Binary { op, left, right } => Expression::Binary {
op,
left: self.upgrade_expression(maybe_fn_handle, left)?,
right: self.upgrade_expression(maybe_fn_handle, right)?,
},
Expression::Select {
condition,
accept,
reject,
} => Expression::Select {
condition: self.upgrade_expression(maybe_fn_handle, condition)?,
accept: self.upgrade_expression(maybe_fn_handle, accept)?,
reject: self.upgrade_expression(maybe_fn_handle, reject)?,
},
Expression::Derivative { axis, ctrl, expr } => Expression::Derivative {
axis,
ctrl,
expr: self.upgrade_expression(maybe_fn_handle, expr)?,
},
Expression::Relational { fun, argument } => Expression::Relational {
fun,
argument: self.upgrade_expression(maybe_fn_handle, argument)?,
},
Expression::Math {
fun,
arg,
arg1,
arg2,
arg3,
} => Expression::Math {
fun,
arg: self.upgrade_expression(maybe_fn_handle, arg)?,
arg1: self.upgrade_opt_expression(maybe_fn_handle, arg1)?,
arg2: self.upgrade_opt_expression(maybe_fn_handle, arg2)?,
arg3: self.upgrade_opt_expression(maybe_fn_handle, arg3)?,
},
Expression::As {
expr,
kind,
convert,
} => Expression::As {
expr: self.upgrade_expression(maybe_fn_handle, expr)?,
kind,
convert,
},
c @ Expression::CallResult(_) => c,
a @ Expression::AtomicResult { .. } => a,
Expression::WorkGroupUniformLoadResult { ty } => {
Expression::WorkGroupUniformLoadResult {
ty: self.upgrade_type(ty)?,
}
}
Expression::ArrayLength(h) => {
Expression::ArrayLength(self.upgrade_expression(maybe_fn_handle, h)?)
_ => {
return Err(Error::Unsupported);
}
r @ Expression::RayQueryProceedResult => r,
Expression::RayQueryGetIntersection { query, committed } => {
Expression::RayQueryGetIntersection {
query: self.upgrade_expression(maybe_fn_handle, query)?,
committed,
}
}
s @ Expression::SubgroupBallotResult => s,
Expression::SubgroupOperationResult { ty } => Expression::SubgroupOperationResult {
ty: self.upgrade_type(ty)?,
},
};

if new_expr != expr {
Expand Down
12 changes: 0 additions & 12 deletions naga/src/front/spv/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -151,18 +151,6 @@ impl<T> LookupHelper for FastHashMap<spirv::Word, T> {
}
}

trait LookupMutHelper {
type Target;
fn lookup_mut(&mut self, key: spirv::Word) -> Result<&mut Self::Target, Error>;
}

impl<T> LookupMutHelper for FastHashMap<spirv::Word, T> {
type Target = T;
fn lookup_mut(&mut self, key: spirv::Word) -> Result<&mut T, Error> {
self.get_mut(&key).ok_or(Error::InvalidId(key))
}
}

impl crate::ImageDimension {
const fn required_coordinate_size(&self) -> Option<crate::VectorSize> {
match *self {
Expand Down

0 comments on commit f6c97c7

Please sign in to comment.