Remove math usage of raw LLVM intrinsic prototypes

core/math/math_basic.odin

@@ -3,44 +3,110 @@ package math
 
 import "core:intrinsics"
 
-@(default_calling_convention="none")
+@(default_calling_convention="none", private="file")
 foreign _ {
 	@(link_name="llvm.sin.f16", require_results)
-	sin_f16 :: proc(θ: f16) -> f16 ---
+	_sin_f16 :: proc(θ: f16) -> f16 ---
 	@(link_name="llvm.sin.f32", require_results)
-	sin_f32 :: proc(θ: f32) -> f32 ---
+	_sin_f32 :: proc(θ: f32) -> f32 ---
 	@(link_name="llvm.sin.f64", require_results)
-	sin_f64 :: proc(θ: f64) -> f64 ---
+	_sin_f64 :: proc(θ: f64) -> f64 ---
 
 	@(link_name="llvm.cos.f16", require_results)
-	cos_f16 :: proc(θ: f16) -> f16 ---
+	_cos_f16 :: proc(θ: f16) -> f16 ---
 	@(link_name="llvm.cos.f32", require_results)
-	cos_f32 :: proc(θ: f32) -> f32 ---
+	_cos_f32 :: proc(θ: f32) -> f32 ---
 	@(link_name="llvm.cos.f64", require_results)
-	cos_f64 :: proc(θ: f64) -> f64 ---
+	_cos_f64 :: proc(θ: f64) -> f64 ---
 
 	@(link_name="llvm.pow.f16", require_results)
-	pow_f16 :: proc(x, power: f16) -> f16 ---
+	_pow_f16 :: proc(x, power: f16) -> f16 ---
 	@(link_name="llvm.pow.f32", require_results)
-	pow_f32 :: proc(x, power: f32) -> f32 ---
+	_pow_f32 :: proc(x, power: f32) -> f32 ---
 	@(link_name="llvm.pow.f64", require_results)
-	pow_f64 :: proc(x, power: f64) -> f64 ---
+	_pow_f64 :: proc(x, power: f64) -> f64 ---
 
 	@(link_name="llvm.fmuladd.f16", require_results)
-	fmuladd_f16 :: proc(a, b, c: f16) -> f16 ---
+	_fmuladd_f16 :: proc(a, b, c: f16) -> f16 ---
 	@(link_name="llvm.fmuladd.f32", require_results)
-	fmuladd_f32 :: proc(a, b, c: f32) -> f32 ---
+	_fmuladd_f32 :: proc(a, b, c: f32) -> f32 ---
 	@(link_name="llvm.fmuladd.f64", require_results)
-	fmuladd_f64 :: proc(a, b, c: f64) -> f64 ---
+	_fmuladd_f64 :: proc(a, b, c: f64) -> f64 ---
 
 	@(link_name="llvm.exp.f16", require_results)
-	exp_f16 :: proc(x: f16) -> f16 ---
+	_exp_f16 :: proc(x: f16) -> f16 ---
 	@(link_name="llvm.exp.f32", require_results)
-	exp_f32 :: proc(x: f32) -> f32 ---
+	_exp_f32 :: proc(x: f32) -> f32 ---
 	@(link_name="llvm.exp.f64", require_results)
-	exp_f64 :: proc(x: f64) -> f64 ---
+	_exp_f64 :: proc(x: f64) -> f64 ---
 }
 
+@(require_results)
+sin_f16 :: proc "contextless" (θ: f16) -> f16 {
+	return _sin_f16(θ)
+}
+@(require_results)
+sin_f32 :: proc "contextless" (θ: f32) -> f32 {
+	return _sin_f32(θ)
+}
+@(require_results)
+sin_f64 :: proc "contextless" (θ: f64) -> f64 {
+	return _sin_f64(θ)
+}
+
+@(require_results)
+cos_f16 :: proc "contextless" (θ: f16) -> f16 {
+	return _cos_f16(θ)
+}
+@(require_results)
+cos_f32 :: proc "contextless" (θ: f32) -> f32 {
+	return _cos_f32(θ)
+}
+@(require_results)
+cos_f64 :: proc "contextless" (θ: f64) -> f64 {
+	return _cos_f64(θ)
+}
+
+@(require_results)
+pow_f16 :: proc "contextless" (x, power: f16) -> f16 {
+	return _pow_f16(x, power)
+}
+@(require_results)
+pow_f32 :: proc "contextless" (x, power: f32) -> f32 {
+	return _pow_f32(x, power)
+}
+@(require_results)
+pow_f64 :: proc "contextless" (x, power: f64) -> f64 {
+	return _pow_f64(x, power)
+}
+
+@(require_results)
+fmuladd_f16 :: proc "contextless" (a, b, c: f16) -> f16 {
+	return _fmuladd_f16(a, b, c)
+}
+@(require_results)
+fmuladd_f32 :: proc "contextless" (a, b, c: f32) -> f32 {
+	return _fmuladd_f32(a, b, c)
+}
+@(require_results)
+fmuladd_f64 :: proc "contextless" (a, b, c: f64) -> f64 {
+	return _fmuladd_f64(a, b, c)
+}
+
+@(require_results)
+exp_f16 :: proc "contextless" (x: f16) -> f16 {
+	return _exp_f16(x)
+}
+@(require_results)
+exp_f32 :: proc "contextless" (x: f32) -> f32 {
+	return _exp_f32(x)
+}
+@(require_results)
+exp_f64 :: proc "contextless" (x: f64) -> f64 {
+	return _exp_f64(x)
+}
+
+
 @(require_results)
 sqrt_f16 :: proc "contextless" (x: f16) -> f16 {
 	return intrinsics.sqrt(x)