Skip to content

Commit 66d7387

Browse files
teoxoyteoxoy
committed
[msl] refactor chain of if blocks to match 
1 parent 7078b0a commit 66d7387

File tree

1 file changed

+130
-118
lines changed

1 file changed

+130
-118
lines changed

‎naga/src/back/msl/writer.rs

Lines changed: 130 additions & 118 deletions
Original file line numberDiff line numberDiff line change
@@ -1853,133 +1853,145 @@ impl<W: Write> Writer<W> {
18531853
_ => {}
18541854
}
18551855

1856-
if fun == Mf::Distance && scalar_argument {
1857-
write!(self.out, "{NAMESPACE}::abs(")?;
1858-
self.put_expression(arg, context, false)?;
1859-
write!(self.out, " - ")?;
1860-
self.put_expression(arg1.unwrap(), context, false)?;
1861-
write!(self.out, ")")?;
1862-
} else if fun == Mf::FindLsb {
1863-
let scalar = context.resolve_type(arg).scalar().unwrap();
1864-
let constant = scalar.width * 8 + 1;
1865-
1866-
write!(self.out, "((({NAMESPACE}::ctz(")?;
1867-
self.put_expression(arg, context, true)?;
1868-
write!(self.out, ") + 1) % {constant}) - 1)")?;
1869-
} else if fun == Mf::FindMsb {
1870-
let inner = context.resolve_type(arg);
1871-
let scalar = inner.scalar().unwrap();
1872-
let constant = scalar.width * 8 - 1;
1873-
1874-
write!(
1875-
self.out,
1876-
"{NAMESPACE}::select({constant} - {NAMESPACE}::clz("
1877-
)?;
1856+
match fun {
1857+
Mf::Distance if scalar_argument => {
1858+
write!(self.out, "{NAMESPACE}::abs(")?;
1859+
self.put_expression(arg, context, false)?;
1860+
write!(self.out, " - ")?;
1861+
self.put_expression(arg1.unwrap(), context, false)?;
1862+
write!(self.out, ")")?;
1863+
}
1864+
Mf::FindLsb => {
1865+
let scalar = context.resolve_type(arg).scalar().unwrap();
1866+
let constant = scalar.width * 8 + 1;
18781867

1879-
if scalar.kind == crate::ScalarKind::Sint {
1880-
write!(self.out, "{NAMESPACE}::select(")?;
1881-
self.put_expression(arg, context, true)?;
1882-
write!(self.out, ", ~")?;
1883-
self.put_expression(arg, context, true)?;
1884-
write!(self.out, ", ")?;
1885-
self.put_expression(arg, context, true)?;
1886-
write!(self.out, " < 0)")?;
1887-
} else {
1868+
write!(self.out, "((({NAMESPACE}::ctz(")?;
18881869
self.put_expression(arg, context, true)?;
1870+
write!(self.out, ") + 1) % {constant}) - 1)")?;
18891871
}
1872+
Mf::FindMsb => {
1873+
let inner = context.resolve_type(arg);
1874+
let scalar = inner.scalar().unwrap();
1875+
let constant = scalar.width * 8 - 1;
18901876

1891-
write!(self.out, "), ")?;
1877+
write!(
1878+
self.out,
1879+
"{NAMESPACE}::select({constant} - {NAMESPACE}::clz("
1880+
)?;
18921881

1893-
// or metal will complain that select is ambiguous
1894-
match *inner {
1895-
crate::TypeInner::Vector { size, scalar } => {
1896-
let size = back::vector_size_str(size);
1897-
let name = scalar.to_msl_name();
1898-
write!(self.out, "{name}{size}")?;
1882+
if scalar.kind == crate::ScalarKind::Sint {
1883+
write!(self.out, "{NAMESPACE}::select(")?;
1884+
self.put_expression(arg, context, true)?;
1885+
write!(self.out, ", ~")?;
1886+
self.put_expression(arg, context, true)?;
1887+
write!(self.out, ", ")?;
1888+
self.put_expression(arg, context, true)?;
1889+
write!(self.out, " < 0)")?;
1890+
} else {
1891+
self.put_expression(arg, context, true)?;
18991892
}
1900-
crate::TypeInner::Scalar(scalar) => {
1901-
let name = scalar.to_msl_name();
1902-
write!(self.out, "{name}")?;
1893+
1894+
write!(self.out, "), ")?;
1895+
1896+
// or metal will complain that select is ambiguous
1897+
match *inner {
1898+
crate::TypeInner::Vector { size, scalar } => {
1899+
let size = back::vector_size_str(size);
1900+
let name = scalar.to_msl_name();
1901+
write!(self.out, "{name}{size}")?;
1902+
}
1903+
crate::TypeInner::Scalar(scalar) => {
1904+
let name = scalar.to_msl_name();
1905+
write!(self.out, "{name}")?;
1906+
}
1907+
_ => (),
19031908
}
1904-
_ => (),
1909+
1910+
write!(self.out, "(-1), ")?;
1911+
self.put_expression(arg, context, true)?;
1912+
write!(self.out, " == 0 || ")?;
1913+
self.put_expression(arg, context, true)?;
1914+
write!(self.out, " == -1)")?;
1915+
}
1916+
Mf::Unpack2x16float => {
1917+
write!(self.out, "float2(as_type<half2>(")?;
1918+
self.put_expression(arg, context, false)?;
1919+
write!(self.out, "))")?;
19051920
}
1921+
Mf::Pack2x16float => {
1922+
write!(self.out, "as_type<uint>(half2(")?;
1923+
self.put_expression(arg, context, false)?;
1924+
write!(self.out, "))")?;
1925+
}
1926+
Mf::ExtractBits => {
1927+
// The behavior of ExtractBits is undefined when offset + count > bit_width. We need
1928+
// to first sanitize the offset and count first. If we don't do this, Apple chips
1929+
// will return out-of-spec values if the extracted range is not within the bit width.
1930+
//
1931+
// This encodes the exact formula specified by the wgsl spec, without temporary values:
1932+
// https://gpuweb.github.io/gpuweb/wgsl/#extractBits-unsigned-builtin
1933+
//
1934+
// w = sizeof(x) * 8
1935+
// o = min(offset, w)
1936+
// tmp = w - o
1937+
// c = min(count, tmp)
1938+
//
1939+
// bitfieldExtract(x, o, c)
1940+
//
1941+
// extract_bits(e, min(offset, w), min(count, w - min(offset, w))))
19061942

1907-
write!(self.out, "(-1), ")?;
1908-
self.put_expression(arg, context, true)?;
1909-
write!(self.out, " == 0 || ")?;
1910-
self.put_expression(arg, context, true)?;
1911-
write!(self.out, " == -1)")?;
1912-
} else if fun == Mf::Unpack2x16float {
1913-
write!(self.out, "float2(as_type<half2>(")?;
1914-
self.put_expression(arg, context, false)?;
1915-
write!(self.out, "))")?;
1916-
} else if fun == Mf::Pack2x16float {
1917-
write!(self.out, "as_type<uint>(half2(")?;
1918-
self.put_expression(arg, context, false)?;
1919-
write!(self.out, "))")?;
1920-
} else if fun == Mf::ExtractBits {
1921-
// The behavior of ExtractBits is undefined when offset + count > bit_width. We need
1922-
// to first sanitize the offset and count first. If we don't do this, Apple chips
1923-
// will return out-of-spec values if the extracted range is not within the bit width.
1924-
//
1925-
// This encodes the exact formula specified by the wgsl spec, without temporary values:
1926-
// https://gpuweb.github.io/gpuweb/wgsl/#extractBits-unsigned-builtin
1927-
//
1928-
// w = sizeof(x) * 8
1929-
// o = min(offset, w)
1930-
// tmp = w - o
1931-
// c = min(count, tmp)
1932-
//
1933-
// bitfieldExtract(x, o, c)
1934-
//
1935-
// extract_bits(e, min(offset, w), min(count, w - min(offset, w))))
1936-
1937-
let scalar_bits = context.resolve_type(arg).scalar_width().unwrap() * 8;
1938-
1939-
write!(self.out, "{NAMESPACE}::extract_bits(")?;
1940-
self.put_expression(arg, context, true)?;
1941-
write!(self.out, ", {NAMESPACE}::min(")?;
1942-
self.put_expression(arg1.unwrap(), context, true)?;
1943-
write!(self.out, ", {scalar_bits}u), {NAMESPACE}::min(")?;
1944-
self.put_expression(arg2.unwrap(), context, true)?;
1945-
write!(self.out, ", {scalar_bits}u - {NAMESPACE}::min(")?;
1946-
self.put_expression(arg1.unwrap(), context, true)?;
1947-
write!(self.out, ", {scalar_bits}u)))")?;
1948-
} else if fun == Mf::InsertBits {
1949-
// The behavior of InsertBits has the same issue as ExtractBits.
1950-
//
1951-
// insertBits(e, newBits, min(offset, w), min(count, w - min(offset, w))))
1952-
1953-
let scalar_bits = context.resolve_type(arg).scalar_width().unwrap() * 8;
1954-
1955-
write!(self.out, "{NAMESPACE}::insert_bits(")?;
1956-
self.put_expression(arg, context, true)?;
1957-
write!(self.out, ", ")?;
1958-
self.put_expression(arg1.unwrap(), context, true)?;
1959-
write!(self.out, ", {NAMESPACE}::min(")?;
1960-
self.put_expression(arg2.unwrap(), context, true)?;
1961-
write!(self.out, ", {scalar_bits}u), {NAMESPACE}::min(")?;
1962-
self.put_expression(arg3.unwrap(), context, true)?;
1963-
write!(self.out, ", {scalar_bits}u - {NAMESPACE}::min(")?;
1964-
self.put_expression(arg2.unwrap(), context, true)?;
1965-
write!(self.out, ", {scalar_bits}u)))")?;
1966-
} else if fun == Mf::Radians {
1967-
write!(self.out, "((")?;
1968-
self.put_expression(arg, context, false)?;
1969-
write!(self.out, ") * 0.017453292519943295474)")?;
1970-
} else if fun == Mf::Degrees {
1971-
write!(self.out, "((")?;
1972-
self.put_expression(arg, context, false)?;
1973-
write!(self.out, ") * 57.295779513082322865)")?;
1974-
} else if fun == Mf::Modf || fun == Mf::Frexp {
1975-
write!(self.out, "{fun_name}")?;
1976-
self.put_call_parameters(iter::once(arg), context)?;
1977-
} else {
1978-
write!(self.out, "{NAMESPACE}::{fun_name}")?;
1979-
self.put_call_parameters(
1980-
iter::once(arg).chain(arg1).chain(arg2).chain(arg3),
1981-
context,
1982-
)?;
1943+
let scalar_bits = context.resolve_type(arg).scalar_width().unwrap() * 8;
1944+
1945+
write!(self.out, "{NAMESPACE}::extract_bits(")?;
1946+
self.put_expression(arg, context, true)?;
1947+
write!(self.out, ", {NAMESPACE}::min(")?;
1948+
self.put_expression(arg1.unwrap(), context, true)?;
1949+
write!(self.out, ", {scalar_bits}u), {NAMESPACE}::min(")?;
1950+
self.put_expression(arg2.unwrap(), context, true)?;
1951+
write!(self.out, ", {scalar_bits}u - {NAMESPACE}::min(")?;
1952+
self.put_expression(arg1.unwrap(), context, true)?;
1953+
write!(self.out, ", {scalar_bits}u)))")?;
1954+
}
1955+
Mf::InsertBits => {
1956+
// The behavior of InsertBits has the same issue as ExtractBits.
1957+
//
1958+
// insertBits(e, newBits, min(offset, w), min(count, w - min(offset, w))))
1959+
1960+
let scalar_bits = context.resolve_type(arg).scalar_width().unwrap() * 8;
1961+
1962+
write!(self.out, "{NAMESPACE}::insert_bits(")?;
1963+
self.put_expression(arg, context, true)?;
1964+
write!(self.out, ", ")?;
1965+
self.put_expression(arg1.unwrap(), context, true)?;
1966+
write!(self.out, ", {NAMESPACE}::min(")?;
1967+
self.put_expression(arg2.unwrap(), context, true)?;
1968+
write!(self.out, ", {scalar_bits}u), {NAMESPACE}::min(")?;
1969+
self.put_expression(arg3.unwrap(), context, true)?;
1970+
write!(self.out, ", {scalar_bits}u - {NAMESPACE}::min(")?;
1971+
self.put_expression(arg2.unwrap(), context, true)?;
1972+
write!(self.out, ", {scalar_bits}u)))")?;
1973+
}
1974+
Mf::Radians => {
1975+
write!(self.out, "((")?;
1976+
self.put_expression(arg, context, false)?;
1977+
write!(self.out, ") * 0.017453292519943295474)")?;
1978+
}
1979+
Mf::Degrees => {
1980+
write!(self.out, "((")?;
1981+
self.put_expression(arg, context, false)?;
1982+
write!(self.out, ") * 57.295779513082322865)")?;
1983+
}
1984+
Mf::Modf | Mf::Frexp => {
1985+
write!(self.out, "{fun_name}")?;
1986+
self.put_call_parameters(iter::once(arg), context)?;
1987+
}
1988+
_ => {
1989+
write!(self.out, "{NAMESPACE}::{fun_name}")?;
1990+
self.put_call_parameters(
1991+
iter::once(arg).chain(arg1).chain(arg2).chain(arg3),
1992+
context,
1993+
)?;
1994+
}
19831995
}
19841996
}
19851997
crate::Expression::As {

0 commit comments

Comments
 (0)