Add f32 and f64 distinction

codegen/luajit/runtime/runtime.lua

@@ -96,11 +96,11 @@ do
 		return (i64(u64(lhs) % u64(rhs)))
 	end
 
-	function neg.num(num)
+	function neg.f32(num)
 		return -num
 	end
 
-	function copysign.num(lhs, rhs)
+	function copysign.f32(lhs, rhs)
 		RE_INSTANCE.f64 = rhs
 
 		if RE_INSTANCE.b32 >= 0 then
@@ -110,7 +110,7 @@ do
 		end
 	end
 
-	function nearest.num(num)
+	function nearest.f32(num)
 		local result = round(num)
 
 		if math_abs(num) % 1 == 0.5 and temp_2 % 2 == 1 then
@@ -120,6 +120,10 @@ do
 		return result
 	end
 
+	neg.f64 = neg.f32
+	copysign.f64 = copysign.f32
+	nearest.f64 = nearest.f32
+
 	module.add = add
 	module.sub = sub
 	module.mul = mul

codegen/luajit/src/analyzer/as_symbol.rs

@@ -7,10 +7,10 @@ pub trait AsSymbol {
 impl AsSymbol for BinOpType {
 	fn as_symbol(&self) -> Option<&'static str> {
 		let result = match self {
-			Self::Add_I64 | Self::Add_FN => "+",
+			Self::Add_I64 | Self::Add_F32 | Self::Add_F64 => "+",
-			Self::Sub_I64 | Self::Sub_FN => "-",
+			Self::Sub_I64 | Self::Sub_F32 | Self::Sub_F64 => "-",
-			Self::Mul_I64 | Self::Mul_FN => "*",
+			Self::Mul_I64 | Self::Mul_F32 | Self::Mul_F64 => "*",
-			Self::DivS_I64 | Self::Div_FN => "/",
+			Self::DivS_I64 | Self::Div_F32 | Self::Div_F64 => "/",
 			Self::RemS_I64 => "%",
 			_ => return None,
 		};
@@ -22,12 +22,12 @@ impl AsSymbol for BinOpType {
 impl AsSymbol for CmpOpType {
 	fn as_symbol(&self) -> Option<&'static str> {
 		let result = match self {
-			Self::Eq_I32 | Self::Eq_I64 | Self::Eq_FN => "==",
+			Self::Eq_I32 | Self::Eq_I64 | Self::Eq_F32 | Self::Eq_F64 => "==",
-			Self::Ne_I32 | Self::Ne_I64 | Self::Ne_FN => "~=",
+			Self::Ne_I32 | Self::Ne_I64 | Self::Ne_F32 | Self::Ne_F64 => "~=",
-			Self::LtS_I32 | Self::LtS_I64 | Self::Lt_FN => "<",
+			Self::LtS_I32 | Self::LtS_I64 | Self::Lt_F32 | Self::Lt_F64 => "<",
-			Self::GtS_I32 | Self::GtS_I64 | Self::Gt_FN => ">",
+			Self::GtS_I32 | Self::GtS_I64 | Self::Gt_F32 | Self::Gt_F64 => ">",
-			Self::LeS_I32 | Self::LeS_I64 | Self::Le_FN => "<=",
+			Self::LeS_I32 | Self::LeS_I64 | Self::Le_F32 | Self::Le_F64 => "<=",
-			Self::GeS_I32 | Self::GeS_I64 | Self::Ge_FN => ">=",
+			Self::GeS_I32 | Self::GeS_I64 | Self::Ge_F32 | Self::Ge_F64 => ">=",
 			_ => return None,
 		};
 

codegen/luau/runtime/runtime.lua

@@ -87,11 +87,11 @@ do
 
 	div.u64 = I64.divide_unsigned
 
-	function neg.num(num)
+	function neg.f32(num)
 		return -num
 	end
 
-	function min.num(a, b)
+	function min.f32(a, b)
 		if b == b then
 			return math_min(a, b)
 		else
@@ -99,7 +99,7 @@ do
 		end
 	end
 
-	function max.num(a, b)
+	function max.f32(a, b)
 		if b == b then
 			return math_max(a, b)
 		else
@@ -107,7 +107,7 @@ do
 		end
 	end
 
-	function copysign.num(lhs, rhs)
+	function copysign.f32(lhs, rhs)
 		if rhs >= 0 then
 			return (math_abs(lhs))
 		else
@@ -115,7 +115,7 @@ do
 		end
 	end
 
-	function nearest.num(num)
+	function nearest.f32(num)
 		local result = math_round(num)
 
 		if math_abs(num) % 1 == 0.5 and math_floor(math_abs(num) % 2) == 0 then
@@ -125,6 +125,12 @@ do
 		return result
 	end
 
+	neg.f64 = neg.f32
+	min.f64 = min.f32
+	max.f64 = max.f32
+	copysign.f64 = copysign.f32
+	nearest.f64 = nearest.f32
+
 	module.add = add
 	module.sub = sub
 	module.mul = mul
@@ -333,7 +339,7 @@ do
 		end
 	end
 
-	function trunc.num(num)
+	function trunc.f32(num)
 		if num >= 0 then
 			return math.floor(num)
 		else
@@ -341,6 +347,7 @@ do
 		end
 	end
 
+	trunc.f64 = trunc.f32
 	trunc.u64_f32 = num_from_u64
 	trunc.u64_f64 = num_from_u64
 

codegen/luau/src/analyzer/as_symbol.rs

@@ -7,10 +7,10 @@ pub trait AsSymbol {
 impl AsSymbol for BinOpType {
 	fn as_symbol(&self) -> Option<&'static str> {
 		let result = match self {
-			Self::Add_FN => "+",
+			Self::Add_F32 | Self::Add_F64 => "+",
-			Self::Sub_FN => "-",
+			Self::Sub_F32 | Self::Sub_F64 => "-",
-			Self::Mul_FN => "*",
+			Self::Mul_F32 | Self::Mul_F64 => "*",
-			Self::Div_FN => "/",
+			Self::Div_F32 | Self::Div_F64 => "/",
 			Self::RemS_I32 | Self::RemU_I32 => "%",
 			_ => return None,
 		};
@@ -22,12 +22,12 @@ impl AsSymbol for BinOpType {
 impl AsSymbol for CmpOpType {
 	fn as_symbol(&self) -> Option<&'static str> {
 		let result = match self {
-			Self::Eq_I32 | Self::Eq_FN => "==",
+			Self::Eq_I32 | Self::Eq_F32 | Self::Eq_F64 => "==",
-			Self::Ne_I32 | Self::Ne_FN => "~=",
+			Self::Ne_I32 | Self::Ne_F32 | Self::Ne_F64 => "~=",
-			Self::LtU_I32 | Self::Lt_FN => "<",
+			Self::LtU_I32 | Self::Lt_F32 | Self::Lt_F64 => "<",
-			Self::GtU_I32 | Self::Gt_FN => ">",
+			Self::GtU_I32 | Self::Gt_F32 | Self::Gt_F64 => ">",
-			Self::LeU_I32 | Self::Le_FN => "<=",
+			Self::LeU_I32 | Self::Le_F32 | Self::Le_F64 => "<=",
-			Self::GeU_I32 | Self::Ge_FN => ">=",
+			Self::GeU_I32 | Self::Ge_F32 | Self::Ge_F64 => ">=",
 			_ => return None,
 		};
 

wasm-ast/src/node.rs

@@ -132,13 +132,20 @@ pub enum UnOpType {
 	Clz_I64,
 	Ctz_I64,
 	Popcnt_I64,
-	Abs_FN,
+	Abs_F32,
-	Neg_FN,
+	Neg_F32,
-	Ceil_FN,
+	Ceil_F32,
-	Floor_FN,
+	Floor_F32,
-	Trunc_FN,
+	Trunc_F32,
-	Nearest_FN,
+	Nearest_F32,
-	Sqrt_FN,
+	Sqrt_F32,
+	Abs_F64,
+	Neg_F64,
+	Ceil_F64,
+	Floor_F64,
+	Trunc_F64,
+	Nearest_F64,
+	Sqrt_F64,
 	Wrap_I32_I64,
 	Trunc_I32_F32,
 	Trunc_U32_F32,
@@ -180,13 +187,20 @@ impl UnOpType {
 			Self::Clz_I64 => ("clz", "i64"),
 			Self::Ctz_I64 => ("ctz", "i64"),
 			Self::Popcnt_I64 => ("popcnt", "i64"),
-			Self::Abs_FN => ("abs", "num"),
+			Self::Abs_F32 => ("abs", "f32"),
-			Self::Neg_FN => ("neg", "num"),
+			Self::Neg_F32 => ("neg", "f32"),
-			Self::Ceil_FN => ("ceil", "num"),
+			Self::Ceil_F32 => ("ceil", "f32"),
-			Self::Floor_FN => ("floor", "num"),
+			Self::Floor_F32 => ("floor", "f32"),
-			Self::Trunc_FN => ("trunc", "num"),
+			Self::Trunc_F32 => ("trunc", "f32"),
-			Self::Nearest_FN => ("nearest", "num"),
+			Self::Nearest_F32 => ("nearest", "f32"),
-			Self::Sqrt_FN => ("sqrt", "num"),
+			Self::Sqrt_F32 => ("sqrt", "f32"),
+			Self::Abs_F64 => ("abs", "f64"),
+			Self::Neg_F64 => ("neg", "f64"),
+			Self::Ceil_F64 => ("ceil", "f64"),
+			Self::Floor_F64 => ("floor", "f64"),
+			Self::Trunc_F64 => ("trunc", "f64"),
+			Self::Nearest_F64 => ("nearest", "f64"),
+			Self::Sqrt_F64 => ("sqrt", "f64"),
 			Self::Wrap_I32_I64 => ("wrap", "i32_i64"),
 			Self::Trunc_I32_F32 => ("trunc", "i32_f32"),
 			Self::Trunc_U32_F32 => ("trunc", "u32_f32"),
@@ -231,13 +245,20 @@ impl TryFrom<&Operator<'_>> for UnOpType {
 			Operator::I64Clz => Self::Clz_I64,
 			Operator::I64Ctz => Self::Ctz_I64,
 			Operator::I64Popcnt => Self::Popcnt_I64,
-			Operator::F32Abs | Operator::F64Abs => Self::Abs_FN,
+			Operator::F32Abs => Self::Abs_F32,
-			Operator::F32Neg | Operator::F64Neg => Self::Neg_FN,
+			Operator::F32Neg => Self::Neg_F32,
-			Operator::F32Ceil | Operator::F64Ceil => Self::Ceil_FN,
+			Operator::F32Ceil => Self::Ceil_F32,
-			Operator::F32Floor | Operator::F64Floor => Self::Floor_FN,
+			Operator::F32Floor => Self::Floor_F32,
-			Operator::F32Trunc | Operator::F64Trunc => Self::Trunc_FN,
+			Operator::F32Trunc => Self::Trunc_F32,
-			Operator::F32Nearest | Operator::F64Nearest => Self::Nearest_FN,
+			Operator::F32Nearest => Self::Nearest_F32,
-			Operator::F32Sqrt | Operator::F64Sqrt => Self::Sqrt_FN,
+			Operator::F32Sqrt => Self::Sqrt_F32,
+			Operator::F64Abs => Self::Abs_F64,
+			Operator::F64Neg => Self::Neg_F64,
+			Operator::F64Ceil => Self::Ceil_F64,
+			Operator::F64Floor => Self::Floor_F64,
+			Operator::F64Trunc => Self::Trunc_F64,
+			Operator::F64Nearest => Self::Nearest_F64,
+			Operator::F64Sqrt => Self::Sqrt_F64,
 			Operator::I32WrapI64 => Self::Wrap_I32_I64,
 			Operator::I32TruncF32S => Self::Trunc_I32_F32,
 			Operator::I32TruncF32U => Self::Trunc_U32_F32,
@@ -307,13 +328,20 @@ pub enum BinOpType {
 	ShrU_I64,
 	Rotl_I64,
 	Rotr_I64,
-	Add_FN,
+	Add_F32,
-	Sub_FN,
+	Sub_F32,
-	Mul_FN,
+	Mul_F32,
-	Div_FN,
+	Div_F32,
-	Min_FN,
+	Min_F32,
-	Max_FN,
+	Max_F32,
-	Copysign_FN,
+	Copysign_F32,
+	Add_F64,
+	Sub_F64,
+	Mul_F64,
+	Div_F64,
+	Min_F64,
+	Max_F64,
+	Copysign_F64,
 }
 
 impl BinOpType {
@@ -350,13 +378,20 @@ impl BinOpType {
 			Self::ShrU_I64 => ("shr", "u64"),
 			Self::Rotl_I64 => ("rotl", "i64"),
 			Self::Rotr_I64 => ("rotr", "i64"),
-			Self::Add_FN => ("add", "num"),
+			Self::Add_F32 => ("add", "f32"),
-			Self::Sub_FN => ("sub", "num"),
+			Self::Sub_F32 => ("sub", "f32"),
-			Self::Mul_FN => ("mul", "num"),
+			Self::Mul_F32 => ("mul", "f32"),
-			Self::Div_FN => ("div", "num"),
+			Self::Div_F32 => ("div", "f32"),
-			Self::Min_FN => ("min", "num"),
+			Self::Min_F32 => ("min", "f32"),
-			Self::Max_FN => ("max", "num"),
+			Self::Max_F32 => ("max", "f32"),
-			Self::Copysign_FN => ("copysign", "num"),
+			Self::Copysign_F32 => ("copysign", "f32"),
+			Self::Add_F64 => ("add", "f64"),
+			Self::Sub_F64 => ("sub", "f64"),
+			Self::Mul_F64 => ("mul", "f64"),
+			Self::Div_F64 => ("div", "f64"),
+			Self::Min_F64 => ("min", "f64"),
+			Self::Max_F64 => ("max", "f64"),
+			Self::Copysign_F64 => ("copysign", "f64"),
 		}
 	}
 }
@@ -396,13 +431,20 @@ impl TryFrom<&Operator<'_>> for BinOpType {
 			Operator::I64ShrU => Self::ShrU_I64,
 			Operator::I64Rotl => Self::Rotl_I64,
 			Operator::I64Rotr => Self::Rotr_I64,
-			Operator::F32Add | Operator::F64Add => Self::Add_FN,
+			Operator::F32Add => Self::Add_F32,
-			Operator::F32Sub | Operator::F64Sub => Self::Sub_FN,
+			Operator::F32Sub => Self::Sub_F32,
-			Operator::F32Mul | Operator::F64Mul => Self::Mul_FN,
+			Operator::F32Mul => Self::Mul_F32,
-			Operator::F32Div | Operator::F64Div => Self::Div_FN,
+			Operator::F32Div => Self::Div_F32,
-			Operator::F32Min | Operator::F64Min => Self::Min_FN,
+			Operator::F32Min => Self::Min_F32,
-			Operator::F32Max | Operator::F64Max => Self::Max_FN,
+			Operator::F32Max => Self::Max_F32,
-			Operator::F32Copysign | Operator::F64Copysign => Self::Copysign_FN,
+			Operator::F32Copysign => Self::Copysign_F32,
+			Operator::F64Add => Self::Add_F64,
+			Operator::F64Sub => Self::Sub_F64,
+			Operator::F64Mul => Self::Mul_F64,
+			Operator::F64Div => Self::Div_F64,
+			Operator::F64Min => Self::Min_F64,
+			Operator::F64Max => Self::Max_F64,
+			Operator::F64Copysign => Self::Copysign_F64,
 			_ => {
 				return Err(());
 			}
@@ -435,12 +477,18 @@ pub enum CmpOpType {
 	LeU_I64,
 	GeS_I64,
 	GeU_I64,
-	Eq_FN,
+	Eq_F32,
-	Ne_FN,
+	Ne_F32,
-	Lt_FN,
+	Lt_F32,
-	Gt_FN,
+	Gt_F32,
-	Le_FN,
+	Le_F32,
-	Ge_FN,
+	Ge_F32,
+	Eq_F64,
+	Ne_F64,
+	Lt_F64,
+	Gt_F64,
+	Le_F64,
+	Ge_F64,
 }
 
 impl CmpOpType {
@@ -467,12 +515,18 @@ impl CmpOpType {
 			Self::LeU_I64 => ("le", "u64"),
 			Self::GeS_I64 => ("ge", "i64"),
 			Self::GeU_I64 => ("ge", "u64"),
-			Self::Eq_FN => ("eq", "num"),
+			Self::Eq_F32 => ("eq", "f32"),
-			Self::Ne_FN => ("ne", "num"),
+			Self::Ne_F32 => ("ne", "f32"),
-			Self::Lt_FN => ("lt", "num"),
+			Self::Lt_F32 => ("lt", "f32"),
-			Self::Gt_FN => ("gt", "num"),
+			Self::Gt_F32 => ("gt", "f32"),
-			Self::Le_FN => ("le", "num"),
+			Self::Le_F32 => ("le", "f32"),
-			Self::Ge_FN => ("ge", "num"),
+			Self::Ge_F32 => ("ge", "f32"),
+			Self::Eq_F64 => ("eq", "f64"),
+			Self::Ne_F64 => ("ne", "f64"),
+			Self::Lt_F64 => ("lt", "f64"),
+			Self::Gt_F64 => ("gt", "f64"),
+			Self::Le_F64 => ("le", "f64"),
+			Self::Ge_F64 => ("ge", "f64"),
 		}
 	}
 }
@@ -502,12 +556,18 @@ impl TryFrom<&Operator<'_>> for CmpOpType {
 			Operator::I64LeU => Self::LeU_I64,
 			Operator::I64GeS => Self::GeS_I64,
 			Operator::I64GeU => Self::GeU_I64,
-			Operator::F32Eq | Operator::F64Eq => Self::Eq_FN,
+			Operator::F32Eq => Self::Eq_F32,
-			Operator::F32Ne | Operator::F64Ne => Self::Ne_FN,
+			Operator::F32Ne => Self::Ne_F32,
-			Operator::F32Lt | Operator::F64Lt => Self::Lt_FN,
+			Operator::F32Lt => Self::Lt_F32,
-			Operator::F32Gt | Operator::F64Gt => Self::Gt_FN,
+			Operator::F32Gt => Self::Gt_F32,
-			Operator::F32Le | Operator::F64Le => Self::Le_FN,
+			Operator::F32Le => Self::Le_F32,
-			Operator::F32Ge | Operator::F64Ge => Self::Ge_FN,
+			Operator::F32Ge => Self::Ge_F32,
+			Operator::F64Eq => Self::Eq_F64,
+			Operator::F64Ne => Self::Ne_F64,
+			Operator::F64Lt => Self::Lt_F64,
+			Operator::F64Gt => Self::Gt_F64,
+			Operator::F64Le => Self::Le_F64,
+			Operator::F64Ge => Self::Ge_F64,
 			_ => {
 				return Err(());
 			}