[WebAssembly] Add linker options to control feature checking

[tlively]

Summary

Adds --check-features and --no-check-features. The default for now is
to enable the checking, but this might change in the future.

Also adds --features=foo,bar for precisely controlling the features
used in the output binary.

Depends on D59173.

[ruiu]

lld/wasm/Config.h

58 ↗

(On Diff #190344)

It seems like you can just use std::vector<std::string> instead of Optional<std::vector<std::string>>. If there's nothing, leave the vector empty.

lld/wasm/Driver.cpp

345–352 ↗

(On Diff #190344)

This use of using seems unusual in the lld codebase. A more common way of writing it in lld is:

if (auto *Arg = Args.getLastArg(OPT_features))
  for (StringRef S : Args.getLastArg(OPT_features))
    Config->Features.push_back(S);

lld/wasm/Options.td

163 ↗

(On Diff #190344)

Unless you have a plan to use C multiple times, I wouldn't define C. You can do that when you have more than one occurrence of the same pattern.

lld/wasm/Writer.cpp

873 ↗

(On Diff #190344)

This function sounds like it computes TargetFeatures, but it does more than that -- it tries to find a conflict of feature sets. Is this a good name or a design?

882 ↗

(On Diff #190344)

We don't use auto unless its type is obvious from the right-hand side (e.g. cast).

883 ↗

(On Diff #190344)

TargetFeatures = Config->Features;

884–886 ↗

(On Diff #190344)

Why don't you need to check features?

901 ↗

(On Diff #190344)

So, if --feature is given, you ignore Used but use Required and Disallowed? It seems a bit inconsistent to me. I'm not sure if it's correct.

[tlively]

• Address comments

lld/wasm/Config.h

58 ↗

(On Diff #190344)

This would not quite work. Currently an empty vector means "the output uses no features", which is different from an empty Optional which means "read the set of used features from the input objects."

lld/wasm/Writer.cpp

873 ↗

(On Diff #190344)

I think this is reasonable as is. Splitting this into separate functions for computing TargetFeatures and for validating the TargetFeatures would require another loop over all the individual objects' target features. I also view the validation as an important part of computing the TargetFeatures set.

882 ↗

(On Diff #190344)

I switched to using a loop. Hopefully auto is ok in that context?

883 ↗

(On Diff #190344)

This does not work. TargetFeatures is a set of strings, but Config->Features is a vector of char *.

884–886 ↗

(On Diff #190344)

If the user chooses to explicitly supply features on the command line (using --features=...) and also elects not to validate the used features (using --no-check-features), then there is no reason to do more work here.

901 ↗

(On Diff #190344)

Not quite. If --feature is given, we still compute the Used set from the input objects, then we check below that no features are Used that were not supplied on the command line by the user. If that check passes then we go on to validate against the Required and Disallowed sets.

[ruiu]

Is there a PR or something that explains how these things are supposed to work?

[ruiu]

lld/wasm/Options.td

159–160 ↗

(On Diff #190369)

Add "(default)" to the default choice just like other options.

[tlively]

• Add (default) to --check-features description

[tlively]

In D59274#1428226, @ruiu wrote:

Is there a PR or something that explains how these things are supposed to work?

The desired linking behavior when the user does not manually specify features is described in this PR: https://github.com/WebAssembly/tool-conventions/pull/99. Unfortunately that document does not describe the flags implemented here, because the flags are for deviating from the convention.

[tlively]

• Add more tests for empty feature sets

[tlively]

@sbc100 Any comments or concerns with these flags?

[tlively]

@sbc100 friendly ping! It would be great to start clearing this stack.

[sbc100]

lld/wasm/Driver.cpp

351 ↗

(On Diff #190540)

Is this not the default for Optional types? Can you remove this else block?

lld/wasm/Writer.cpp

920 ↗

(On Diff #190540)

Use single quotes around feature name to avoid escape chars?

lld/trunk/test/wasm/target-feature-disallowed.yaml

 # RUN: yaml2obj %s -o %t1.o
 
+# RUN: wasm-ld --no-entry --features=foo,bar,baz -o - %t1.o | obj2yaml | FileCheck %s --check-prefix SPECIFIED
+
+# RUN: wasm-ld --no-entry --features=bar,baz,quux -o - %t1.o | obj2yaml | FileCheck %s --check-prefix UNSPECIFIED
+
 # RUN: yaml2obj %S/Inputs/disallow-feature-foo.yaml -o %t.disallowed.o
 # RUN: wasm-ld --no-entry -o %t.disallowed.exe %t1.o %t.disallowed.o
 # RUN: obj2yaml < %t.disallowed.exe | FileCheck %s --check-prefix DISALLOWED
 
 # RUN: yaml2obj %S/Inputs/no-feature-foo.yaml -o %t.none.o
 # RUN: wasm-ld --no-entry -o %t.none.exe %t1.o %t.none.o
 # RUN: obj2yaml < %t.none.exe | FileCheck %s --check-prefix NONE
 
- Type:            CUSTOM
     Features:
       - Prefix:        DISALLOWED
         Name:          "foo"
         # included so output has target features section
       - Prefix:        USED
         Name:          "bar"
 ...
 
+# SPECIFIED:        - Type:            CUSTOM
+# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED-NEXT:     Features:
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            bar
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            baz
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            foo
+# SPECIFIED-NEXT: ...
+
+# UNSPECIFIED:        - Type:            CUSTOM
+# UNSPECIFIED-NEXT:     Name:            target_features
+# UNSPECIFIED-NEXT:     Features:
+# UNSPECIFIED-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NEXT:         Name:            bar
+# UNSPECIFIED-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NEXT:         Name:            baz
+# UNSPECIFIED-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NEXT:         Name:            quux
+# UNSPECIFIED-NEXT: ...
+
 # DISALLOWED:        - Type:            CUSTOM
 # DISALLOWED-NEXT:     Name:            target_features
 # DISALLOWED-NEXT:     Features:
 # DISALLOWED-NEXT:       - Prefix:          USED
 # DISALLOWED-NEXT:         Name:            bar
 # DISALLOWED-NEXT: ...
 
 # NONE:        - Type:            CUSTOM
 # NONE-NEXT:     Name:            target_features
 # NONE-NEXT:     Features:
 # NONE-NEXT:       - Prefix:          USED
 # NONE-NEXT:         Name:            bar
 # NONE-NEXT: ...

lld/trunk/test/wasm/target-feature-none.yaml

+# RUN: yaml2obj %s -o %t1.o
+
+# RUN: wasm-ld --no-entry -o - %t1.o | obj2yaml | FileCheck %s --check-prefix EMPTY
+
+# RUN: wasm-ld --no-entry --features= -o - %t1.o | obj2yaml | FileCheck %s --check-prefix EMPTY
+
+# RUN: wasm-ld --no-entry --features=foo,bar,baz -o - %t1.o | obj2yaml | FileCheck %s --check-prefix SPECIFIED
+
+--- !WASM
+FileHeader:
+  Version:         0x00000001
+Sections:
+  - Type:            CUSTOM
+    Name:            linking
+    Version:         2
+  - Type:            CUSTOM
+    Name:            target_features
+    Features:        [ ]
+...
+
+# section is not emitted if it would be empty
+# EMPTY-NOT: target_features
+
+# SPECIFIED:        - Type:            CUSTOM
+# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED-NEXT:     Features:
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            bar
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            baz
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            foo
+# SPECIFIED-NEXT: ...

lld/trunk/test/wasm/target-feature-required.yaml

 # RUN: yaml2obj %s -o %t1.o
 
+# RUN: wasm-ld --no-entry --features=foo,bar,baz -o - %t1.o | obj2yaml | FileCheck %s --check-prefix SPECIFIED
+
+# RUN: not wasm-ld --no-entry --features=bar,baz,quux -o - %t1.o 2>&1 | FileCheck %s --check-prefix UNSPECIFIED
+
+# RUN: wasm-ld --no-entry --no-check-features --features=bar,baz,quux -o - %t1.o | obj2yaml | FileCheck %s --check-prefix UNSPECIFIED-NOCHECK
+
 # RUN: yaml2obj %S/Inputs/require-feature-foo.yaml -o %t.required.o
 # RUN: wasm-ld --no-entry -o %t.required.exe %t1.o %t.required.o
 # RUN: obj2yaml < %t.required.exe | FileCheck %s --check-prefix REQUIRED
 
 # RUN: yaml2obj %S/Inputs/disallow-feature-foo.yaml -o %t.disallowed.o
 # RUN: not wasm-ld --no-entry -o /dev/null %t1.o %t.disallowed.o 2>&1 | FileCheck %s --check-prefix DISALLOWED
 
+# RUN: wasm-ld --no-entry --no-check-features -o - %t1.o %t.disallowed.o | obj2yaml | FileCheck %s --check-prefix DISALLOWED-NOCHECK
+
 # RUN: yaml2obj %S/Inputs/no-feature-foo.yaml -o %t.none.o
 # RUN: not wasm-ld --no-entry -o /dev/null %t1.o %t.none.o 2>&1 | FileCheck %s --check-prefix NONE
 
+# RUN: wasm-ld --no-entry --no-check-features -o - %t1.o %t.none.o | obj2yaml | FileCheck %s --check-prefix NONE-NOCHECK
+
 # Check that the following combinations of feature linkage policies
 # give the expected results:
 #
 #     REQUIRED x REQUIRED => USED
 #     REQUIRED x DISALLOWED => Error
 #     REQUIRED x NONE => Error
 
 --- !WASM
 FileHeader:
   Version:         0x00000001
 Sections:
   - Type:            CUSTOM
     Name:            linking
     Version:         2
   - Type:            CUSTOM
     Name:            target_features
     Features:
       - Prefix:        REQUIRED
         Name:          "foo"
 ...
 
+# SPECIFIED:        - Type:            CUSTOM
+# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED-NEXT:     Features:
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            bar
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            baz
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            foo
+# SPECIFIED-NEXT: ...
+
+# UNSPECIFIED: Target feature 'foo' is not allowed.{{$}}
+
+# UNSPECIFIED-NOCHECK:        - Type:            CUSTOM
+# UNSPECIFIED-NOCHECK-NEXT:     Name:            target_features
+# UNSPECIFIED-NOCHECK-NEXT:     Features:
+# UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NOCHECK-NEXT:         Name:            bar
+# UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NOCHECK-NEXT:         Name:            baz
+# UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NOCHECK-NEXT:         Name:            quux
+# UNSPECIFIED-NOCHECK-NEXT: ...
+
 # REQUIRED:        - Type:            CUSTOM
 # REQUIRED-NEXT:     Name:            target_features
 # REQUIRED-NEXT:     Features:
 # REQUIRED-NEXT:       - Prefix:          USED
 # REQUIRED-NEXT:         Name:            foo
 # REQUIRED-NEXT: ...
 
-# DISALLOWED: Target feature "foo" is disallowed
+# DISALLOWED: Target feature 'foo' is disallowed. Use --no-check-features to suppress.{{$}}
 
-# NONE: Missing required target feature "foo"
+# DISALLOWED-NOCHECK:        - Type:            CUSTOM
+# DISALLOWED-NOCHECK-NEXT:     Name:            target_features
+# DISALLOWED-NOCHECK-NEXT:     Features:
+# DISALLOWED-NOCHECK-NEXT:       - Prefix:          USED
+# DISALLOWED-NOCHECK-NEXT:         Name:            foo
+# DISALLOWED-NOCHECK-NEXT: ...
+
+# NONE: Missing required target feature 'foo'. Use --no-check-features to suppress.{{$}}
+
+# NONE-NOCHECK:        - Type:            CUSTOM
+# NONE-NOCHECK-NEXT:     Name:            target_features
+# NONE-NOCHECK-NEXT:     Features:
+# NONE-NOCHECK-NEXT:       - Prefix:          USED
+# NONE-NOCHECK-NEXT:         Name:            foo
+# NONE-NOCHECK-NEXT: ...

lld/trunk/test/wasm/target-feature-used.yaml

 # RUN: yaml2obj %s -o %t1.o
 
+# RUN: wasm-ld --no-entry --features=foo,bar,baz -o - %t1.o | obj2yaml | FileCheck %s --check-prefix SPECIFIED
+
+# RUN: not wasm-ld --no-entry --features=bar,baz,quux -o - %t1.o 2>&1 | FileCheck %s --check-prefix UNSPECIFIED
+
+# RUN: wasm-ld --no-entry --no-check-features --features=bar,baz,quux -o - %t1.o | obj2yaml | FileCheck %s --check-prefix UNSPECIFIED-NOCHECK
+
 # RUN: yaml2obj %S/Inputs/use-feature-foo.yaml -o %t.used.o
 # RUN: wasm-ld --no-entry -o %t.used.exe %t1.o %t.used.o
 # RUN: obj2yaml < %t.used.exe | FileCheck %s --check-prefix USED
 
 # RUN: yaml2obj %S/Inputs/require-feature-foo.yaml -o %t.required.o
 # RUN: wasm-ld --no-entry -o %t.required.exe %t1.o %t.required.o
 # RUN: obj2yaml < %t.required.exe | FileCheck %s --check-prefix REQUIRED
 
 # RUN: yaml2obj %S/Inputs/disallow-feature-foo.yaml -o %t.disallowed.o
 # RUN: not wasm-ld --no-entry -o /dev/null %t1.o %t.disallowed.o 2>&1 | FileCheck %s --check-prefix DISALLOWED
 
+# RUN: wasm-ld --no-entry --no-check-features -o - %t1.o %t.disallowed.o | obj2yaml | FileCheck %s --check-prefix DISALLOWED-NOCHECK
+
 # RUN: yaml2obj %S/Inputs/no-feature-foo.yaml -o %t.none.o
 # RUN: wasm-ld --no-entry -o %t.none.exe %t1.o %t.none.o
 # RUN: obj2yaml %t.none.exe | FileCheck %s --check-prefix NONE
 
 # Check that the following combinations of feature linkage policies
 # give the expected results:
 #
 #     USED x USED => USED
- Type:            CUSTOM
     Version:         2
   - Type:            CUSTOM
     Name:            target_features
     Features:
       - Prefix:        USED
         Name:          "foo"
 ...
 
+# SPECIFIED:        - Type:            CUSTOM
+# SPECIFIED-NEXT:     Name:            target_features
+# SPECIFIED-NEXT:     Features:
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            bar
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            baz
+# SPECIFIED-NEXT:       - Prefix:          USED
+# SPECIFIED-NEXT:         Name:            foo
+# SPECIFIED-NEXT: ...
+
+# UNSPECIFIED: Target feature 'foo' is not allowed.{{$}}
+
+# UNSPECIFIED-NOCHECK:        - Type:            CUSTOM
+# UNSPECIFIED-NOCHECK-NEXT:     Name:            target_features
+# UNSPECIFIED-NOCHECK-NEXT:     Features:
+# UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NOCHECK-NEXT:         Name:            bar
+# UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NOCHECK-NEXT:         Name:            baz
+# UNSPECIFIED-NOCHECK-NEXT:       - Prefix:          USED
+# UNSPECIFIED-NOCHECK-NEXT:         Name:            quux
+# UNSPECIFIED-NOCHECK-NEXT: ...
+
 # USED:        - Type:            CUSTOM
 # USED-NEXT:     Name:            target_features
 # USED-NEXT:     Features:
 # USED-NEXT:       - Prefix:          USED
 # USED-NEXT:         Name:            foo
 # USED-NEXT: ...
 
 # REQUIRED:        - Type:            CUSTOM
 # REQUIRED-NEXT:     Name:            target_features
 # REQUIRED-NEXT:     Features:
 # REQUIRED-NEXT:       - Prefix:          USED
 # REQUIRED-NEXT:         Name:            foo
 # REQUIRED-NEXT: ...
 
-# DISALLOWED: Target feature "foo" is disallowed
+# DISALLOWED: Target feature 'foo' is disallowed. Use --no-check-features to suppress.{{$}}
+
+# DISALLOWED-NOCHECK:        - Type:            CUSTOM
+# DISALLOWED-NOCHECK-NEXT:     Name:            target_features
+# DISALLOWED-NOCHECK-NEXT:     Features:
+# DISALLOWED-NOCHECK-NEXT:       - Prefix:          USED
+# DISALLOWED-NOCHECK-NEXT:         Name:            foo
+# DISALLOWED-NOCHECK-NEXT: ...
 
 # NONE:        - Type:            CUSTOM
 # NONE-NEXT:     Name:            target_features
 # NONE-NEXT:     Features:
 # NONE-NEXT:       - Prefix:          USED
 # NONE-NEXT:         Name:            foo
 # NONE-NEXT: ...

lld/trunk/wasm/Config.h

 #include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Support/CachePruning.h"
 
 namespace lld {
 namespace wasm {
 
 struct Configuration {
   bool AllowUndefined;
+  bool CheckFeatures;
   bool CompressRelocations;
   bool Demangle;
   bool DisableVerify;
   bool ExportAll;
   bool ExportDynamic;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
struct Configuration {
   unsigned ThinLTOJobs;
   llvm::StringRef Entry;
   llvm::StringRef OutputFile;
   llvm::StringRef ThinLTOCacheDir;
 
   llvm::StringSet<> AllowUndefinedSymbols;
   std::vector<llvm::StringRef> SearchPaths;
   llvm::CachePruningPolicy ThinLTOCachePolicy;
+  llvm::Optional<std::vector<std::string>> Features;
 
   // True if we are creating position-independent code.
   bool Pic;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/trunk/wasm/Driver.cpp

 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
+#include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetSelect.h"
 
 #define DEBUG_TYPE "lld"
 

 }
 
 // Some Config members do not directly correspond to any particular
 // command line options, but computed based on other Config values.
 // This function initialize such members. See Config.h for the details
 // of these values.
 static void setConfigs(opt::InputArgList &Args) {
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
+  Config->CheckFeatures =
+      Args.hasFlag(OPT_check_features, OPT_no_check_features, true);
   Config->CompressRelocations = Args.hasArg(OPT_compress_relocations);
   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->ExportDynamic = Args.hasFlag(OPT_export_dynamic,
       OPT_no_export_dynamic, false);
   Config->ExportTable = Args.hasArg(OPT_export_table);
static void setConfigs(opt::InputArgList &Args) {
   LLVM_DEBUG(errorHandler().Verbose = true);
   ThreadsEnabled = Args.hasFlag(OPT_threads, OPT_no_threads, true);
 
   Config->InitialMemory = args::getInteger(Args, OPT_initial_memory, 0);
   Config->GlobalBase = args::getInteger(Args, OPT_global_base, 1024);
   Config->MaxMemory = args::getInteger(Args, OPT_max_memory, 0);
   Config->ZStackSize =
       args::getZOptionValue(Args, OPT_z, "stack-size", WasmPageSize);
+
+  if (auto *Arg = Args.getLastArg(OPT_features)) {
+    Config->Features =
+        llvm::Optional<std::vector<std::string>>(std::vector<std::string>());
+    for (StringRef S : Arg->getValues())
+      Config->Features->push_back(S);
+  }
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &Args) {
   if (!Config->StripDebug && !Config->StripAll && Config->CompressRelocations)
     error("--compress-relocations is incompatible with output debug"
           " information. Please pass --strip-debug or --strip-all");

lld/trunk/wasm/Options.td

 
 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)">;
 
+defm check_features: B<"check-features",
+    "Check feature compatibility of linked objects (default)",
+    "Ignore feature compatibility of linked objects">;
+
+def features: CommaJoined<["--", "-"], "features=">,
+  HelpText<"Comma-separated used features, inferred from input objects by default.">;
+
 // Aliases
 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: Flag<["-"], "s">, Alias<strip_all>, HelpText<"Alias for --strip-all">;

lld/trunk/wasm/Writer.cpp

void Writer::createSections() {
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateTargetFeatures() {
+  SmallSet<std::string, 8> Used;
   SmallSet<std::string, 8> Required;
   SmallSet<std::string, 8> Disallowed;
 
+  // Only infer used features if user did not specify features
+  bool InferFeatures = !Config->Features.hasValue();
+
+  if (!InferFeatures) {
+    for (auto &Feature : Config->Features.getValue())
+      TargetFeatures.insert(Feature);
+    // No need to read or check features
+    if (!Config->CheckFeatures)
+      return;
+  }
+
   // Find the sets of used, required, and disallowed features
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (auto &Feature : File->getWasmObj()->getTargetFeatures()) {
       switch (Feature.Prefix) {
       case WASM_FEATURE_PREFIX_USED:
-        TargetFeatures.insert(Feature.Name);
+        Used.insert(Feature.Name);
         break;
       case WASM_FEATURE_PREFIX_REQUIRED:
-        TargetFeatures.insert(Feature.Name);
+        Used.insert(Feature.Name);
         Required.insert(Feature.Name);
         break;
       case WASM_FEATURE_PREFIX_DISALLOWED:
         Disallowed.insert(Feature.Name);
         break;
       default:
         error("Unrecognized feature policy prefix " +
               std::to_string(Feature.Prefix));
       }
     }
   }
 
+  if (InferFeatures)
+    TargetFeatures.insert(Used.begin(), Used.end());
+
+  if (!Config->CheckFeatures)
+    return;
+
+  // Validate that used features are allowed in output
+  if (!InferFeatures) {
+    for (auto &Feature : Used) {
+      if (!TargetFeatures.count(Feature))
+        error(Twine("Target feature '") + Feature + "' is not allowed.");
+    }
+  }
+
   // Validate the required and disallowed constraints for each file
   for (ObjFile *File : Symtab->ObjectFiles) {
     SmallSet<std::string, 8> ObjectFeatures;
     for (auto &Feature : File->getWasmObj()->getTargetFeatures()) {
       if (Feature.Prefix == WASM_FEATURE_PREFIX_DISALLOWED)
         continue;
       ObjectFeatures.insert(Feature.Name);
       if (Disallowed.count(Feature.Name))
-        error("Target feature \"" + Feature.Name + "\" is disallowed");
+        error(Twine("Target feature '") + Feature.Name +
+              "' is disallowed. Use --no-check-features to suppress.");
     }
     for (auto &Feature : Required) {
       if (!ObjectFeatures.count(Feature))
-        error(Twine("Missing required target feature \"") + Feature + "\"");
+        error(Twine("Missing required target feature '") + Feature +
+              "'. Use --no-check-features to suppress.");
     }
   }
 }
 
 void Writer::calculateImports() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isUndefined())
       continue;