[WebAssembly] Fix libcall signature lookup

[dschuff]

Summary

RuntimeLibcallSignatures previously manually initialized all the libcall
names into an array and searched it linearly for the first match to lookup
the corresponding index.
r322802 switched that to initializing a map keyed by the libcall name.
Neither of these approaches works correctly because some libcall numbers use
the same name on different platforms (e.g. the "l" suffixed functions
use f80 or f128 or ppcf128).

This change fixes that by ensuring that each name only goes into the map
once. It also adds tests.

[dschuff]

• fix build

[sbc100]

lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

468

No need for StringRefOrEmpty anymore since its already inside a null check?

[dschuff]

lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

468

Actually it is needed because the macro expands to Map.find(nullptr) and you can't construct a StringRef from nullptr. However I just double-checked that and discovered that I duplicated StringRef::withNullAsEmpty() so, switched to that 👍

[dschuff]

• use StringRef::withNullAsEmpty() and clang-format

lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

RuntimeLibcallSignatureTable() : Table(RTLIB::UNKNOWN_LIBCALL, unsupported) {
     Table[RTLIB::OLE_F64] = i32_func_f64_f64;
     Table[RTLIB::OLE_F128] = i32_func_i64_i64_i64_i64;
     Table[RTLIB::OGT_F32] = i32_func_f32_f32;
     Table[RTLIB::OGT_F64] = i32_func_f64_f64;
     Table[RTLIB::OGT_F128] = i32_func_i64_i64_i64_i64;
     Table[RTLIB::UO_F32] = i32_func_f32_f32;
     Table[RTLIB::UO_F64] = i32_func_f64_f64;
     Table[RTLIB::UO_F128] = i32_func_i64_i64_i64_i64;
-    Table[RTLIB::O_F32] = i32_func_f32_f32;
-    Table[RTLIB::O_F64] = i32_func_f64_f64;
-    Table[RTLIB::O_F128] = i32_func_i64_i64_i64_i64;
+    // O_FXX has the weird property that it uses the same libcall name as UO_FXX
+    // This breaks our name-based lookup. Fortunately only the UO family of
+    // libcalls appears to be actually used.
+    Table[RTLIB::O_F32] = unsupported;
+    Table[RTLIB::O_F64] = unsupported;
+    Table[RTLIB::O_F128] = unsupported;
 
     // Memory
     Table[RTLIB::MEMCPY] = iPTR_func_iPTR_iPTR_iPTR;
     Table[RTLIB::MEMSET] = iPTR_func_iPTR_i32_iPTR;
     Table[RTLIB::MEMMOVE] = iPTR_func_iPTR_iPTR_iPTR;
 
     // Element-wise Atomic memory
     // TODO: Fix these when we implement atomic support
RuntimeLibcallSignatureTable() : Table(RTLIB::UNKNOWN_LIBCALL, unsupported) {
     Table[RTLIB::ATOMIC_FETCH_NAND_1] = unsupported;
     Table[RTLIB::ATOMIC_FETCH_NAND_2] = unsupported;
     Table[RTLIB::ATOMIC_FETCH_NAND_4] = unsupported;
     Table[RTLIB::ATOMIC_FETCH_NAND_8] = unsupported;
     Table[RTLIB::ATOMIC_FETCH_NAND_16] = unsupported;
   }
 };
 
-
-StringRef StringRefOrEmpty(const char* arg) {
-  if (arg) return StringRef(arg);
-  return StringRef();
-}
+ManagedStatic<RuntimeLibcallSignatureTable> RuntimeLibcallSignatures;
 
 // Maps libcall names to their RTLIB::Libcall number. Builds the map in a
 // constructor for use with ManagedStatic
 struct StaticLibcallNameMap {
   StringMap<RTLIB::Libcall> Map;
   StaticLibcallNameMap() {
-#define HANDLE_LIBCALL(code, name) \
-    Map[StringRefOrEmpty(name)] = RTLIB::code;
-    #include "llvm/CodeGen/RuntimeLibcalls.def"
+#define HANDLE_LIBCALL(code, name)                                           \
+  if (name && RuntimeLibcallSignatures->Table[RTLIB::code] != unsupported) { \
+    assert(Map.find(StringRef::withNullAsEmpty(name)) == Map.end() &&        \
+           "duplicate libcall names in name map");                           \
+    Map[StringRef::withNullAsEmpty(name)] = RTLIB::code;                     \
+  }
 #undef HANDLE_LIBCALL
   }
 };
 
