[wasm] Simplify Table.get/set

The TableType will need to be adapted for tracking wasm-gc
signatures. I just couldn't find a good reason why we'd need to store
the TableType on Table.get and Table.set?

Bug: 445356784
Change-Id: Ia115d287b27cc18f52a48ddce25b897f1a19b293
Reviewed-on: https://chrome-internal-review.googlesource.com/c/v8/fuzzilli/+/9123736
Reviewed-by: Manos Koukoutos <manoskouk@google.com>
Commit-Queue: Matthias Liedtke <mliedtke@google.com>

Author: Liedtke

Sources/Fuzzilli/Base/ProgramBuilder.swift

@@ -3747,14 +3747,14 @@ public class ProgramBuilder {
         public func wasmTableGet(tableRef: Variable, idx: Variable) -> Variable {
             let tableType = b.type(of: tableRef)
             let offsetType = tableType.wasmTableType!.isTable64 ? ILType.wasmi64 : ILType.wasmi32
-            return b.emit(WasmTableGet(tableType: tableType), withInputs: [tableRef, idx], types: [tableType, offsetType]).output
+            return b.emit(WasmTableGet(), withInputs: [tableRef, idx], types: [tableType, offsetType]).output
         }
 
         public func wasmTableSet(tableRef: Variable, idx: Variable, to value: Variable) {
             let tableType = b.type(of: tableRef)
             let elementType = tableType.wasmTableType!.elementType
             let offsetType = tableType.wasmTableType!.isTable64 ? ILType.wasmi64 : ILType.wasmi32
-            b.emit(WasmTableSet(tableType: tableType), withInputs: [tableRef, idx, value], types: [tableType, offsetType, elementType])
+            b.emit(WasmTableSet(), withInputs: [tableRef, idx, value], types: [tableType, offsetType, elementType])
         }
 
         @discardableResult

Sources/Fuzzilli/FuzzIL/Instruction.swift

@@ -1258,24 +1258,10 @@ extension Instruction: ProtobufConvertible {
                 $0.wasmStoreGlobal = Fuzzilli_Protobuf_WasmStoreGlobal.with {
                     $0.globalType = ILTypeToWasmTypeEnum(op.globalType)
                 }
-            case .wasmTableGet(let op):
-                $0.wasmTableGet = Fuzzilli_Protobuf_WasmTableGet.with {
-                    $0.elementType = ILTypeToWasmTypeEnum(op.tableType.elementType)
-                    $0.minSize = Int64(op.tableType.limits.min)
-                    if let max = op.tableType.limits.max {
-                        $0.maxSize = Int64(max)
-                    }
-                    $0.isTable64 = op.tableType.isTable64
-                }
-            case .wasmTableSet(let op):
-                $0.wasmTableSet = Fuzzilli_Protobuf_WasmTableSet.with {
-                    $0.elementType = ILTypeToWasmTypeEnum(op.tableType.elementType)
-                    $0.minSize = Int64(op.tableType.limits.min)
-                    if let max = op.tableType.limits.max {
-                        $0.maxSize = Int64(max)
-                    }
-                    $0.isTable64 = op.tableType.isTable64
-                }
+            case .wasmTableGet(_):
+                $0.wasmTableGet = Fuzzilli_Protobuf_WasmTableGet()
+            case .wasmTableSet(_):
+                $0.wasmTableSet = Fuzzilli_Protobuf_WasmTableSet()
             case .wasmCallIndirect(let op):
                 $0.wasmCallIndirect = Fuzzilli_Protobuf_WasmCallIndirect.with {
                     $0.parameterTypes = op.signature.parameterTypes.map(ILTypeToWasmTypeEnum)
@@ -2340,14 +2326,10 @@ extension Instruction: ProtobufConvertible {
             op = WasmLoadGlobal(globalType: WasmTypeEnumToILType(p.globalType))
         case .wasmStoreGlobal(let p):
             op = WasmStoreGlobal(globalType: WasmTypeEnumToILType(p.globalType))
-        case .wasmTableGet(let p):
-            op = WasmTableGet(tableType: .wasmTable(wasmTableType:
-                WasmTableType(elementType: WasmTypeEnumToILType(p.elementType),
-                              limits: Limits(min: Int(p.minSize), max: p.hasMaxSize ? Int(p.maxSize) : nil), isTable64: p.isTable64, knownEntries: [])))
-        case .wasmTableSet(let p):
-            op = WasmTableSet(tableType: .wasmTable(wasmTableType:
-                WasmTableType(elementType: WasmTypeEnumToILType(p.elementType),
-                              limits: Limits(min: Int(p.minSize), max: p.hasMaxSize ? Int(p.maxSize) : nil), isTable64: p.isTable64, knownEntries: [])))
+        case .wasmTableGet(_):
+            op = WasmTableGet()
+        case .wasmTableSet(_):
+            op = WasmTableSet()
         case .wasmCallIndirect(let p):
             let parameters = p.parameterTypes.map(WasmTypeEnumToILType)
             let outputs = p.outputTypes.map(WasmTypeEnumToILType)

Sources/Fuzzilli/FuzzIL/JSTyper.swift

@@ -768,10 +768,11 @@ public struct JSTyper: Analyzer {
             case .wasmStoreGlobal(_):
                 let definingInstruction = defUseAnalyzer.definition(of: instr.input(0))
                 dynamicObjectGroupManager.addWasmGlobal(withType: type(of: instr.input(0)), forDefinition: definingInstruction, forVariable: instr.input(0))
-            case .wasmTableGet(let op):
+            case .wasmTableGet(_):
                 let definingInstruction = defUseAnalyzer.definition(of: instr.input(0))
-                dynamicObjectGroupManager.addWasmTable(withType: type(of: instr.input(0)), forDefinition: definingInstruction, forVariable: instr.input(0))
-                setType(of: instr.output, to: op.tableType.elementType)
+                let tableType = type(of: instr.input(0))
+                dynamicObjectGroupManager.addWasmTable(withType: tableType, forDefinition: definingInstruction, forVariable: instr.input(0))
+                setType(of: instr.output, to: tableType.wasmTableType!.elementType)
             case .wasmTableSet(_):
                 let definingInstruction = defUseAnalyzer.definition(of: instr.input(0))
                 dynamicObjectGroupManager.addWasmTable(withType: type(of: instr.input(0)), forDefinition: definingInstruction, forVariable: instr.input(0))

Sources/Fuzzilli/FuzzIL/WasmOperations.swift

@@ -912,24 +912,15 @@ final class WasmStoreGlobal: WasmOperation {
 final class WasmTableGet: WasmOperation {
     override var opcode: Opcode { .wasmTableGet(self) }
 
-    let tableType: WasmTableType
-
-    init(tableType: ILType) {
-        assert(tableType.isWasmTableType)
-        self.tableType = tableType.wasmTableType!
-
+    init() {
         super.init(numInputs: 2, numOutputs: 1, requiredContext: [.wasmFunction])
     }
 }
 
 final class WasmTableSet: WasmOperation {
     override var opcode: Opcode { .wasmTableSet(self) }
 
-    let tableType: WasmTableType
-
-    init(tableType: ILType) {
-        assert(tableType.isWasmTableType)
-        self.tableType = tableType.wasmTableType!
+    init() {
         super.init(numInputs: 3, requiredContext: [.wasmFunction])
     }
 }

Sources/Fuzzilli/Protobuf/operations.pb.swift

@@ -4754,75 +4754,24 @@ public struct Fuzzilli_Protobuf_WasmStoreGlobal: Sendable {
   fileprivate var _globalType: Fuzzilli_Protobuf_WasmILType? = nil
 }
 
-/// WasmTableGet and WasmTableSet need a WasmTableType as input.
 public struct Fuzzilli_Protobuf_WasmTableGet: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
 
-  public var elementType: Fuzzilli_Protobuf_WasmILType {
-    get {_elementType ?? Fuzzilli_Protobuf_WasmILType()}
-    set {_elementType = newValue}
-  }
-  /// Returns true if `elementType` has been explicitly set.
-  public var hasElementType: Bool {self._elementType != nil}
-  /// Clears the value of `elementType`. Subsequent reads from it will return its default value.
-  public mutating func clearElementType() {self._elementType = nil}
-
-  public var minSize: Int64 = 0
-
-  public var maxSize: Int64 {
-    get {_maxSize ?? 0}
-    set {_maxSize = newValue}
-  }
-  /// Returns true if `maxSize` has been explicitly set.
-  public var hasMaxSize: Bool {self._maxSize != nil}
-  /// Clears the value of `maxSize`. Subsequent reads from it will return its default value.
-  public mutating func clearMaxSize() {self._maxSize = nil}
-
-  public var isTable64: Bool = false
-
   public var unknownFields = SwiftProtobuf.UnknownStorage()
 
   public init() {}
-
-  fileprivate var _elementType: Fuzzilli_Protobuf_WasmILType? = nil
-  fileprivate var _maxSize: Int64? = nil
 }
 
 public struct Fuzzilli_Protobuf_WasmTableSet: Sendable {
   // SwiftProtobuf.Message conformance is added in an extension below. See the
   // `Message` and `Message+*Additions` files in the SwiftProtobuf library for
   // methods supported on all messages.
 
-  public var elementType: Fuzzilli_Protobuf_WasmILType {
-    get {_elementType ?? Fuzzilli_Protobuf_WasmILType()}
-    set {_elementType = newValue}
-  }
-  /// Returns true if `elementType` has been explicitly set.
-  public var hasElementType: Bool {self._elementType != nil}
-  /// Clears the value of `elementType`. Subsequent reads from it will return its default value.
-  public mutating func clearElementType() {self._elementType = nil}
-
-  public var minSize: Int64 = 0
-
-  public var maxSize: Int64 {
-    get {_maxSize ?? 0}
-    set {_maxSize = newValue}
-  }
-  /// Returns true if `maxSize` has been explicitly set.
-  public var hasMaxSize: Bool {self._maxSize != nil}
-  /// Clears the value of `maxSize`. Subsequent reads from it will return its default value.
-  public mutating func clearMaxSize() {self._maxSize = nil}
-
-  public var isTable64: Bool = false
-
   public var unknownFields = SwiftProtobuf.UnknownStorage()
 
   public init() {}
-
-  fileprivate var _elementType: Fuzzilli_Protobuf_WasmILType? = nil
-  fileprivate var _maxSize: Int64? = nil
 }
 
 public struct Fuzzilli_Protobuf_WasmTableSize: Sendable {
@@ -12732,97 +12681,37 @@ extension Fuzzilli_Protobuf_WasmStoreGlobal: SwiftProtobuf.Message, SwiftProtobu
 
 extension Fuzzilli_Protobuf_WasmTableGet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   public static let protoMessageName: String = _protobuf_package + ".WasmTableGet"
-  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}elementType\0\u{1}minSize\0\u{1}maxSize\0\u{1}isTable64\0")
+  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
 
   public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
-    while let fieldNumber = try decoder.nextFieldNumber() {
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every case branch when no optimizations are
-      // enabled. https://github.com/apple/swift-protobuf/issues/1034
-      switch fieldNumber {
-      case 1: try { try decoder.decodeSingularMessageField(value: &self._elementType) }()
-      case 2: try { try decoder.decodeSingularInt64Field(value: &self.minSize) }()
-      case 3: try { try decoder.decodeSingularInt64Field(value: &self._maxSize) }()
-      case 4: try { try decoder.decodeSingularBoolField(value: &self.isTable64) }()
-      default: break
-      }
-    }
+    // Load everything into unknown fields
+    while try decoder.nextFieldNumber() != nil {}
   }
 
   public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._elementType {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    if self.minSize != 0 {
-      try visitor.visitSingularInt64Field(value: self.minSize, fieldNumber: 2)
-    }
-    try { if let v = self._maxSize {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 3)
-    } }()
-    if self.isTable64 != false {
-      try visitor.visitSingularBoolField(value: self.isTable64, fieldNumber: 4)
-    }
     try unknownFields.traverse(visitor: &visitor)
   }
 
   public static func ==(lhs: Fuzzilli_Protobuf_WasmTableGet, rhs: Fuzzilli_Protobuf_WasmTableGet) -> Bool {
-    if lhs._elementType != rhs._elementType {return false}
-    if lhs.minSize != rhs.minSize {return false}
-    if lhs._maxSize != rhs._maxSize {return false}
-    if lhs.isTable64 != rhs.isTable64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }
 }
 
 extension Fuzzilli_Protobuf_WasmTableSet: SwiftProtobuf.Message, SwiftProtobuf._MessageImplementationBase, SwiftProtobuf._ProtoNameProviding {
   public static let protoMessageName: String = _protobuf_package + ".WasmTableSet"
-  public static let _protobuf_nameMap = SwiftProtobuf._NameMap(bytecode: "\0\u{1}elementType\0\u{1}minSize\0\u{1}maxSize\0\u{1}isTable64\0")
+  public static let _protobuf_nameMap = SwiftProtobuf._NameMap()
 
   public mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws {
-    while let fieldNumber = try decoder.nextFieldNumber() {
-      // The use of inline closures is to circumvent an issue where the compiler
-      // allocates stack space for every case branch when no optimizations are
-      // enabled. https://github.com/apple/swift-protobuf/issues/1034
-      switch fieldNumber {
-      case 1: try { try decoder.decodeSingularMessageField(value: &self._elementType) }()
-      case 2: try { try decoder.decodeSingularInt64Field(value: &self.minSize) }()
-      case 3: try { try decoder.decodeSingularInt64Field(value: &self._maxSize) }()
-      case 4: try { try decoder.decodeSingularBoolField(value: &self.isTable64) }()
-      default: break
-      }
-    }
+    // Load everything into unknown fields
+    while try decoder.nextFieldNumber() != nil {}
   }
 
   public func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws {
-    // The use of inline closures is to circumvent an issue where the compiler
-    // allocates stack space for every if/case branch local when no optimizations
-    // are enabled. https://github.com/apple/swift-protobuf/issues/1034 and
-    // https://github.com/apple/swift-protobuf/issues/1182
-    try { if let v = self._elementType {
-      try visitor.visitSingularMessageField(value: v, fieldNumber: 1)
-    } }()
-    if self.minSize != 0 {
-      try visitor.visitSingularInt64Field(value: self.minSize, fieldNumber: 2)
-    }
-    try { if let v = self._maxSize {
-      try visitor.visitSingularInt64Field(value: v, fieldNumber: 3)
-    } }()
-    if self.isTable64 != false {
-      try visitor.visitSingularBoolField(value: self.isTable64, fieldNumber: 4)
-    }
     try unknownFields.traverse(visitor: &visitor)
   }
 
   public static func ==(lhs: Fuzzilli_Protobuf_WasmTableSet, rhs: Fuzzilli_Protobuf_WasmTableSet) -> Bool {
-    if lhs._elementType != rhs._elementType {return false}
-    if lhs.minSize != rhs.minSize {return false}
-    if lhs._maxSize != rhs._maxSize {return false}
-    if lhs.isTable64 != rhs.isTable64 {return false}
     if lhs.unknownFields != rhs.unknownFields {return false}
     return true
   }

Sources/Fuzzilli/Protobuf/operations.proto

@@ -1097,19 +1097,10 @@ message WasmStoreGlobal {
   WasmILType globalType = 2;
 }
 
-// WasmTableGet and WasmTableSet need a WasmTableType as input.
 message WasmTableGet {
-  WasmILType elementType = 1;
-  int64 minSize = 2;
-  optional int64 maxSize = 3;
-  bool isTable64 = 4;
 }
 
 message WasmTableSet {
-  WasmILType elementType = 1;
-  int64 minSize = 2;
-  optional int64 maxSize = 3;
-  bool isTable64 = 4;
 }
 
 message WasmTableSize {