declare types for functions which may not have a use, so that asm2wasm can infer their type (e.g. they may only be in a table, but never called)

Author: kripken

lib/Target/JSBackend/JSBackend.cpp

@@ -233,6 +233,7 @@ namespace {
     BlockAddressMap BlockAddresses;
     std::map<std::string, AsmConstInfo> AsmConsts; // code => { index, list of seen sigs }
     NameSet FuncRelocatableExterns; // which externals are accessed in this function; we load them once at the beginning (avoids a potential call in a heap access, and might be faster)
+    std::set<const Function*> DeclaresNeedingTypeDeclarations; // list of declared funcs whose type we must declare asm.js-style with a usage, as they may not have another usage
 
     struct {
       // 0 is reserved for void type
@@ -434,6 +435,14 @@ namespace {
         (this->*(CH->second))(NULL, Name, -1);
       }
 
+      // and in asm.js, types are inferred from use. so if we have a method that *only* appears in a table, it therefore has no use,
+      // and we are in trouble; emit a fake dce-able use for it.
+      if (WebAssembly) {
+        if (F->isDeclaration()) {
+          DeclaresNeedingTypeDeclarations.insert(F);
+        }
+      }
+
       return Index;
     }
 
@@ -701,6 +710,7 @@ namespace {
     /// Like getPtrUse(), but for pointers represented in string expression form.
     static std::string getHeapAccess(const std::string& Name, unsigned Bytes, bool Integer=true);
 
+    std::string getUndefValue(Type* T, AsmCast sign=ASM_SIGNED);
     std::string getConstant(const Constant*, AsmCast sign=ASM_SIGNED);
     template<typename VectorType/*= ConstantVector or ConstantDataVector*/>
     std::string getConstantVector(const VectorType *C);
@@ -1464,6 +1474,23 @@ std::string JSWriter::getPtrUse(const Value* Ptr) {
   return std::string(HeapName) + '[' + Index + ']';
 }
 
+std::string JSWriter::getUndefValue(Type* T, AsmCast sign) {
+  std::string S;
+  if (VectorType *VT = dyn_cast<VectorType>(T)) {
+    checkVectorType(VT);
+    S = std::string("SIMD_") + SIMDType(VT) + "_splat(" + ensureFloat("0", !VT->getElementType()->isIntegerTy()) + ')';
+  } else {
+    if (OnlyWebAssembly && T->isIntegerTy() && T->getIntegerBitWidth() == 64) {
+      return "i64(0)"; 
+    }
+    S = T->isFloatingPointTy() ? "+0" : "0"; // XXX refactor this
+    if (PreciseF32 && T->isFloatTy() && !(sign & ASM_FFI_OUT)) {
+      S = "Math_fround(" + S + ")";
+    }
+  }
+  return S;
+}
+
 std::string JSWriter::getConstant(const Constant* CV, AsmCast sign) {
   if (isa<ConstantPointerNull>(CV)) return "0";
 
@@ -1516,20 +1543,7 @@ std::string JSWriter::getConstant(const Constant* CV, AsmCast sign) {
       return emitI64Const(CI->getValue());
     }
   } else if (isa<UndefValue>(CV)) {
-    std::string S;
-    if (VectorType *VT = dyn_cast<VectorType>(CV->getType())) {
-      checkVectorType(VT);
-      S = std::string("SIMD_") + SIMDType(VT) + "_splat(" + ensureFloat("0", !VT->getElementType()->isIntegerTy()) + ')';
-    } else {
-      if (OnlyWebAssembly && CV->getType()->isIntegerTy() && CV->getType()->getIntegerBitWidth() == 64) {
-        return "i64(0)"; 
-      }
-      S = CV->getType()->isFloatingPointTy() ? "+0" : "0"; // XXX refactor this
-      if (PreciseF32 && CV->getType()->isFloatTy() && !(sign & ASM_FFI_OUT)) {
-        S = "Math_fround(" + S + ")";
-      }
-    }
-    return S;
+    return getUndefValue(CV->getType(), sign);
   } else if (isa<ConstantAggregateZero>(CV)) {
     if (VectorType *VT = dyn_cast<VectorType>(CV->getType())) {
       checkVectorType(VT);
@@ -3397,6 +3411,29 @@ void JSWriter::printModuleBody() {
       Out << "}\n";
       Exports.push_back("__post_instantiate");
     }
+    if (DeclaresNeedingTypeDeclarations.size() > 0) {
+      Out << "function __emscripten_dceable_type_decls() {\n";
+      for (auto& Decl : DeclaresNeedingTypeDeclarations) {
+        std::string Call = getJSName(Decl) + "(";
+        bool First = true;
+        auto* FT = Decl->getFunctionType();
+        for (auto AI = FT->param_begin(), AE = FT->param_end(); AI != AE; ++AI) {
+          if (First) {
+            First = false;
+          } else {
+            Call += ", ";
+          }
+          Call += getUndefValue(*AI);
+        }
+        Call += ")";
+        Type *RT = FT->getReturnType();
+        if (!RT->isVoidTy()) {
+          Call = getCast(Call, RT);
+        }
+        Out << " " << Call << ";\n";
+      }
+      Out << "}\n";
+    }
   }
   Out << "// EMSCRIPTEN_END_FUNCTIONS\n\n";