[dart2wasm] Check const-ness of instructions added to const exprs

A constant expression in Wasm is an instruction sequence that consists
of only the constant instructions.

Currently if I generate a non-constant instruction in a constant
expression I get an error during Wasm compilation. I then have to find
where and how I generate the instruction, possibly by using `--watch
<instruction offset>` passed to dart2wasm.

With this change we check in an assertion that an instruction added to
an instruction sequence for a constant expression can only be a constant
expression.

This helps with debugging as I notice the error earlier, and get a stack
trace of the compiler function that generates the invalid instruction.

Changes:

- Add `bool get isConstant => false` member to `Instruction`.

  A method instead of field to avoid adding one more word to
  `Instruction` objects.

- Override the member in constant instructions.

- When creating an instructions builder, mark the builder as "constant",
  with an optional named constructor argument that defaults to `false`.

- When adding an instruction to an instructions builder, check that if
  the instruction block is for a constant expression, the instruction is
  constant.

Spec:
https://webassembly.github.io/gc/core/valid/instructions.html#constant-expressions

Change-Id: I59454f0634ab419a62f9455c84aa9ce631db8b63
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/391440
Commit-Queue: Ömer Ağacan <[email protected]>
Reviewed-by: Slava Egorov <[email protected]>

Author: osa1

pkg/wasm_builder/lib/src/builder/global.dart

@@ -10,7 +10,8 @@ class GlobalBuilder extends ir.Global with IndexableBuilder<ir.DefinedGlobal> {
 
   GlobalBuilder(super.enclosingModule, super.index, super.type,
       [super.globalName])
-      : initializer = InstructionsBuilder(enclosingModule, [], [type.type]);
+      : initializer = InstructionsBuilder(enclosingModule, [], [type.type],
+            constantExpression: true);
 
   @override
   ir.DefinedGlobal forceBuild() => ir.DefinedGlobal(

pkg/wasm_builder/lib/src/builder/instructions.dart

@@ -146,11 +146,16 @@ class InstructionsBuilder with Builder<ir.Instructions> {
   /// Stored stack traces leading to the instructions for watch points.
   final Map<ir.Instruction, StackTrace>? _stackTraces;
 
+  /// Whether the instruction block is for a Wasm constant expression.
+  final bool _constantExpression;
+
   /// Create a new instruction sequence.
   InstructionsBuilder(
-      this.module, List<ir.ValueType> inputs, List<ir.ValueType> outputs)
+      this.module, List<ir.ValueType> inputs, List<ir.ValueType> outputs,
+      {bool constantExpression = false})
       : _stackTraces = module.watchPoints.isNotEmpty ? {} : null,
-        _sourceMappings = module.sourceMapUrl == null ? null : [] {
+        _sourceMappings = module.sourceMapUrl == null ? null : [],
+        _constantExpression = constantExpression {
     _labelStack.add(Expression(const [], outputs));
     for (ir.ValueType paramType in inputs) {
       _addParameter(paramType);
@@ -184,6 +189,8 @@ class InstructionsBuilder with Builder<ir.Instructions> {
       locals, _instructions, _stackTraces, _traceLines, _sourceMappings);
 
   void _add(ir.Instruction i) {
+    assert(!_constantExpression || i.isConstant,
+        "Non-constant instruction $i added to constant expression");
     if (!_reachable) return;
     _instructions.add(i);
     if (module.watchPoints.isNotEmpty) {

pkg/wasm_builder/lib/src/ir/instruction.dart

@@ -16,6 +16,13 @@ abstract class Instruction implements Serializable {
   List<DefType> get usedDefTypes => const [];
 
   const Instruction();
+
+  /// Whether the instruction is a "constant instruction", as defined by the
+  /// Wasm spec.
+  ///
+  /// Constant instructions can be used in global initializers, element
+  /// segments, data segments.
+  bool get isConstant => false;
 }
 
 abstract class SingleByteInstruction extends Instruction {
@@ -226,6 +233,9 @@ class Rethrow extends Instruction {
 
 class End extends SingleByteInstruction {
   const End() : super(0x0B);
+
+  @override
+  bool get isConstant => true;
 }
 
 class Br extends Instruction {
@@ -382,6 +392,9 @@ class GlobalGet extends Instruction {
 
   GlobalGet(this.global);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0x23);
@@ -597,6 +610,9 @@ class RefNull extends Instruction {
 
   RefNull(this.heapType);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0xD0);
@@ -613,6 +629,9 @@ class RefFunc extends Instruction {
 
   RefFunc(this.function);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0xD2);
@@ -728,6 +747,9 @@ class StructNew extends Instruction {
 
   StructNew(this.structType);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeBytes(const [0xFB, 0x00]);
@@ -743,6 +765,9 @@ class StructNewDefault extends Instruction {
 
   StructNewDefault(this.structType);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeBytes(const [0xFB, 0x01]);
@@ -823,6 +848,9 @@ class ArrayNewFixed extends Instruction {
 
   ArrayNewFixed(this.arrayType, this.length);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeBytes(const [0xFB, 0x08]);
@@ -839,6 +867,9 @@ class ArrayNew extends Instruction {
 
   ArrayNew(this.arrayType);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeBytes(const [0xFB, 0x06]);
@@ -854,6 +885,9 @@ class ArrayNewDefault extends Instruction {
 
   ArrayNewDefault(this.arrayType);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeBytes(const [0xFB, 0x07]);
@@ -995,17 +1029,26 @@ class BrOnCastFail extends Instruction {
 
 class ExternInternalize extends MultiByteInstruction {
   const ExternInternalize() : super(const [0xFB, 0x1A]);
+
+  @override
+  bool get isConstant => true;
 }
 
 class ExternExternalize extends MultiByteInstruction {
   const ExternExternalize() : super(const [0xFB, 0x1B]);
+
+  @override
+  bool get isConstant => true;
 }
 
 class I32Const extends Instruction {
   final int value;
 
   I32Const(this.value);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0x41);
@@ -1018,6 +1061,9 @@ class I64Const extends Instruction {
 
   I64Const(this.value);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0x42);
@@ -1030,6 +1076,9 @@ class F32Const extends Instruction {
 
   F32Const(this.value);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0x43);
@@ -1042,6 +1091,9 @@ class F64Const extends Instruction {
 
   F64Const(this.value);
 
+  @override
+  bool get isConstant => true;
+
   @override
   void serialize(Serializer s) {
     s.writeByte(0x44);