[WebAssembly] Add `wasm-exported` function attribute

[sbc100]

Summary

This matches the existing wasm-export-name attribute but exports that symbol
but its llvm symbol name. This corresponds directly to the existing
WASM_SYMBOL_EXPORTED symbol flag.

This allows the existing emscripten macro EMSCERIPTEN_KEEPALIVE to be
implemented in terms of this attribute rather then the current
workaround which uses overload the used attribute.

[kripken]

clang/include/clang/Basic/AttrDocs.td

5535

"the be" => "the function to be"

[sunfish]

Instead of creating a new LLVM-IR-level attribute here, could you have clang translate the attribute to "wasm-export-name", to keep the LLVM-IR level simpler?

Also, I myself would be more comfortable with this change if it were restricted to Emscripten for now. export_name already exists and works in both Emscripten and non-Emscripten targets. If there's demand for this new syntax outside of Emscripten, I'm happy to reconsider, but until then it seems better to be conservative. Obviously it's not possible to completely prevent people from becoming dependent on C++ ABI details, but we can avoid giving them tools that make it easy to do the wrong thing. And we can keep the ecosystem simpler if we don't have multiple ways to do the same thing.

[sbc100]

What about your idea of using the default keyword rather than adding a new clang attr? I quite liked that approach.

[sbc100]

I was thinking of dropping the new clang attr in favor of the default keyword in the current attr, but actually keeping the llvm attr, since it corresponds quite nicely to the existing EXPORTED symbol attribute in the binary format and avoid duplication in the .ll, .s and .o formats.

[sbc100]

• rebase

[sbc100]

In D76547#1945094, @sbc100 wrote:

What about your idea of using the default keyword rather than adding a new clang attr? I quite liked that approach.

IIRC I tried this approach but wan't able to make it works since a single attribute can't both take a string and a fix value like default.

[sbc100]

• update test

[sbc100]

I've limited to new attribute to only the emcripten triple.

[sbc100]

• limit to emscripten

[sbc100]

I just figured out that this cannot replace the current use of __attribute__((used)) in emscripten because function attributes only work for functions and we need this mechanism to work for global data addresses too. There is simply no way to do something like Fn->addFnAttr("wasm-exported"); for a GlobalValue that isn't a function (as far as I can tell).

[aaron.ballman]

The changes need a release note at some point, and this is missing all of the usual sema diagnostic tests (wrong subject, wrong number of args, wrong target, etc).

That said, are we sure this attribute is sufficiently compelling to add it in the first place? This seems like an attribute needed for one? use case, but it's using a pretty general name for the attribute (exported). For example, it's not clear to me why this cannot be solved with the existing export_name attribute (e.g., __attribute__((export_name("foo"))) void foo();)

clang/include/clang/Basic/AttrDocs.td

5533–5536

I think more details would be helpful here. The docs for export_name:

WebAssembly functions are exported via string name. By default when a symbol is exported, the export name for C/C++ symbols are the same as their C/C++ symbol names. This attribute can be used to override the default behavior, and request a specific string name be used instead.

make it sound like there's already a way to export the symbol, so it's not clear to me why this attribute is needed (unless this attribute is actually the one intended to provide that functionality!).

Also, the docs don't mention important things like that this attribute only works for emscripten.

clang/lib/Sema/SemaDeclAttr.cpp

7561–7568

These can both be dropped, they're handled automatically for you.

7572

Is this diagnostic actually correct? It's for use with the alias and ifunc attributes, so I'm surprised to see it here.

clang/test/CodeGen/WebAssembly/wasm-exported.c

12

This should be handled in a sema test along with the other sema testing, rather than squirreled away here in the codegen tests.

[sbc100]

The reason __attribute__((export_name("foo"))) doesn't work in all use cases is that we have a lot of existing code that uses the EMSCRIPTEN_KEEPALIVE macro. We also have run into other folks who want to include this is some kind of FOO_API, or EXPORT_API type macros. Its not possible to have such a macro map to the existing export_name since they don't include the symbol name: e.g:

