compiler: use the LLVM builtins everywhere

This gives some more optimization opportunities to LLVM, because it
understands these intrinsics. For example, it might convert
llvm.sqrt.f64 to llvm.sqrt.f32 if possible.

compiler/compiler.go

@@ -1657,10 +1657,7 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 		name := fn.RelString(nil)
 		switch {
 		case name == "math.Ceil" || name == "math.Floor" || name == "math.Sqrt" || name == "math.Trunc":
-			result, ok := b.createMathOp(instr)
-			if ok {
-				return result, nil
-			}
+			return b.createMathOp(instr), nil
 		case name == "device.Asm" || name == "device/arm.Asm" || name == "device/arm64.Asm" || name == "device/avr.Asm" || name == "device/riscv.Asm":
 			return b.createInlineAsm(instr.Args)
 		case name == "device.AsmFull" || name == "device/arm.AsmFull" || name == "device/arm64.AsmFull" || name == "device/avr.AsmFull" || name == "device/riscv.AsmFull":

compiler/intrinsics.go

@@ -88,49 +88,25 @@ var mathToLLVMMapping = map[string]string{
 	"math.Trunc": "llvm.trunc.f64",
 }
 
-// createMathOp tries to lower the given call as a LLVM math intrinsic, if
-// possible. It returns the call result if possible, and a boolean whether it
-// succeeded. If it doesn't succeed, the architecture doesn't support the given
-// intrinsic.
-func (b *builder) createMathOp(call *ssa.CallCommon) (llvm.Value, bool) {
-	// Check whether this intrinsic is supported on the given GOARCH.
-	// If it is unsupported, this can have two reasons:
-	//
-	//  1. LLVM can expand the intrinsic inline (using float instructions), but
-	//     the result doesn't pass the tests of the math package.
-	//  2. LLVM cannot expand the intrinsic inline, will therefore lower it as a
-	//     libm function call, but the libm function call also fails the math
-	//     package tests.
-	//
-	// Whatever the implementation, it must pass the tests in the math package
-	// so unfortunately only the below intrinsic+architecture combinations are
-	// supported.
-	name := call.StaticCallee().RelString(nil)
-	switch name {
-	case "math.Ceil", "math.Floor", "math.Trunc":
-		if b.GOARCH != "wasm" && b.GOARCH != "arm64" {
-			return llvm.Value{}, false
-		}
-	case "math.Sqrt":
-		if b.GOARCH != "wasm" && b.GOARCH != "amd64" && b.GOARCH != "386" {
-			return llvm.Value{}, false
-		}
-	default:
-		return llvm.Value{}, false // only the above functions are supported.
+// createMathOp lowers the given call as a LLVM math intrinsic. It returns the
+// resulting value.
+func (b *builder) createMathOp(call *ssa.CallCommon) llvm.Value {
+	llvmName := mathToLLVMMapping[call.StaticCallee().RelString(nil)]
+	if llvmName == "" {
+		panic("unreachable: unknown math operation") // sanity check
 	}
-
-	llvmFn := b.mod.NamedFunction(mathToLLVMMapping[name])
+	llvmFn := b.mod.NamedFunction(llvmName)
 	if llvmFn.IsNil() {
 		// The intrinsic doesn't exist yet, so declare it.
 		// At the moment, all supported intrinsics have the form "double
 		// foo(double %x)" so we can hardcode the signature here.
 		llvmType := llvm.FunctionType(b.ctx.DoubleType(), []llvm.Type{b.ctx.DoubleType()}, false)
-		llvmFn = llvm.AddFunction(b.mod, mathToLLVMMapping[name], llvmType)
+		llvmFn = llvm.AddFunction(b.mod, llvmName, llvmType)
 	}
 	// Create a call to the intrinsic.
 	args := make([]llvm.Value, len(call.Args))
 	for i, arg := range call.Args {
 		args[i] = b.getValue(arg)
 	}
-	return b.CreateCall(llvmFn, args, ""), true
+	return b.CreateCall(llvmFn, args, "")
 }

compiler/testdata/intrinsics-cortex-m-qemu.ll

@@ -14,21 +14,23 @@ entry:
 ; Function Attrs: nounwind
 define hidden double @main.mySqrt(double %x, i8* %context) unnamed_addr #1 {
 entry:
-  %0 = call double @math.Sqrt(double %x, i8* undef) #2
+  %0 = call double @llvm.sqrt.f64(double %x)
   ret double %0
 }
 
-declare double @math.Sqrt(double, i8*) #0
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare double @llvm.sqrt.f64(double) #2
 
 ; Function Attrs: nounwind
 define hidden double @main.myTrunc(double %x, i8* %context) unnamed_addr #1 {
 entry:
-  %0 = call double @math.Trunc(double %x, i8* undef) #2
+  %0 = call double @llvm.trunc.f64(double %x)
   ret double %0
 }
 
-declare double @math.Trunc(double, i8*) #0
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare double @llvm.trunc.f64(double) #2
 
 attributes #0 = { "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
 attributes #1 = { nounwind "target-features"="+armv7-m,+hwdiv,+soft-float,+strict-align,+thumb-mode,-aes,-bf16,-cdecp0,-cdecp1,-cdecp2,-cdecp3,-cdecp4,-cdecp5,-cdecp6,-cdecp7,-crc,-crypto,-d32,-dotprod,-dsp,-fp-armv8,-fp-armv8d16,-fp-armv8d16sp,-fp-armv8sp,-fp16,-fp16fml,-fp64,-fpregs,-fullfp16,-hwdiv-arm,-i8mm,-lob,-mve,-mve.fp,-neon,-pacbti,-ras,-sb,-sha2,-vfp2,-vfp2sp,-vfp3,-vfp3d16,-vfp3d16sp,-vfp3sp,-vfp4,-vfp4d16,-vfp4d16sp,-vfp4sp" }
-attributes #2 = { nounwind }
+attributes #2 = { nofree nosync nounwind readnone speculatable willreturn }