[WebAssembly] Remove restriction on main name mangling

[sbc100]

Summary

Emscripten now handles/supports this new mode.

[sbc100]

• update

[sbc100]

Currently waiting on https://github.com/emscripten-core/emscripten/pull/17099 to land.

[sbc100]

• update

[sunfish]

llvm/lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

264

Why is this code going away? This isn't Emscripten-specific code.

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

264

Ah.. I was hoping we could delete these codepaths, but maybe not.. :(

[sbc100]

• revert parts

[sunfish]

clang/lib/CodeGen/CodeGenModule.cpp

6360

Can this use GA->setVisibility(GlobalValue::HiddenVisibility)? __main_void is an implementation detail, so in theory users shouldn't be setting interesting visibility attributes on it.

[sbc100]

clang/lib/CodeGen/CodeGenModule.cpp

6360

The caller main / __main_void could live in different shared library the main function itself.

IIRC the caller of main is normally something like crt1.o and it should be able to see __main_void if, and only if, it can see main. i.e. if should have the same visibility as main itself, no?

[sunfish]

clang/lib/CodeGen/CodeGenModule.cpp

6360

Typically crt1.o is linked into the same exe/dso as main, so it needs main to have external linkage, but it doesn't need main to have any particular visibility.

In Emscripten, is main being called from a different dso, or from JS following visibility rules for different dsos?

[sbc100]

clang/lib/CodeGen/CodeGenModule.cpp

6360

No, emscirpten is not different that respect. Typically main lives in the same DSO as crt1.o.

But it doesn't have to, and we have a few tests that check it can be in a separate dso.

[sbc100]

• feedback

[sbc100]

• rebase

[sbc100]

clang/lib/CodeGen/CodeGenModule.cpp

6360

Actually I think verified that setting this to hidden works for emscripten (at least the tests pass).

@sunfish.. do you know if you were relying on this symbols being marked as "used"?

clang/lib/AST/Mangle.cpp

 
 static CCMangling getCallingConvMangling(const ASTContext &Context,
                                          const NamedDecl *ND) {
   const TargetInfo &TI = Context.getTargetInfo();
   const llvm::Triple &Triple = TI.getTriple();
 
   // On wasm, the argc/argv form of "main" is renamed so that the startup code
   // can call it with the correct function signature.
-  // On Emscripten, users may be exporting "main" and expecting to call it
-  // themselves, so we can't mangle it.
-  if (Triple.isWasm() && !Triple.isOSEmscripten())
+  if (Triple.isWasm())
     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
       if (FD->isMain() && FD->hasPrototype() && FD->param_size() == 2)
         return CCM_WasmMainArgcArgv;
 
   if (!Triple.isOSWindows() || !Triple.isX86())
     return CCM_Other;
 
   if (Context.getLangOpts().CPlusPlus && !isExternC(ND) &&

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::Release() {
   CodeGenPGO(*this).setValueProfilingFlag(getModule());
   if (CoverageMapping)
     CoverageMapping->emit();
   if (CodeGenOpts.SanitizeCfiCrossDso) {
     CodeGenFunction(*this).EmitCfiCheckFail();
     CodeGenFunction(*this).EmitCfiCheckStub();
   }
   emitAtAvailableLinkGuard();
-  if (Context.getTargetInfo().getTriple().isWasm() &&
-      !Context.getTargetInfo().getTriple().isOSEmscripten()) {
+  if (Context.getTargetInfo().getTriple().isWasm())
     EmitMainVoidAlias();
-  }
 
   if (getTriple().isAMDGPU()) {
     // Emit reference of __amdgpu_device_library_preserve_asan_functions to
     // preserve ASAN functions in bitcode libraries.
     if (LangOpts.Sanitize.has(SanitizerKind::Address)) {
       auto *FT = llvm::FunctionType::get(VoidTy, {});
       auto *F = llvm::Function::Create(
           FT, llvm::GlobalValue::ExternalLinkage,

 }
 
 void CodeGenModule::EmitMainVoidAlias() {
   // In order to transition away from "__original_main" gracefully, emit an
   // alias for "main" in the no-argument case so that libc can detect when
   // new-style no-argument main is in used.
   if (llvm::Function *F = getModule().getFunction("main")) {
     if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
-        F->getReturnType()->isIntegerTy(Context.getTargetInfo().getIntWidth()))
-      addUsedGlobal(llvm::GlobalAlias::create("__main_void", F));
+        F->getReturnType()->isIntegerTy(Context.getTargetInfo().getIntWidth())) {
+      auto *GA = llvm::GlobalAlias::create("__main_void", F);
+      GA->setVisibility(llvm::GlobalValue::DefaultVisibility);
+    }
   }
 }
 
 /// Turns the given pointer into a constant.
 static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
                                           const void *Ptr) {
   uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
   llvm::Type *i64 = llvm::Type::getInt64Ty(Context);

llvm/lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

LLVM_DEBUG(dbgs() << "createWrapper: no wrapper needed: " << F->getName()
                       << "\n");
     Wrapper->eraseFromParent();
     return nullptr;
   }
   LLVM_DEBUG(dbgs() << "createWrapper: " << F->getName() << "\n");
   return Wrapper;
 }
 
-// Test whether a main function with type FuncTy should be rewritten to have
-// type MainTy.
-static bool shouldFixMainFunction(FunctionType *FuncTy, FunctionType *MainTy) {
-  // Only fix the main function if it's the standard zero-arg form. That way,
-  // the standard cases will work as expected, and users will see signature
-  // mismatches from the linker for non-standard cases.
-  return FuncTy->getReturnType() == MainTy->getReturnType() &&
-         FuncTy->getNumParams() == 0 &&
-         !FuncTy->isVarArg();
-}
-
 bool FixFunctionBitcasts::runOnModule(Module &M) {
   LLVM_DEBUG(dbgs() << "********** Fix Function Bitcasts **********\n");
 
-  Function *Main = nullptr;
-  CallInst *CallMain = nullptr;
   SmallVector<std::pair<CallBase *, Function *>, 0> Uses;
 
   // Collect all the places that need wrappers.
   for (Function &F : M) {
     // Skip to fix when the function is swiftcc because swiftcc allows
     // bitcast type difference for swiftself and swifterror.
     if (F.getCallingConv() == CallingConv::Swift)
       continue;
     findUses(&F, F, Uses);
-
-    // If we have a "main" function, and its type isn't
-    // "int main(int argc, char *argv[])", create an artificial call with it
-    // bitcasted to that type so that we generate a wrapper for it, so that
-    // the C runtime can call it.
-    if (F.getName() == "main") {
-      Main = &F;
-      LLVMContext &C = M.getContext();
-      Type *MainArgTys[] = {Type::getInt32Ty(C),
-                            PointerType::get(Type::getInt8PtrTy(C), 0)};
-      FunctionType *MainTy = FunctionType::get(Type::getInt32Ty(C), MainArgTys,
-                                               /*isVarArg=*/false);
-      if (shouldFixMainFunction(F.getFunctionType(), MainTy)) {
-        LLVM_DEBUG(dbgs() << "Found `main` function with incorrect type: "
-                          << *F.getFunctionType() << "\n");
-        Value *Args[] = {UndefValue::get(MainArgTys[0]),
-                         UndefValue::get(MainArgTys[1])};
-        Value *Casted =
-            ConstantExpr::getBitCast(Main, PointerType::get(MainTy, 0));
-        CallMain = CallInst::Create(MainTy, Casted, Args, "call_main");
-        Uses.push_back(std::make_pair(CallMain, &F));
-      }
-    }
   }
 
   DenseMap<std::pair<Function *, FunctionType *>, Function *> Wrappers;
 
   for (auto &UseFunc : Uses) {
     CallBase *CB = UseFunc.first;
     Function *F = UseFunc.second;
     FunctionType *Ty = CB->getFunctionType();
 
     auto Pair = Wrappers.insert(std::make_pair(std::make_pair(F, Ty), nullptr));
     if (Pair.second)
       Pair.first->second = createWrapper(F, Ty);
 
     Function *Wrapper = Pair.first->second;
     if (!Wrapper)
       continue;
 
     CB->setCalledOperand(Wrapper);
   }
 
-  // If we created a wrapper for main, rename the wrapper so that it's the
-  // one that gets called from startup.
-  if (CallMain) {
-    Main->setName("__original_main");
-    auto *MainWrapper =
-        cast<Function>(CallMain->getCalledOperand()->stripPointerCasts());
-    delete CallMain;
-    if (Main->isDeclaration()) {
-      // The wrapper is not needed in this case as we don't need to export
-      // it to anyone else.
-      MainWrapper->eraseFromParent();
-    } else {
-      // Otherwise give the wrapper the same linkage as the original main
-      // function, so that it can be called from the same places.
-      MainWrapper->setName("main");
-      MainWrapper->setLinkage(Main->getLinkage());
-      MainWrapper->setVisibility(Main->getVisibility());
-    }
-  }
-
   return true;
 }