-ManagedStatic<RuntimeLibcallSignatureTable> RuntimeLibcallSignatures;
-
 } // end anonymous namespace
 
 
 
 void llvm::GetSignature(const WebAssemblySubtarget &Subtarget,
                         RTLIB::Libcall LC, SmallVectorImpl<wasm::ValType> &Rets,
                         SmallVectorImpl<wasm::ValType> &Params) {
   assert(Rets.empty());

test/CodeGen/WebAssembly/libcalls.ll

+; RUN: llc < %s -asm-verbose=false -disable-wasm-fallthrough-return-opt | FileCheck %s
+
+; Test a subset of compiler-rt/libm libcalls expected to be emitted by the wasm backend
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+declare fp128 @llvm.sqrt.f128(fp128)
+declare fp128 @llvm.floor.f128(fp128)
+declare fp128 @llvm.trunc.f128(fp128)
+declare fp128 @llvm.nearbyint.f128(fp128)
+declare fp128 @llvm.pow.f128(fp128, fp128)
+
+declare double @llvm.cos.f64(double)
+declare double @llvm.log10.f64(double)
+
+
+; CHECK-LABEL: fp128libcalls:
+define fp128 @fp128libcalls(fp128 %x, fp128 %y) {
+  ; compiler-rt call
+  ; CHECK: call __addtf3
+  %a = fadd fp128 %x, %y
+  ; CHECK: call __multf3
+  %b = fmul fp128 %a, %y
+  ; CHECK: call __divtf3
+  %c = fdiv fp128 %b, %y
+  ; libm calls
+  ; CHECK: call sqrtl
+  %d = call fp128 @llvm.sqrt.f128(fp128 %c)
+  ; CHECK: call floorl
+  %e = call fp128 @llvm.floor.f128(fp128 %d)
+  ; CHECK: call powl
+  %f = call fp128 @llvm.pow.f128(fp128 %e, fp128 %y)
+  ; CHECK: call truncl
+  %g = call fp128 @llvm.trunc.f128(fp128 %f)
+  ; CHECK: call nearbyintl
+  %h = call fp128 @llvm.nearbyint.f128(fp128 %g)
+  ret fp128 %h
+}
+
+; CHECK-LABEL: i128libcalls:
+define i128 @i128libcalls(i128 %x, i128 %y) {
+  ; Basic ops should be expanded
+  ; CHECK_NOT: call
+  %a = add i128 %x, %y
+  ; CHECK: call __multi3
+  %b = mul i128 %a, %y
+  ; CHECK: call __umodti3
+  %c = urem i128 %b, %y
+  ret i128 %c
+}
+
+; CHECK-LABEL: f64libcalls:
+define double @f64libcalls(double %x, double %y) {
+ ; CHECK: f64.call $push{{[0-9]}}=, cos@FUNCTION
+ %a = call double @llvm.cos.f64(double %x)
+ ; CHECK: f64.call $push{{[0-9]}}=, log10@FUNCTION
+ %b = call double @llvm.log10.f64(double %a)
+ ret double %b
+}
+
+; 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
+
+; CHECK-LABEL: unordd:
+define i1 @unordd(double %x, double %y) {
+ ; CHECK-NOT: call
+ ; CHECK: f64.ne
+ %a = fcmp uno double %x, %y
+ ; CHECK-NOT: call
+ ; CHECK: f64.eq
+ %b = fcmp ord double %x, %y
+ ; CHECK: i32.xor
+ %c = xor i1 %a, %b
+ ret i1 %c
+}
+
+; CHECK-LABEL: unordf:
+define i1 @unordf(float %x, float %y) {
+ ; CHECK-NOT: call
+ ; CHECK: f32.ne
+ %a = fcmp uno float %x, %y
+ ; CHECK-NOT: call
+ ; CHECK: f32.eq
+ %b = fcmp ord float %x, %y
+ ; CHECK: i32.xor
+ %c = xor i1 %a, %b
+ ret i1 %c
+}
+
+; CHECK-LABEL: unordt:
+define i1 @unordt(fp128 %x, fp128 %y) {
+ ; CHECK: i32.call $push[[CALL:[0-9]]]=, __unordtf2
+ ; CHECK-NEXT: i32.const $push[[ZERO:[0-9]+]]=, 0
+ ; CHECK-NEXT: i32.ne $push{{[0-9]}}=, $pop[[CALL]], $pop[[ZERO]]
+ %a = fcmp uno fp128 %x, %y
+ ret i1 %a
+}
+
+; CHECK-LABEL: ordt:
+define i1 @ordt(fp128 %x, fp128 %y) {
+ ; CHECK: i32.call $push[[CALL:[0-9]]]=, __unordtf2
+ ; CHECK-NEXT: i32.eqz $push{{[0-9]}}=, $pop[[CALL]]
+ %a = fcmp ord fp128 %x, %y
+ ret i1 %a
+}