Clean up loose ends in feature handling (#2203)

Fix and test mutable globals support, replace string literals with
constants, and add a pass to emit the target features section.

Author: tlively

src/passes/StripTargetFeatures.cpp

@@ -19,11 +19,14 @@
 namespace wasm {
 
 struct StripTargetFeatures : public Pass {
+  bool isStripped = false;
+  StripTargetFeatures(bool isStripped) : isStripped(isStripped) {}
   void run(PassRunner* runner, Module* module) override {
-    module->hasFeaturesSection = false;
+    module->hasFeaturesSection = !isStripped;
   }
 };
 
-Pass* createStripTargetFeaturesPass() { return new StripTargetFeatures(); }
+Pass* createStripTargetFeaturesPass() { return new StripTargetFeatures(true); }
+Pass* createEmitTargetFeaturesPass() { return new StripTargetFeatures(false); }
 
 } // namespace wasm

src/passes/pass.cpp

@@ -109,6 +109,9 @@ void PassRegistry::registerPasses() {
   registerPass("duplicate-function-elimination",
                "removes duplicate functions",
                createDuplicateFunctionEliminationPass);
+  registerPass("emit-target-features",
+               "emit the target features section in the output",
+               createEmitTargetFeaturesPass);
   registerPass("extract-function",
                "leaves just one function (useful for debugging)",
                createExtractFunctionPass);

src/passes/passes.h

@@ -36,6 +36,7 @@ Pass* createDataFlowOptsPass();
 Pass* createDeadCodeEliminationPass();
 Pass* createDirectizePass();
 Pass* createDuplicateFunctionEliminationPass();
+Pass* createEmitTargetFeaturesPass();
 Pass* createExtractFunctionPass();
 Pass* createFlattenPass();
 Pass* createFuncCastEmulationPass();

src/wasm-binary.h

@@ -400,6 +400,7 @@ extern const char* TargetFeatures;
 extern const char* AtomicsFeature;
 extern const char* BulkMemoryFeature;
 extern const char* ExceptionHandlingFeature;
+extern const char* MutableGlobalsFeature;
 extern const char* TruncSatFeature;
 extern const char* SignExtFeature;
 extern const char* SIMD128Feature;

src/wasm/wasm-binary.cpp

@@ -666,19 +666,19 @@ void WasmBinaryWriter::writeFeaturesSection() {
   auto toString = [](FeatureSet::Feature f) {
     switch (f) {
       case FeatureSet::Atomics:
-        return "atomics";
+        return BinaryConsts::UserSections::AtomicsFeature;
       case FeatureSet::MutableGlobals:
-        return "mutable-globals";
+        return BinaryConsts::UserSections::MutableGlobalsFeature;
       case FeatureSet::TruncSat:
-        return "nontrapping-fptoint";
+        return BinaryConsts::UserSections::TruncSatFeature;
       case FeatureSet::SIMD:
-        return "simd128";
+        return BinaryConsts::UserSections::SIMD128Feature;
       case FeatureSet::BulkMemory:
-        return "bulk-memory";
+        return BinaryConsts::UserSections::BulkMemoryFeature;
       case FeatureSet::SignExt:
-        return "sign-ext";
+        return BinaryConsts::UserSections::SignExtFeature;
       case FeatureSet::ExceptionHandling:
-        return "exception-handling";
+        return BinaryConsts::UserSections::ExceptionHandlingFeature;
       default:
         WASM_UNREACHABLE();
     }
@@ -2154,6 +2154,8 @@ void WasmBinaryBuilder::readFeatures(size_t payloadLen) {
         wasm.features.setBulkMemory();
       } else if (name == BinaryConsts::UserSections::ExceptionHandlingFeature) {
         wasm.features.setExceptionHandling();
+      } else if (name == BinaryConsts::UserSections::MutableGlobalsFeature) {
+        wasm.features.setMutableGlobals();
       } else if (name == BinaryConsts::UserSections::TruncSatFeature) {
         wasm.features.setTruncSat();
       } else if (name == BinaryConsts::UserSections::SignExtFeature) {

src/wasm/wasm.cpp

@@ -36,6 +36,7 @@ const char* TargetFeatures = "target_features";
 const char* AtomicsFeature = "atomics";
 const char* BulkMemoryFeature = "bulk-memory";
 const char* ExceptionHandlingFeature = "exception-handling";
+const char* MutableGlobalsFeature = "mutable-globals";
 const char* TruncSatFeature = "nontrapping-fptoint";
 const char* SignExtFeature = "sign-ext";
 const char* SIMD128Feature = "simd128";

test/unit/input/mutable_globals_target_feature.wasm

@@ -137,6 +137,13 @@ def test_nontrapping_fptoint(self):
     self.check_features(filename, ['nontrapping-float-to-int'])
     self.assertIn('i32.trunc_sat_f32_u', self.disassemble(filename))
 
+  def test_mutable_globals(self):
+    filename = 'mutable_globals_target_feature.wasm'
+    self.roundtrip(filename)
+    self.check_features(filename, ['mutable-globals'])
+    self.assertIn('(import "env" "global-mut" (global $gimport$0 (mut i32)))',
+                  self.disassemble(filename))
+
   def test_sign_ext(self):
     filename = 'signext_target_feature.wasm'
     self.roundtrip(filename)
@@ -173,3 +180,20 @@ def test_incompatible_features_forced(self):
   def test_explicit_detect_features(self):
     self.check_features('signext_target_feature.wasm', ['sign-ext', 'simd'],
                         opts=['-mvp', '--detect-features', '--enable-simd'])
+
+  def test_emit_all_features(self):
+    p = run_process(WASM_OPT + ['--emit-target-features', '-all', '-o', '-'],
+                    input="(module)", check=False, capture_output=True)
+    self.assertEqual(p.returncode, 0)
+    p2 = run_process(WASM_OPT + ['--print-features', '-o', os.devnull],
+                     input=p.stdout, check=False, capture_output=True)
+    self.assertEqual(p2.returncode, 0)
+    self.assertEqual(p2.stdout.split(), [
+        '--enable-threads',
+        '--enable-bulk-memory',
+        '--enable-exception-handling',
+        '--enable-mutable-globals',
+        '--enable-nontrapping-float-to-int',
+        '--enable-sign-ext',
+        '--enable-simd',
+    ])