[WebAssembly] Add frexp{f,l} libcall signatures

[dschuff]

Summary

The llvm.frexp.* family of intrinsics and their corresponding libcalls were
recently added, which means we need to know their signatures.

Fixed: https://github.com/llvm/llvm-project/issues/63657

[sbc100]

llvm/test/CodeGen/WebAssembly/libcalls.ll

261

How is llvm.frexp.f64.i32 implemented? Is it supposed to be the name of a function compiler-rt?

[dschuff]

llvm/test/CodeGen/WebAssembly/libcalls.ll

261

it's a libm function, like the other functions in this test. IIRC some of the libcalls might be compiler-rt, I'm not sure LLVM differentiates. Also the list of intrinsics doesn't really differentiate between ones that lower directly to libcalls and ones that don't, because it depends on the architecture (e.g. if there are instructions that map directly or not). In this case wasm doesn't really have a direct equivalent for frexp.

[sbc100]

llvm/test/CodeGen/WebAssembly/libcalls.ll

261

But how can libm implement a function called llvm.frexp.f64.i32.. wouldn't you need a name without periods in it if you want to be able to implement it in C?

261

The other callees here have names like __powidf2

[dschuff]

Fix test

[dschuff]

llvm/test/CodeGen/WebAssembly/libcalls.ll

261

Sorry, the target-independent lowering code translates the intrinsic (named @llvm.frexp.f64.i32 or @llvm.frexp.f32.i32) into a call to the library function (named frexp or frexpf).

Oh, but I see the problem here, the call in the generated code in this test is wrong! It looks like there was some kind of accident with update_llc_check_tests.py, I'm not sure what happened there. I fixed that

(Also yes, I missed __powidf2. I assume that one is a compiler-rt function)

[dschuff]

fix upload

llvm/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