EMSCRIPTEN_KEEPALIVE int foo();`

JNI_EXPORT int myfunct();

In these cases we need something that uses the llvm symbol name for the export.

However, as I mention in my earlier comment I have since realized that these attributes cannot be applies the llvm GlobalValues in general only the Functions... and the idea behind EMSCRIPTEN_KEEPALIVE is that it can be used to tag both functions and data symbols (addresses).

Sadly I don't see any way to attach attributes to data symbols in llvm today.. we have visibility but not attribute bag :(

clang/lib/Sema/SemaDeclAttr.cpp

7572

It does look incorrect yes, this is copy-pasted from the exist ExportNameAttr so I guess that is wrong too.

[aaron.ballman]

In D76547#4231422, @sbc100 wrote:

The reason __attribute__((export_name("foo"))) doesn't work in all use cases is that we have a lot of existing code that uses the EMSCRIPTEN_KEEPALIVE macro. We also have run into other folks who want to include this is some kind of FOO_API, or EXPORT_API type macros. Its not possible to have such a macro map to the existing export_name since they don't include the symbol name: e.g:

EMSCRIPTEN_KEEPALIVE int foo();`

JNI_EXPORT int myfunct();

In these cases we need something that uses the llvm symbol name for the export.

I think there's two ways we could address this without adding a new attribute (maybe you've thought of this and have reasons for this to be a bad suggestion):

• It seems that export_name doesn't care if you put in an empty string for the argument, so we could treat that case as meaning "export with the name of the symbol this attribute is attached to"
• We could allow export_name to take zero or one argument. The one-argument form is the same as it is today, but the zero argument form exports with the name of the symbol the attribute is attached to.

Do you think either of those could work?

[sbc100]

In D76547#4231476, @aaron.ballman wrote:

In D76547#4231422, @sbc100 wrote:

The reason __attribute__((export_name("foo"))) doesn't work in all use cases is that we have a lot of existing code that uses the EMSCRIPTEN_KEEPALIVE macro. We also have run into other folks who want to include this is some kind of FOO_API, or EXPORT_API type macros. Its not possible to have such a macro map to the existing export_name since they don't include the symbol name: e.g:

EMSCRIPTEN_KEEPALIVE int foo();`

JNI_EXPORT int myfunct();

In these cases we need something that uses the llvm symbol name for the export.

I think there's two ways we could address this without adding a new attribute (maybe you've thought of this and have reasons for this to be a bad suggestion):

• It seems that export_name doesn't care if you put in an empty string for the argument, so we could treat that case as meaning "export with the name of the symbol this attribute is attached to"
• We could allow export_name to take zero or one argument. The one-argument form is the same as it is today, but the zero argument form exports with the name of the symbol the attribute is attached to.

Do you think either of those could work?

Yes, I think the second one would be ideal. The first one is slightly less idea because it prevents something being exported with the empty string as its name (wasm allows such things).

Can an attribute take an optional argument? That would be great solution. For my initial version of this change I did look into making export_name(DEFAULT) work (note the lack of quotes around the word DEFAULT here), but I could not find way to make a single attribute take both a string *or* a constant.

[aaron.ballman]

In D76547#4231501, @sbc100 wrote:

In D76547#4231476, @aaron.ballman wrote:

In D76547#4231422, @sbc100 wrote:

The reason __attribute__((export_name("foo"))) doesn't work in all use cases is that we have a lot of existing code that uses the EMSCRIPTEN_KEEPALIVE macro. We also have run into other folks who want to include this is some kind of FOO_API, or EXPORT_API type macros. Its not possible to have such a macro map to the existing export_name since they don't include the symbol name: e.g:

EMSCRIPTEN_KEEPALIVE int foo();`

JNI_EXPORT int myfunct();

In these cases we need something that uses the llvm symbol name for the export.

I think there's two ways we could address this without adding a new attribute (maybe you've thought of this and have reasons for this to be a bad suggestion):

• It seems that export_name doesn't care if you put in an empty string for the argument, so we could treat that case as meaning "export with the name of the symbol this attribute is attached to"
• We could allow export_name to take zero or one argument. The one-argument form is the same as it is today, but the zero argument form exports with the name of the symbol the attribute is attached to.

Do you think either of those could work?

Yes, I think the second one would be ideal. The first one is slightly less idea because it prevents something being exported with the empty string as its name (wasm allows such things).

Ah, yeah, that's a good reason to avoid the first one.

Can an attribute take an optional argument? That would be great solution. For my initial version of this change I did look into making export_name(DEFAULT) work (note the lack of quotes around the word DEFAULT here), but I could not find way to make a single attribute take both a string *or* a constant.

