[wasm-dis] Restore features section in output (#7840)

This effectively restores pre-#7802 status, except for the case the
input binary has the features section. If the binary does not have it,
we restore the default features (mutable-global + sign-ext) + whatever
is given in the command line before the printing. If the binary has the
features section, we just restore it before the printing.

This currently does not handle the case when there is the features
section and the user gives more features flags in the command line, but
in the current interface it is cumbersome to handle. And we were not
handling that anyway pre-#7802, so it is not a regression.

And we preserve the `FeaturesSet::All` setting at parsing time so
@tlively's
[concern](#7836 (comment))
will not be an issue.

Because we preserve the features section, #7836 will be addressed too.

The main motivation for #7802 was `call_indirect` could be incorrectly
printed, and that was also separately addressed by #7843.

`ModuleReader::getFeaturesSectionFeatures` was adopted from @tlively's
commit:

ed36a8c

Because we don't set the features to `Features::All` at the printing
time, `(type $..)` in `(func)` definitions and `(table ..)` in
`call_indirect`s have been removed.

Fixes #7836.

Author: aheejin

src/tools/wasm-dis.cpp

@@ -18,6 +18,7 @@
 // wasm2asm console tool
 //
 
+#include "parsing.h"
 #include "source-map.h"
 #include "support/colors.h"
 #include "support/file.h"
@@ -67,10 +68,12 @@ int main(int argc, const char* argv[]) {
   }
   Module wasm;
   options.applyOptionsBeforeParse(wasm);
+  auto enabledFeatures = wasm.features;
   wasm.features = FeatureSet::All;
 
+  auto moduleReader = ModuleReader();
   try {
-    ModuleReader().readBinary(options.extra["infile"], wasm, sourceMapFilename);
+    moduleReader.readBinary(options.extra["infile"], wasm, sourceMapFilename);
   } catch (ParseException& p) {
     p.dump(std::cerr);
     std::cerr << '\n';
@@ -87,7 +90,11 @@ int main(int argc, const char* argv[]) {
   }
 
   options.applyOptionsAfterParse(wasm);
-
+  // If the features section is present, restore it. If not, restore the command
+  // line + default features.
+  wasm.features = wasm.hasFeaturesSection
+                    ? moduleReader.getFeaturesSectionFeatures()
+                    : enabledFeatures;
   if (options.debug) {
     std::cerr << "Printing..." << std::endl;
   }

src/wasm-binary.h

@@ -30,6 +30,7 @@
 #include "parsing.h"
 #include "source-map.h"
 #include "wasm-builder.h"
+#include "wasm-features.h"
 #include "wasm-ir-builder.h"
 #include "wasm-traversal.h"
 #include "wasm-validator.h"
@@ -1730,12 +1731,19 @@ class WasmBinaryReader {
     throw ParseException(text, 0, pos);
   }
 
+  // Allow users to query the target features section features after parsing.
+  FeatureSet getFeaturesSectionFeatures() { return featuresSectionFeatures; }
+
 private:
   // In certain modes we need to note the locations of expressions, to match
   // them against sections like DWARF or custom annotations. As this incurs
   // overhead, we only note locations when we actually need to.
   bool needCodeLocations = false;
 
+  // The features enabled by the target features section, which may be a subset
+  // of the features enabled for the module.
+  FeatureSet featuresSectionFeatures;
+
   // Scans ahead in the binary to check certain conditions like
   // needCodeLocations.
   void preScan();

src/wasm-io.h

@@ -21,7 +21,6 @@
 #ifndef wasm_wasm_io_h
 #define wasm_wasm_io_h
 
-#include "parsing.h"
 #include "pass.h"
 #include "support/file.h"
 #include "wasm.h"
@@ -67,13 +66,17 @@ class ModuleReader : public ModuleIOBase {
   // check whether a file is a wasm binary
   bool isBinaryFile(std::string filename);
 
+  FeatureSet getFeaturesSectionFeatures() { return featuresSectionFeatures; }
+
 private:
   bool DWARF = false;
 
   IRProfile profile = IRProfile::Normal;
 
   bool skipFunctionBodies = false;
 
+  FeatureSet featuresSectionFeatures = FeatureSet::MVP;
+
   void readStdin(Module& wasm, std::string sourceMapFilename);
 
   void readBinaryData(std::vector<char>& input,

src/wasm/wasm-binary.cpp

@@ -5262,12 +5262,14 @@ void WasmBinaryReader::readFeatures(size_t sectionPos, size_t payloadLen) {
         << " was enabled by the user, but disallowed in the features section.";
     }
     if (used) {
-      wasm.features.enable(feature);
+      featuresSectionFeatures.enable(feature);
     }
   }
   if (pos != sectionPos + payloadLen) {
     throwError("bad features section size");
   }
+
+  wasm.features.enable(featuresSectionFeatures);
 }
 
 void WasmBinaryReader::readDylink(size_t payloadLen) {

src/wasm/wasm-io.cpp

@@ -65,6 +65,9 @@ void ModuleReader::readBinaryData(std::vector<char>& input,
   parser.setDWARF(DWARF);
   parser.setSkipFunctionBodies(skipFunctionBodies);
   parser.read();
+  if (wasm.hasFeaturesSection) {
+    featuresSectionFeatures = parser.getFeaturesSectionFeatures();
+  }
 }
 
 void ModuleReader::readBinary(std::string filename,

test/br_to_exit.wasm.fromBinary

@@ -1,6 +1,6 @@
 (module
  (type $0 (func))
- (func $0 (type $0)
+ (func $0
   (block $label
    (br $label)
   )

test/br_to_try.wasm.fromBinary

@@ -2,7 +2,7 @@
  (type $0 (func (param i32)))
  (type $1 (func))
  (tag $tag$0 (type $0) (param i32))
- (func $0 (type $1)
+ (func $0
   (block $label
    (try
     (do

test/break-to-return.wasm.fromBinary

@@ -2,7 +2,7 @@
  (type $0 (func (param i32 i32) (result i32)))
  (memory $0 256 256)
  (export "add" (func $0))
- (func $0 (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (func $0 (param $0 i32) (param $1 i32) (result i32)
   (block $label (result i32)
    (br $label
     (i32.add

test/break-within-catch.wasm.fromBinary

@@ -2,7 +2,7 @@
  (type $0 (func (param i32)))
  (type $1 (func))
  (tag $tag$0 (type $0) (param i32))
- (func $0 (type $1)
+ (func $0
   (block $label
    (try
     (do

test/complexBinaryNames.wasm.fromBinary

@@ -1,10 +1,10 @@
 (module
  (type $0 (func))
  (export "$zoo (.bar)" (func $1))
- (func $foo\20\28.bar\29 (type $0)
+ (func $foo\20\28.bar\29
   (nop)
  )
- (func $1 (type $0)
+ (func $1
   (call $foo\20\28.bar\29)
  )
 )