[WebAssembly] Add --[no]-export-dynamic to replace --export-default

[sbc100]

Summary

In a very recent change I introduced a --no-export-default flag
but after conferring with others it seems that this feature already
exists in gnu GNU ld and lld in the form the --export-dynamic flag
which is off by default.

This change replaced export-default with export-dynamic and also
changes the default to match the traditional linker behaviour.

Now, by default only the entry point is exported. If other symbols
are required by the embedder then --export-dynamic or --export can
be used to export either all visibility hidden symbols or individual
symbols respectively.

This change touches a lot of tests that were relying on synmbols
being exported by default. I imagine it will also effect many
users but do think the change is worth it match of the traditional
behaviour and flag names.

[ruiu]

LGTM

wasm/Driver.cpp

477 ↗

(On Diff #167230)

nit: synthetic

lld/trunk/test/wasm/alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
-; RUN: wasm-ld %t.o -o %t.wasm
+; RUN: wasm-ld --export=start_alias %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @start_alias = alias void (), void ()* @_start
 
 ; Function Attrs: nounwind uwtable
 define void @_start() local_unnamed_addr #1 {

lld/trunk/test/wasm/archive-export.ll

 Test that --export will also fetch lazy symbols from archives
 
 RUN: llc -filetype=obj %S/Inputs/start.ll -o %t.o
 RUN: llc -filetype=obj %S/Inputs/archive1.ll -o %t.a1.o
 RUN: llc -filetype=obj %S/Inputs/archive2.ll -o %t.a2.o
 RUN: rm -f %t.a
 RUN: llvm-ar rcs %t.a %t.a1.o %t.a2.o
-RUN: wasm-ld --export=archive2_symbol -o %t.wasm %t.a %t.o
+RUN: wasm-ld --export-dynamic --export=archive2_symbol -o %t.wasm %t.a %t.o
 RUN: obj2yaml %t.wasm | FileCheck %s
-RUN: wasm-ld -o %t.wasm %t.a %t.o
+RUN: wasm-ld --export-dynamic -o %t.wasm %t.a %t.o
 RUN: obj2yaml %t.wasm | FileCheck %s -check-prefix=NOEXPORT
 
 CHECK:         Exports:
 CHECK-NEXT:       - Name:            memory
 CHECK-NEXT:         Kind:            MEMORY
 CHECK-NEXT:         Index:           0
 CHECK-NEXT:       - Name:            __heap_base
 CHECK-NEXT:         Kind:            GLOBAL

lld/trunk/test/wasm/call-indirect.ll

 ; RUN: llc -filetype=obj %p/Inputs/call-indirect.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld -o %t.wasm %t2.o %t.o
+; RUN: wasm-ld --export-dynamic -o %t.wasm %t2.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; bitcode generated from the following C code:
 ; int foo(void) { return 1; }
 ; int (*indirect_func)(void) = &foo;
 ; void _start(void) { indirect_func(); }
 
 target triple = "wasm32-unknown-unknown"

lld/trunk/test/wasm/comdats.ll

 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat1.ll -o %t1.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %p/Inputs/comdat2.ll -o %t2.o
 ; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %s -o %t.o
-; RUN: wasm-ld -o %t.wasm %t.o %t1.o %t2.o
+; RUN: wasm-ld --export-dynamic -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @inlineFn()
 
 define void @_start() local_unnamed_addr {
 entry:

lld/trunk/test/wasm/compress-relocs.ll

 ; RUN: llc -filetype=obj %p/Inputs/call-indirect.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld -o %t.wasm %t2.o %t.o
+; RUN: wasm-ld --export-dynamic -o %t.wasm %t2.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
-; RUN: wasm-ld -O2 -o %t-opt.wasm %t2.o %t.o
+; RUN: wasm-ld --export-dynamic -O2 -o %t-opt.wasm %t2.o %t.o
 ; RUN: obj2yaml %t-opt.wasm | FileCheck %s
 ; RUN: not wasm-ld --compress-relocations -o %t-compressed.wasm %t2.o %t.o 2>&1 | FileCheck %s -check-prefix=ERROR
-; RUN: wasm-ld --strip-debug --compress-relocations -o %t-compressed.wasm %t2.o %t.o
+; RUN: wasm-ld --export-dynamic --strip-debug --compress-relocations -o %t-compressed.wasm %t2.o %t.o
 ; RUN: obj2yaml %t-compressed.wasm | FileCheck %s -check-prefix=COMPRESS
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define i32 @foo() {
 entry:
   ret i32 2
 }

lld/trunk/test/wasm/cxx-mangling.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --demangle -o %t_demangle.wasm %t.o
+; RUN: wasm-ld --export=_Z3fooi --demangle -o %t_demangle.wasm %t.o
 ; RUN: obj2yaml %t_demangle.wasm | FileCheck %s
-; RUN: wasm-ld --no-demangle -o %t_nodemangle.wasm %t.o
+; RUN: wasm-ld --export=_Z3fooi --no-demangle -o %t_nodemangle.wasm %t.o
 ; RUN: obj2yaml %t_nodemangle.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 ; Check that the EXPORT name is still mangled, but that the "name" custom
 ; section contains the unmangled name.
 
 define void @_Z3fooi(i32 %arg) {

lld/trunk/test/wasm/local-symbols.ll

+; Test that internal symbols can still be GC'd when with --export-dynamic.
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld -o %t.wasm %t.o
+; RUN: wasm-ld --export-dynamic -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 @foo = default global i32 1, align 4
 @bar = internal default global i32 3, align 4
 
 define internal i32 @baz() local_unnamed_addr {

lld/trunk/test/wasm/locals-duplicate.test

 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/locals-duplicate2.ll -o %t2.o
-; RUN: wasm-ld --no-entry -o %t.wasm %t1.o %t2.o
+; RUN: wasm-ld --export-dynamic --no-entry -o %t.wasm %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:

lld/trunk/test/wasm/lto/archive.ll

 ; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
 ; RUN: rm -f %t.a
 ; RUN: llvm-ar rcs %t.a %t1.o
 ; RUN: llvm-as %s -o %t2.o
-; RUN: wasm-ld %t2.o %t.a -o %t3
+; RUN: wasm-ld --export-dynamic %t2.o %t.a -o %t3
 ; RUN: obj2yaml %t3 | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 define void @_start() {
   call void @f()
   ret void

lld/trunk/test/wasm/undefined-weak-call.ll

 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld --no-entry --print-gc-sections %t.o \
+; RUN: wasm-ld --entry=callWeakFuncs --print-gc-sections %t.o \
 ; RUN:     -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-GC %s
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Check that calling an undefined weak function generates an appropriate stub
 ; that will fail at runtime with "unreachable".
 
 target triple = "wasm32-unknown-unknown"
 

lld/trunk/test/wasm/visibility-hidden.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/hidden.ll -o %t2.o
 ; RUN: rm -f %t2.a
 ; RUN: llvm-ar rcs %t2.a %t2.o
 
-; Test that hidden symbols are not exported, whether pulled in from an archive
-; or directly.
-; RUN: wasm-ld %t.o %t2.a -o %t.wasm
+; Test that symbols with hidden visitiblity are not export, even with
+; --export-dynamic
+; RUN: wasm-ld --export-dynamic %t.o %t2.a -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
-; Test that symbols with default visitiblity are not exported when
-; --no-export-default is passed.
-; RUN: wasm-ld --no-export-default %t.o %t2.a -o %t.nodef.wasm
+; Test that symbols with default visitiblity are not exported without
+; --export-dynamic
+; RUN: wasm-ld %t.o %t2.a -o %t.nodef.wasm
 ; RUN: obj2yaml %t.nodef.wasm | FileCheck %s -check-prefix=NO-DEFAULT
 
 
 target triple = "wasm32-unknown-unknown"
 
 define hidden i32 @objectHidden() {
 entry:
     ret i32 0

 ; CHECK-NEXT:   - Type:
 
 
 ; NO-DEFAULT:        - Type:            EXPORT
 ; NO-DEFAULT-NEXT:     Exports:
 ; NO-DEFAULT-NEXT:       - Name:            memory
 ; NO-DEFAULT-NEXT:         Kind:            MEMORY
 ; NO-DEFAULT-NEXT:         Index:           0
+; NO-DEFAULT-NEXT:       - Name:            __heap_base
+; NO-DEFAULT-NEXT:         Kind:            GLOBAL
+; NO-DEFAULT-NEXT:         Index:           1
+; NO-DEFAULT-NEXT:       - Name:            __data_end
+; NO-DEFAULT-NEXT:         Kind:            GLOBAL
+; NO-DEFAULT-NEXT:         Index:           2
+; NO-DEFAULT-NEXT:       - Name:            _start
+; NO-DEFAULT-NEXT:         Kind:            FUNCTION
+; NO-DEFAULT-NEXT:         Index:           3
 ; NO-DEFAULT-NEXT:   - Type:

lld/trunk/test/wasm/weak-alias-overide.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
-; RUN: wasm-ld %t.o %t2.o -o %t.wasm
+; RUN: wasm-ld --export-dynamic %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that the strongly defined alias_fn from this file is used both here
 ; and in call_alias.
 
 target triple = "wasm32-unknown-unknown"
 
 define i32 @alias_fn() local_unnamed_addr #1 {

lld/trunk/test/wasm/weak-alias.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
-; RUN: wasm-ld %t.o %t2.o -o %t.wasm
+; RUN: wasm-ld --export-dynamic %t.o %t2.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that weak aliases (alias_fn is a weak alias of direct_fn) are linked correctly
 
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @alias_fn() local_unnamed_addr #1
 

lld/trunk/test/wasm/weak-symbols.ll

 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol1.ll -o %t1.o
 ; RUN: llc -filetype=obj %p/Inputs/weak-symbol2.ll -o %t2.o
 ; RUN: llc -filetype=obj %s -o %t.o
-; RUN: wasm-ld -no-gc-sections -o %t.wasm %t.o %t1.o %t2.o
+; RUN: wasm-ld --export-dynamic -o %t.wasm %t.o %t1.o %t2.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @weakFn() local_unnamed_addr
 @weakGlobal = external global i32
 
 define void @_start() local_unnamed_addr {

 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      NORESULT
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            FUNCTION
-; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1, 1, 1, 1 ]
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 1, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000002
 ; CHECK-NEXT:           Maximum:         0x00000002
 ; CHECK-NEXT:   - Type:            MEMORY

 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           66576
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           1032
+; CHECK-NEXT:           Value:           1028
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         false
 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:

 ; CHECK-NEXT:       - Name:            exportWeak1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            weakGlobal
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            exportWeak2
 ; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           5
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            1082808080001A0B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41010B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            41020B
-; CHECK-NEXT:       - Index:           5
-; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   7
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
-; CHECK-NEXT:         Content:         '0100000002000000'
+; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            __wasm_call_ctors
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            weakFn
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            exportWeak1
 ; CHECK-NEXT:       - Index:           4
-; CHECK-NEXT:         Name:            weakFn
-; CHECK-NEXT:       - Index:           5
 ; CHECK-NEXT:         Name:            exportWeak2
 ; CHECK-NEXT: ...

lld/trunk/test/wasm/weak-undefined.ll

 }
 
 define i32* @get_address_of_global_var() #0 {
   ret i32* @global_var
 }
 
 define void @_start() #0 {
 entry:
-    %call = call i32* @get_address_of_global_var()
+    %call1 = call i32* @get_address_of_global_var()
+    %call2 = call i8* @get_address_of_foo()
     ret void
 }
 
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE

 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            get_address_of_foo
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            get_address_of_global_var
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            0B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4180808080000B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            1082808080001A0B
+; CHECK-NEXT:         Body:            1082808080001A1081808080001A0B
 ; CHECK-NEXT: ...

lld/trunk/wasm/Config.h

 namespace wasm {
 
 struct Configuration {
   bool AllowUndefined;
   bool CompressRelocations;
   bool Demangle;
   bool DisableVerify;
   bool ExportAll;
-  bool ExportDefault;
+  bool ExportDynamic;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
   bool ImportTable;
   bool MergeDataSegments;
   bool PrintGcSections;
   bool Relocatable;
   bool SaveTemps;

lld/trunk/wasm/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
 
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Entry = getEntry(Args, Args.hasArg(OPT_relocatable) ? "" : "_start");
   Config->ExportAll = Args.hasArg(OPT_export_all);
-  Config->ExportDefault = Args.hasFlag(OPT_export_default,
-      OPT_no_export_default, true);
+  Config->ExportDynamic = Args.hasFlag(OPT_export_dynamic,
+      OPT_no_export_dynamic, false);
   Config->ExportTable = Args.hasArg(OPT_export_table);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->ImportMemory = Args.hasArg(OPT_import_memory);
   Config->ImportTable = Args.hasArg(OPT_import_table);
   Config->LTOO = args::getInteger(Args, OPT_lto_O, 2);
   Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1);
   Config->Optimize = args::getInteger(Args, OPT_O, 0);
if (!Config->Relocatable) {
     // spec proposal is implemented in all major browsers.
     // See: https://github.com/WebAssembly/mutable-global
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer);
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base", 0);
     WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol(
         "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end", 0);
+
+    // These two synthetic symbols exist purely for the embedder so we always
+    // want to export them.
+    WasmSym::HeapBase->ForceExport = true;
+    WasmSym::DataEnd->ForceExport = true;
   }
 
   createFiles(Args);
   if (errorCount())
     return;
 
   // Add all files to the symbol table. This will add almost all
   // symbols that we need to the symbol table.
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   }
 
   if (!Config->Relocatable) {
     // Add synthetic dummies for weak undefined functions.
     handleWeakUndefines();
 
     if (!Config->Entry.empty()) {
       EntrySym = handleUndefined(Config->Entry);
-      if (!EntrySym)
+      if (EntrySym && EntrySym->isDefined())
+        EntrySym->ForceExport = true;
+      else
         error("entry symbol not defined (pass --no-entry to supress): " +
               Config->Entry);
     }
 
     // Make sure we have resolved all symbols.
     if (!Config->AllowUndefined)
       Symtab->reportRemainingUndefines();
   }

lld/trunk/wasm/Options.td

 
 def compress_relocations: F<"compress-relocations">,
   HelpText<"Compress the relocation targets in the code section.">;
 
 defm demangle: B<"demangle",
     "Demangle symbol names",
     "Do not demangle symbol names">;
 
-defm export_default: B<"export-default",
-    "Export symbols marked as 'default' visibility (default)",
-    "Do not export symbols marked as 'default' visibility">;
+defm export_dynamic: B<"export-dynamic",
+    "Put symbols in the dynamic symbol table",
+    "Do not put symbols in the dynamic symbol table (default)">;
 
 def entry: S<"entry">, MetaVarName<"<entry>">,
   HelpText<"Name of entry point symbol">;
 
 def error_limit: J<"error-limit=">,
   HelpText<"Maximum number of errors to emit before stopping (0 = no limit)">;
 
 def fatal_warnings: F<"fatal-warnings">,

 def stack_first: F<"stack-first">,
   HelpText<"Place stack at start of linear memory rather than after data">;
 
 defm whole_archive: B<"whole-archive",
     "Force load of all members in a static library",
     "Do not force load of all members in a static library (default)">;
 
 // Aliases
-def alias_entry_e: JoinedOrSeparate<["-"], "e">, Alias<entry>;
-def alias_entry_entry: J<"entry=">, Alias<entry>;
-def alias_initial_memory_i: Flag<["-"], "i">, Alias<initial_memory>;
-def alias_max_memory_m: Flag<["-"], "m">, Alias<max_memory>;
-def alias_relocatable_r: Flag<["-"], "r">, Alias<relocatable>;
-def alias_undefined_u: JoinedOrSeparate<["-"], "u">, Alias<undefined>;
+def: JoinedOrSeparate<["-"], "e">, Alias<entry>;
+def: J<"entry=">, Alias<entry>;
+def: Flag<["-"], "E">, Alias<export_dynamic>, HelpText<"Alias for --export-dynamic">;
+def: Flag<["-"], "i">, Alias<initial_memory>;
+def: Flag<["-"], "m">, Alias<max_memory>;
+def: Flag<["-"], "r">, Alias<relocatable>;
+def: JoinedOrSeparate<["-"], "u">, Alias<undefined>;
 
 // LTO-related options.
 def lto_O: J<"lto-O">, MetaVarName<"<opt-level>">,
   HelpText<"Optimization level for LTO">;
 def lto_partitions: J<"lto-partitions=">,
   HelpText<"Number of LTO codegen partitions">;
 def disable_verify: F<"disable-verify">;
 def save_temps: F<"save-temps">;
 def thinlto_cache_dir: J<"thinlto-cache-dir=">,
   HelpText<"Path to ThinLTO cached object file directory">;
 defm thinlto_cache_policy: Eq<"thinlto-cache-policy">,
   HelpText<"Pruning policy for the ThinLTO cache">;
 def thinlto_jobs: J<"thinlto-jobs=">, HelpText<"Number of ThinLTO jobs">;

lld/trunk/wasm/Symbols.cpp

 
 bool Symbol::isExported() const {
   if (!isDefined() || isLocal())
     return false;
 
   if (ForceExport || Config->ExportAll)
     return true;
 
-  if (!Config->ExportDefault)
-    return false;
+  if (Config->ExportDynamic && !isHidden())
+    return true;
 
-  return !isHidden();
+  return false;
 }
 
 uint32_t FunctionSymbol::getFunctionIndex() const {
   if (auto *F = dyn_cast<DefinedFunction>(this))
     return F->Function->getFunctionIndex();
   assert(FunctionIndex != INVALID_INDEX);
   return FunctionIndex;
 }