[WebAssembly] Mangle the argc/argv `main` as `__main_argc_argv`

[sunfish]

Summary

WebAssembly enforces a rule that caller and callee signatures must
match. This means that the traditional technique of passing main
argc and argv even when it doesn't need them doesn't work.

Currently the backend renames main to __original_main, however this
doesn't interact well with LTO'ing libc, and the name isn't intuitive.
This patch allows us to transition to __main_argc_argv instead.

This is currently being discussed in https://github.com/WebAssembly/tool-conventions/pull/134.

[sunfish]

This updates the main vs __main_argc_argv patch so that it doesn't apply to Emscripten targets, following the discussion in https://github.com/WebAssembly/tool-conventions/pull/134.

[sunfish]

To support a transition to the new system, temporarily define a __main_void alias for no-argument main. This allows libc to detect whether it's calling old-style or new-style main and do the right thing.

[sbc100]

wasm_argc_argv -> main_argc_argv in the title?

[sunfish]

@sbc100 Friendly ping :-).

[sbc100]

clang/lib/CodeGen/CodeGenModule.cpp

5589

Add a TODO to remove this once we remove the __original_main thing?

[sbc100]

Would you mind re-basing? I'd like to download and try this but it seems to have conflicts right now. (i'll do my best to resolve them you might do better).

clang/lib/AST/Mangle.cpp

 
 void MangleContext::anchor() { }
 
 enum CCMangling {
   CCM_Other,
   CCM_Fast,
   CCM_RegCall,
   CCM_Vector,
-  CCM_Std
+  CCM_Std,
+  CCM_WasmMainArgcArgv
 };
 
 static bool isExternC(const NamedDecl *ND) {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
     return FD->isExternC();
   return cast<VarDecl>(ND)->isExternC();
 }
 
 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 (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) &&
       TI.getCXXABI() == TargetCXXABI::Microsoft)
     return CCM_Other;
 
   const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND);
if (GlobalPrefix)
       Out << '\01'; // LLVM IR Marker for __asm("foo")
 
     Out << ALA->getLabel();
     return;
   }
 
   const ASTContext &ASTContext = getASTContext();
   CCMangling CC = getCallingConvMangling(ASTContext, D);
+
+  if (CC == CCM_WasmMainArgcArgv) {
+    Out << "__main_argc_argv";
+    return;
+  }
+
   bool MCXX = shouldMangleCXXName(D);
   const TargetInfo &TI = Context.getTargetInfo();
   if (CC == CCM_Other || (MCXX && TI.getCXXABI() == TargetCXXABI::Microsoft)) {
     if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(D))
       mangleObjCMethodName(OMD, Out);
     else
       mangleCXXName(D, Out);
     return;

clang/lib/CodeGen/CodeGenModule.h

public:
   /// Remove the deferred empty coverage mapping as this
   /// declaration is actually instrumented.
   void ClearUnusedCoverageMapping(const Decl *D);
 
   /// Emit all the deferred coverage mappings
   /// for the uninstrumented functions.
   void EmitDeferredUnusedCoverageMappings();
 
+  /// Emit an alias for "main" if it has no arguments (needed for wasm).
+  void EmitMainVoidAlias();
+
   /// Tell the consumer that this variable has been instantiated.
   void HandleCXXStaticMemberVarInstantiation(VarDecl *VD);
 
   /// If the declaration has internal linkage but is inside an
   /// extern "C" linkage specification, prepare to emit an alias for it
   /// to the expected name.
   template<typename SomeDecl>
   void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV);

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::Release() {
   EmitDeferredUnusedCoverageMappings();
   if (CoverageMapping)
     CoverageMapping->emit();
   if (CodeGenOpts.SanitizeCfiCrossDso) {
     CodeGenFunction(*this).EmitCfiCheckFail();
     CodeGenFunction(*this).EmitCfiCheckStub();
   }
   emitAtAvailableLinkGuard();
+  if (Context.getTargetInfo().getTriple().isWasm() &&
+      !Context.getTargetInfo().getTriple().isOSEmscripten()) {
+    EmitMainVoidAlias();
+  }
   emitLLVMUsed();
   if (SanStats)
     SanStats->finish();
 
   if (CodeGenOpts.Autolink &&
       (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
     EmitModuleLinkOptions();
   }
case Decl::ObjCMethod: {
       CodeGenPGO PGO(*this);
       GlobalDecl GD(cast<FunctionDecl>(D));
       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
                                   getFunctionLinkage(GD));
       break;
     }
     case Decl::CXXConstructor: {
       CodeGenPGO PGO(*this);
       GlobalDecl GD(cast<CXXConstructorDecl>(D), Ctor_Base);
       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
                                   getFunctionLinkage(GD));
       break;
     }
     case Decl::CXXDestructor: {
       CodeGenPGO PGO(*this);
       GlobalDecl GD(cast<CXXDestructorDecl>(D), Dtor_Base);
       PGO.emitEmptyCounterMapping(D, getMangledName(GD),
                                   getFunctionLinkage(GD));
       break;
     }
     default:
       break;
     };
   }
 }
 
+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));
+  }
+}
+
 /// 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);
   return llvm::ConstantInt::get(i64, PtrInt);
 }
 

clang/lib/Frontend/InitHeaderSearch.cpp

void InitHeaderSearch::AddDefaultIncludePaths(const LangOptions &Lang,
 
   case llvm::Triple::Win32:
     if (triple.getEnvironment() != llvm::Triple::Cygnus ||
         triple.isOSBinFormatMachO())
       return;
     break;
 
   case llvm::Triple::UnknownOS:
-    if (triple.getArch() == llvm::Triple::wasm32 ||
-        triple.getArch() == llvm::Triple::wasm64)
+    if (triple.isWasm())
       return;
     break;
   }
 
   // All header search logic is handled in the Driver for Darwin.
   if (triple.isOSDarwin()) {
     if (HSOpts.UseStandardSystemIncludes) {
       // Add the default framework include paths on Darwin.

clang/test/CodeGen/wasm-call-main.c

+// RUN: %clang_cc1 -triple wasm32 -o - -emit-llvm %s | FileCheck %s
+
+// Mangle argc/argv main even when it's not defined in this TU.
+
+#include <stddef.h>
+
+int main(int argc, char *argv[]);
+
+int foo(void) {
+    return main(0, NULL);
+}
+
+// CHECK: call i32 @__main_argc_argv(

clang/test/CodeGen/wasm-main.c

+// RUN: %clang_cc1 -triple wasm32 -o - -emit-llvm %s | FileCheck %s
+
+// Don't mangle the no-arg form of main.
+
+int main(void) {
+  return 0;
+}
+
+// CHECK-LABEL: define i32 @main()

clang/test/CodeGen/wasm-main_argc_argv.c

+// RUN: %clang_cc1 -triple wasm32 -o - -emit-llvm %s | FileCheck %s
+
+// Mangle the argc/argv form of main.
+
+int main(int argc, char **argv) {
+  return 0;
+}
+
+// CHECK-LABEL: define i32 @__main_argc_argv(i32 %argc, i8** %argv)