RuntimeLibcallSignatureTable() : Table(RTLIB::UNKNOWN_LIBCALL, unsupported) {
     Table[RTLIB::FMIN_F64] = f64_func_f64_f64;
     Table[RTLIB::FMIN_F128] = i64_i64_func_i64_i64_i64_i64;
     Table[RTLIB::FMAX_F32] = f32_func_f32_f32;
     Table[RTLIB::FMAX_F64] = f64_func_f64_f64;
     Table[RTLIB::FMAX_F128] = i64_i64_func_i64_i64_i64_i64;
     Table[RTLIB::LDEXP_F32] = f32_func_f32_i32;
     Table[RTLIB::LDEXP_F64] = f64_func_f64_i32;
     Table[RTLIB::LDEXP_F128] = i64_i64_func_i64_i64_i32;
+    Table[RTLIB::FREXP_F32] = f32_func_f32_i32;
+    Table[RTLIB::FREXP_F64] = f64_func_f64_i32;
+    Table[RTLIB::FREXP_F128] = i64_i64_func_i64_i64_i32;
 
     // Conversion
     // All F80 and PPCF128 routines are unsupported.
     Table[RTLIB::FPEXT_F64_F128] = i64_i64_func_f64;
     Table[RTLIB::FPEXT_F32_F128] = i64_i64_func_f32;
     Table[RTLIB::FPEXT_F32_F64] = f64_func_f32;
     Table[RTLIB::FPEXT_F16_F32] = f32_func_i16;
     Table[RTLIB::FPROUND_F32_F16] = i16_func_f32;

llvm/test/CodeGen/WebAssembly/libcalls.ll

 
 declare double @llvm.cos.f64(double)
 declare double @llvm.log10.f64(double)
 declare double @llvm.pow.f64(double, double)
 declare double @llvm.powi.f64.i32(double, i32)
 declare double @llvm.log.f64(double)
 declare double @llvm.exp.f64(double)
 declare double @llvm.ldexp.f64.i32(double, i32)
+declare {double, i32} @llvm.frexp.f64.i32(double)
 declare i32 @llvm.lround(double)
 
+declare void @escape_value(i32)
+
 define fp128 @fp128libcalls(fp128 %x, fp128 %y, i32 %z) {
   ; compiler-rt call
 ; CHECK-LABEL: fp128libcalls:
 ; CHECK:         .functype fp128libcalls (i32, i64, i64, i64, i64, i32) -> ()
 ; CHECK-NEXT:    .local i32
 ; CHECK-NEXT:  # %bb.0:
 ; CHECK-NEXT:    global.get $push28=, __stack_pointer
 ; CHECK-NEXT:    i32.const $push29=, 144
; CHECK-NEXT:    return
   %b = mul i128 %a, %y
   %c = urem i128 %b, %y
   ret i128 %c
 }
 
 define double @f64libcalls(double %x, double %y, i32 %z) {
 ; CHECK-LABEL: f64libcalls:
 ; CHECK:         .functype f64libcalls (f64, f64, i32) -> (f64)
+; CHECK-NEXT:    .local i32
 ; CHECK-NEXT:  # %bb.0:
-; CHECK-NEXT:    local.get $push12=, 0
-; CHECK-NEXT:    local.get $push9=, 0
-; CHECK-NEXT:    call $push0=, cos, $pop9
+; CHECK-NEXT:    global.get $push10=, __stack_pointer
+; CHECK-NEXT:    i32.const $push11=, 16
+; CHECK-NEXT:    i32.sub $push15=, $pop10, $pop11
+; CHECK-NEXT:    local.tee $push14=, 3, $pop15
+; CHECK-NEXT:    global.set __stack_pointer, $pop14
+; CHECK-NEXT:    local.get $push20=, 3
+; CHECK-NEXT:    local.get $push19=, 0
+; CHECK-NEXT:    local.get $push16=, 0
+; CHECK-NEXT:    call $push0=, cos, $pop16
 ; CHECK-NEXT:    call $push1=, log10, $pop0
-; CHECK-NEXT:    local.get $push10=, 1
-; CHECK-NEXT:    call $push2=, pow, $pop1, $pop10
-; CHECK-NEXT:    local.get $push11=, 2
-; CHECK-NEXT:    call $push3=, __powidf2, $pop2, $pop11
+; CHECK-NEXT:    local.get $push17=, 1
+; CHECK-NEXT:    call $push2=, pow, $pop1, $pop17
+; CHECK-NEXT:    local.get $push18=, 2
+; CHECK-NEXT:    call $push3=, __powidf2, $pop2, $pop18
 ; CHECK-NEXT:    call $push4=, log, $pop3
 ; CHECK-NEXT:    call $push5=, exp, $pop4
 ; CHECK-NEXT:    call $push6=, cbrt, $pop5
 ; CHECK-NEXT:    call $push7=, lround, $pop6
-; CHECK-NEXT:    call $push8=, ldexp, $pop12, $pop7
-; CHECK-NEXT:    return $pop8
+; CHECK-NEXT:    call $push8=, ldexp, $pop19, $pop7
+; CHECK-NEXT:    call llvm.frexp.f64.i32, $pop20, $pop8
+; CHECK-NEXT:    local.get $push22=, 3
+; CHECK-NEXT:    f64.load $push21=, 0($pop22)
+; CHECK-NEXT:    local.set 0, $pop21
+; CHECK-NEXT:    local.get $push23=, 3
+; CHECK-NEXT:    i32.load $push9=, 8($pop23)
+; CHECK-NEXT:    call escape_value, $pop9
+; CHECK-NEXT:    local.get $push24=, 3
+; CHECK-NEXT:    i32.const $push12=, 16
+; CHECK-NEXT:    i32.add $push13=, $pop24, $pop12
+; CHECK-NEXT:    global.set __stack_pointer, $pop13
+; CHECK-NEXT:    local.get $push25=, 0
+; CHECK-NEXT:    return $pop25
+
+
  %a = call double @llvm.cos.f64(double %x)
  %b = call double @llvm.log10.f64(double %a)
  %c = call double @llvm.pow.f64(double %b, double %y)
  %d = call double @llvm.powi.f64.i32(double %c, i32 %z)
  %e = call double @llvm.log.f64(double %d)
  %f = call double @llvm.exp.f64(double %e)
  %g = call fast double @llvm.pow.f64(double %f, double 0x3FD5555555555555)
  %h = call i32 @llvm.lround(double %g)
  %i = call double @llvm.ldexp.f64.i32(double %x, i32 %h);
- ret double %i
+ %result = call {double, i32} @llvm.frexp.f64.i32(double %i)
+ %result.0 = extractvalue { double, i32 } %result, 0
+ %result.1 = extractvalue { double, i32 } %result, 1
+ call void @escape_value(i32 %result.1)
+ ret double %result.0
 }
 
 ; fcmp ord and unord (RTLIB::O_F32 / RTLIB::UO_F32 etc) are a special case (see
 ; comment in WebAssemblyRunimeLibcallSignatures.cpp) so check them separately.
 ; no libcalls are needed for f32 and f64
 
 define i1 @unordd(double %x, double %y) {
 ; CHECK-LABEL: unordd: