[llvm] r322971 - [WebAssembly] Fix libcall signature lookup

Derek Schuff via llvm-commits llvm-commits at lists.llvm.org
Fri Jan 19 09:45:54 PST 2018


Author: dschuff
Date: Fri Jan 19 09:45:54 2018
New Revision: 322971

URL: http://llvm.org/viewvc/llvm-project?rev=322971&view=rev
Log:
[WebAssembly] Fix libcall signature lookup

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.

Differential Revision: https://reviews.llvm.org/D42271

Added:
    llvm/trunk/test/CodeGen/WebAssembly/libcalls.ll
Modified:
    llvm/trunk/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp

Modified: llvm/trunk/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp?rev=322971&r1=322970&r2=322971&view=diff
==============================================================================
--- llvm/trunk/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp (original)
+++ llvm/trunk/lib/Target/WebAssembly/WebAssemblyRuntimeLibcallSignatures.cpp Fri Jan 19 09:45:54 2018
@@ -296,9 +296,12 @@ struct RuntimeLibcallSignatureTable {
     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;
@@ -455,26 +458,24 @@ struct RuntimeLibcallSignatureTable {
   }
 };
 
-
-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;                     \
+  }
+#include "llvm/CodeGen/RuntimeLibcalls.def"
 #undef HANDLE_LIBCALL
   }
 };
 
-ManagedStatic<RuntimeLibcallSignatureTable> RuntimeLibcallSignatures;
-
 } // end anonymous namespace
 
 

Added: llvm/trunk/test/CodeGen/WebAssembly/libcalls.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/CodeGen/WebAssembly/libcalls.ll?rev=322971&view=auto
==============================================================================
--- llvm/trunk/test/CodeGen/WebAssembly/libcalls.ll (added)
+++ llvm/trunk/test/CodeGen/WebAssembly/libcalls.ll Fri Jan 19 09:45:54 2018
@@ -0,0 +1,107 @@
+; 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 at FUNCTION
+ %a = call double @llvm.cos.f64(double %x)
+ ; CHECK: f64.call $push{{[0-9]}}=, log10 at 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
+}




More information about the llvm-commits mailing list