Yup, it takes only a little bit of extra work to do right. Have the attribute's argument list take a VariadicStringArgument instead of StringArgument so you can pass zero or more arguments, then have the attribute handler in SemaDeclAttr.cpp diagnose if the attribute is given > 1 argument. The rest should be things like documentation or fall out somewhat naturally (there will be accessors added to the WebAssemblyExportNameAttr class that let you access the arguments with iterators, and a size accessor as well, so you can tell if the semantic attribute does/does not have an argument).

[sbc100]

In D76547#4231604, @aaron.ballman wrote:

In D76547#4231501, @sbc100 wrote:

In D76547#4231476, @aaron.ballman wrote:

In D76547#4231422, @sbc100 wrote:

The reason __attribute__((export_name("foo"))) doesn't work in all use cases is that we have a lot of existing code that uses the EMSCRIPTEN_KEEPALIVE macro. We also have run into other folks who want to include this is some kind of FOO_API, or EXPORT_API type macros. Its not possible to have such a macro map to the existing export_name since they don't include the symbol name: e.g:

EMSCRIPTEN_KEEPALIVE int foo();`

JNI_EXPORT int myfunct();

In these cases we need something that uses the llvm symbol name for the export.

I think there's two ways we could address this without adding a new attribute (maybe you've thought of this and have reasons for this to be a bad suggestion):

• It seems that export_name doesn't care if you put in an empty string for the argument, so we could treat that case as meaning "export with the name of the symbol this attribute is attached to"
• We could allow export_name to take zero or one argument. The one-argument form is the same as it is today, but the zero argument form exports with the name of the symbol the attribute is attached to.

Do you think either of those could work?

Yes, I think the second one would be ideal. The first one is slightly less idea because it prevents something being exported with the empty string as its name (wasm allows such things).

Ah, yeah, that's a good reason to avoid the first one.

Can an attribute take an optional argument? That would be great solution. For my initial version of this change I did look into making export_name(DEFAULT) work (note the lack of quotes around the word DEFAULT here), but I could not find way to make a single attribute take both a string *or* a constant.

Yup, it takes only a little bit of extra work to do right. Have the attribute's argument list take a VariadicStringArgument instead of StringArgument so you can pass zero or more arguments, then have the attribute handler in SemaDeclAttr.cpp diagnose if the attribute is given > 1 argument. The rest should be things like documentation or fall out somewhat naturally (there will be accessors added to the WebAssemblyExportNameAttr class that let you access the arguments with iterators, and a size accessor as well, so you can tell if the semantic attribute does/does not have an argument).

Thanks! Closing this one for now then.

clang/include/clang/Basic/Attr.td

 def TargetMips32 : TargetArch<["mips", "mipsel"]>;
 def TargetAnyMips : TargetArch<["mips", "mipsel", "mips64", "mips64el"]>;
 def TargetMSP430 : TargetArch<["msp430"]>;
 def TargetM68k : TargetArch<["m68k"]>;
 def TargetRISCV : TargetArch<["riscv32", "riscv64"]>;
 def TargetX86 : TargetArch<["x86"]>;
 def TargetAnyX86 : TargetArch<["x86", "x86_64"]>;
 def TargetWebAssembly : TargetArch<["wasm32", "wasm64"]>;
+def TargetEmscripten : TargetSpec {
+  let Arches = ["wasm32", "wasm64"];
+  let OSes = ["Emscripten"];
+}
 def TargetWindows : TargetSpec {
   let OSes = ["Win32"];
 }
 def TargetHasDLLImportExport : TargetSpec {
   let CustomCode = [{ Target.getTriple().hasDLLImportExport() }];
 }
 def TargetItaniumCXXABI : TargetSpec {
   let CustomCode = [{ Target.getCXXABI().isItaniumFamily() }];

 def WebAssemblyExportName : InheritableAttr,
                             TargetSpecificAttr<TargetWebAssembly> {
   let Spellings = [Clang<"export_name">];
   let Args = [StringArgument<"ExportName">];
   let Documentation = [WebAssemblyExportNameDocs];
   let Subjects = SubjectList<[Function], ErrorDiag>;
 }
 
+def WebAssemblyExported : InheritableAttr,
+                          TargetSpecificAttr<TargetEmscripten> {
+  let Spellings = [Clang<"exported">];
+  let Documentation = [WebAssemblyExportedDocs];
+  let Subjects = SubjectList<[Function], ErrorDiag>;
+}
+
 def WebAssemblyImportModule : InheritableAttr,
                               TargetSpecificAttr<TargetWebAssembly> {
   let Spellings = [Clang<"import_module">];
   let Args = [StringArgument<"ImportModule">];
   let Documentation = [WebAssemblyImportModuleDocs];
   let Subjects = SubjectList<[Function], ErrorDiag>;
 }
 

clang/include/clang/Basic/AttrDocs.td

 
 WebAssembly functions are exported via string name. By default when a symbol
 is exported, the export name for C/C++ symbols are the same as their C/C++
 symbol names. This attribute can be used to override the default behavior, and
 request a specific string name be used instead.
   }];
 }
 
+def WebAssemblyExportedDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+Clang supports the ``__attribute__((exported))``
+attribute for the WebAssembly target. This attribute may be attached to a
+function declaration, where it causes the symbol to be exported from the
+linked WebAssembly module.
+  }];
+}
+
 def WebAssemblyImportModuleDocs : Documentation {
   let Category = DocCatFunction;
   let Content = [{
 Clang supports the ``__attribute__((import_module(<module_name>)))``
 attribute for the WebAssembly target. This attribute may be attached to a
 function declaration, where it modifies how the symbol is to be imported
 within the WebAssembly linking environment.
 

clang/lib/CodeGen/TargetInfo.cpp

explicit WebAssemblyTargetCodeGenInfo(CodeGen::CodeGenTypes &CGT,
     SwiftInfo =
         std::make_unique<SwiftABIInfo>(CGT, /*SwiftErrorInRegister=*/false);
   }
 
   void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV,
                            CodeGen::CodeGenModule &CGM) const override {
     TargetCodeGenInfo::setTargetAttributes(D, GV, CGM);
     if (const auto *FD = dyn_cast_or_null<FunctionDecl>(D)) {
-      if (const auto *Attr = FD->getAttr<WebAssemblyImportModuleAttr>()) {
-        llvm::Function *Fn = cast<llvm::Function>(GV);
+      if (const auto *Attr = FD->getAttr<WebAssemblyImportModuleAttr>()) {
         llvm::AttrBuilder B(GV->getContext());
         B.addAttribute("wasm-import-module", Attr->getImportModule());
         Fn->addFnAttrs(B);
       }
       if (const auto *Attr = FD->getAttr<WebAssemblyImportNameAttr>()) {
-        llvm::Function *Fn = cast<llvm::Function>(GV);
         llvm::AttrBuilder B(GV->getContext());
         B.addAttribute("wasm-import-name", Attr->getImportName());
         Fn->addFnAttrs(B);
       }
       if (const auto *Attr = FD->getAttr<WebAssemblyExportNameAttr>()) {
-        llvm::Function *Fn = cast<llvm::Function>(GV);
         llvm::AttrBuilder B(GV->getContext());
         B.addAttribute("wasm-export-name", Attr->getExportName());
         Fn->addFnAttrs(B);
       }
+      if (const auto *Attr = FD->getAttr<WebAssemblyExportedAttr>()) {
+        Fn->addFnAttr("wasm-exported");
+      }
     }
 
     if (auto *FD = dyn_cast_or_null<FunctionDecl>(D)) {
       llvm::Function *Fn = cast<llvm::Function>(GV);
       if (!FD->doesThisDeclarationHaveABody() && !FD->hasPrototype())
         Fn->addFnAttr("no-prototype");
     }
   }

clang/lib/Sema/SemaDeclAttr.cpp

static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   SourceLocation ArgLoc;
   if (!S.checkStringLiteralArgumentAttr(AL, 0, Str, &ArgLoc))
     return;
 
   D->addAttr(::new (S.Context) WebAssemblyExportNameAttr(S.Context, AL, Str));
   D->addAttr(UsedAttr::CreateImplicit(S.Context));
 }
 
+static void handleWebAssemblyExportedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
+  if (!isFunctionOrMethod(D)) {
+    S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type)
+        << "'exported'" << ExpectedFunction;
+    return;
+  }
+
+  if (S.Context.getTargetInfo().getTriple().isOSEmscripten()) {
+  }
+
+  auto *FD = cast<FunctionDecl>(D);
+  if (FD->isThisDeclarationADefinition()) {
+    S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;
+    return;
+  }
+
+  D->addAttr(::new (S.Context) WebAssemblyExportedAttr(S.Context, AL));
+  D->addAttr(UsedAttr::CreateImplicit(S.Context));
+}
+
 WebAssemblyImportModuleAttr *
 Sema::mergeImportModuleAttr(Decl *D, const WebAssemblyImportModuleAttr &AL) {
   auto *FD = cast<FunctionDecl>(D);
 
   if (const auto *ExistingAttr = FD->getAttr<WebAssemblyImportModuleAttr>()) {
     if (ExistingAttr->getImportModule() == AL.getImportModule())
       return nullptr;
     Diag(ExistingAttr->getLocation(), diag::warn_mismatched_import) << 0
case ParsedAttr::AT_BPFPreserveAccessIndex:
     handleBPFPreserveAccessIndexAttr(S, D, AL);
     break;
   case ParsedAttr::AT_BTFDeclTag:
     handleBTFDeclTagAttr(S, D, AL);
     break;
   case ParsedAttr::AT_WebAssemblyExportName:
     handleWebAssemblyExportNameAttr(S, D, AL);
     break;
+  case ParsedAttr::AT_WebAssemblyExported:
+    handleWebAssemblyExportedAttr(S, D, AL);
+    break;
   case ParsedAttr::AT_WebAssemblyImportModule:
     handleWebAssemblyImportModuleAttr(S, D, AL);
     break;
   case ParsedAttr::AT_WebAssemblyImportName:
     handleWebAssemblyImportNameAttr(S, D, AL);
     break;
   case ParsedAttr::AT_IBOutlet:
     handleIBOutlet(S, D, AL);

clang/test/CodeGen/WebAssembly/wasm-exported.c

+// RUN: %clang_cc1 -triple wasm32-unknown-emscripten -emit-llvm -o - %s | FileCheck %s
+//
+// This attribute is currently limited to `wasm32-unknown-emscripten`
+// RUN: not %clang_cc1 -Werror -triple wasm32-unknown-unknown -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefix=MISSING
+
+int __attribute__((exported)) foo(void);
+
+int foo(void) {
+  return 43;
+}
+
+// MISSING: error: unknown attribute 'exported' ignored
+
+// CHECK: @llvm.used = appending global [1 x ptr] [ptr @foo], section "llvm.metadata"
+
+// CHECK: define i32 @foo() [[A:#[0-9]+]]
+
+// CHECK: attributes [[A]] = {{{.*}} "wasm-exported" {{.*}}}

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

if (DirectiveID.getString() == ".functype") {
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       TOut.emitFunctionType(WasmSym);
       // TODO: backend also calls TOut.emitIndIdx, but that is not implemented.
       return expect(AsmToken::EndOfStatement, "EOL");
     }
 
+    if (DirectiveID.getString() == ".export") {
+      auto SymName = expectIdent();
+      if (SymName.empty())
+        return true;
+      auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));
+      WasmSym->setExported();
+      TOut.emitExport(WasmSym);
+    }
+
     if (DirectiveID.getString() == ".export_name") {
       auto SymName = expectIdent();
       if (SymName.empty())
         return true;
       if (expect(AsmToken::Comma, ","))
         return true;
       auto ExportName = expectIdent();
       auto WasmSym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(SymName));

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.h

public:
   virtual void emitImportModule(const MCSymbolWasm *Sym,
                                 StringRef ImportModule) = 0;
   /// .import_name
   virtual void emitImportName(const MCSymbolWasm *Sym,
                               StringRef ImportName) = 0;
   /// .export_name
   virtual void emitExportName(const MCSymbolWasm *Sym,
                               StringRef ExportName) = 0;
+  /// .export
+  virtual void emitExport(const MCSymbolWasm *Sym) = 0;
 
 protected:
   void emitValueType(wasm::ValType Type);
 };
 
 /// This part is for ascii assembly output
 class WebAssemblyTargetAsmStreamer final : public WebAssemblyTargetStreamer {
   formatted_raw_ostream &OS;
 
 public:
   WebAssemblyTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS);
 
   void emitLocal(ArrayRef<wasm::ValType> Types) override;
   void emitFunctionType(const MCSymbolWasm *Sym) override;
   void emitIndIdx(const MCExpr *Value) override;
   void emitGlobalType(const MCSymbolWasm *Sym) override;
   void emitTableType(const MCSymbolWasm *Sym) override;
   void emitTagType(const MCSymbolWasm *Sym) override;
   void emitImportModule(const MCSymbolWasm *Sym, StringRef ImportModule) override;
   void emitImportName(const MCSymbolWasm *Sym, StringRef ImportName) override;
   void emitExportName(const MCSymbolWasm *Sym, StringRef ExportName) override;
+  void emitExport(const MCSymbolWasm *Sym) override;
 };
 
 /// This part is for Wasm object output
 class WebAssemblyTargetWasmStreamer final : public WebAssemblyTargetStreamer {
 public:
   explicit WebAssemblyTargetWasmStreamer(MCStreamer &S);
 
   void emitLocal(ArrayRef<wasm::ValType> Types) override;
   void emitFunctionType(const MCSymbolWasm *Sym) override {}
   void emitIndIdx(const MCExpr *Value) override;
   void emitGlobalType(const MCSymbolWasm *Sym) override {}
   void emitTableType(const MCSymbolWasm *Sym) override {}
   void emitTagType(const MCSymbolWasm *Sym) override {}
   void emitImportModule(const MCSymbolWasm *Sym,
                         StringRef ImportModule) override {}
   void emitImportName(const MCSymbolWasm *Sym,
                       StringRef ImportName) override {}
   void emitExportName(const MCSymbolWasm *Sym,
                       StringRef ExportName) override {}
+  void emitExport(const MCSymbolWasm *Sym) override {}
 };
 
 /// This part is for null output
 class WebAssemblyTargetNullStreamer final : public WebAssemblyTargetStreamer {
 public:
   explicit WebAssemblyTargetNullStreamer(MCStreamer &S)
       : WebAssemblyTargetStreamer(S) {}
 
   void emitLocal(ArrayRef<wasm::ValType>) override {}
   void emitFunctionType(const MCSymbolWasm *) override {}
   void emitIndIdx(const MCExpr *) override {}
   void emitGlobalType(const MCSymbolWasm *) override {}
   void emitTableType(const MCSymbolWasm *) override {}
   void emitTagType(const MCSymbolWasm *) override {}
   void emitImportModule(const MCSymbolWasm *, StringRef) override {}
   void emitImportName(const MCSymbolWasm *, StringRef) override {}
   void emitExportName(const MCSymbolWasm *, StringRef) override {}
+  void emitExport(const MCSymbolWasm *) override {}
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

 }
 
 void WebAssemblyTargetAsmStreamer::emitExportName(const MCSymbolWasm *Sym,
                                                   StringRef ExportName) {
   OS << "\t.export_name\t" << Sym->getName() << ", "
                            << ExportName << '\n';
 }
 
+void WebAssemblyTargetAsmStreamer::emitExport(const MCSymbolWasm *Sym) {
+  OS << "\t.export\t" << Sym->getName() << '\n';
+}
+
 void WebAssemblyTargetAsmStreamer::emitIndIdx(const MCExpr *Value) {
   OS << "\t.indidx  \t" << *Value << '\n';
 }
 
 void WebAssemblyTargetWasmStreamer::emitLocal(ArrayRef<wasm::ValType> Types) {
   SmallVector<std::pair<wasm::ValType, uint32_t>, 4> Grouped;
   for (auto Type : Types) {
     if (Grouped.empty() || Grouped.back().first != Type)

llvm/lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp

if (F.hasFnAttribute("wasm-import-name")) {
       StringRef Name =
           InvokeDetected
               ? Sym->getName()
               : F.getFnAttribute("wasm-import-name").getValueAsString();
       Sym->setImportName(storeName(Name));
       getTargetStreamer()->emitImportName(Sym, Name);
     }
 
+    if (F.hasFnAttribute("wasm-exported")) {
+      auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
+      Sym->setExported();
+      getTargetStreamer()->emitExport(Sym);
+    }
+
     if (F.hasFnAttribute("wasm-export-name")) {
       auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
       StringRef Name = F.getFnAttribute("wasm-export-name").getValueAsString();
       Sym->setExportName(storeName(Name));
       getTargetStreamer()->emitExportName(Sym, Name);
     }
   }
 }

llvm/test/CodeGen/WebAssembly/export.ll

+; RUN: llc < %s -asm-verbose=false -wasm-keep-registers | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-emscripten"
+
+define void @test() #0 {
+  ret void
+}
+
+declare void @test2() #1
+
+attributes #0 = { "wasm-exported" }
+attributes #1 = { "wasm-exported" }
+
+; CHECK: .export test
+; CHECK: .export test2