| /* |
| * Copyright 2020 WebAssembly Community Group participants |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // Implements a switch on an expression class ID, and has a case for each id |
| // in which it runs delegates on the fields and immediates. You should include |
| // this file after defining the relevant DELEGATE_* macros. |
| // |
| // All defines used here are undefed automatically at the end for you. |
| // |
| // Most of the defines are necessary, and you will get an error if you forget |
| // them, but some are optional and some imply others, see below. |
| // |
| // The defines are as follows: |
| // |
| // DELEGATE_START(id) - called at the start of a case for an expression class. |
| // |
| // DELEGATE_END(id) - called at the end of a case. |
| // |
| // DELEGATE_GET_FIELD(id, field) - called to get a field by its name. This must |
| // know the object on which to get it, so it is just useful for the case |
| // where you operate on a single such object, but in that case it is nice |
| // because then other things can be defined automatically for you, see later. |
| // |
| // DELEGATE_FIELD_CHILD(id, field) - called for each child field (note: children |
| // are visited in reverse order, which is convenient for walking by pushing |
| // them to a stack first). |
| // |
| // DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(id, field) - called for each child field |
| // whose type is given by an immediate in the binary format. If you do not |
| // define this, then DELEGATE_FIELD_CHILD is called. |
| // |
| // DELEGATE_FIELD_OPTIONAL_CHILD(id, field) - called for a child that may not be |
| // present (like a Return's value). If you do not define this then |
| // DELEGATE_FIELD_CHILD is called. |
| // |
| // DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(id, field) - The previous two |
| // cases combined. If you do not define this, but you define exactly one of |
| // DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD and DELEGATE_FIELD_OPTIONAL_CHILD, that |
| // defined macro will be called. Defining both |
| // DELEGATE_FIELD_IMMEDIATE_TYPE_CHILD and DELEGATE_FIELD_OPTIONAL_CHILD without |
| // defining DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD is an error. If |
| // neither of the other macros are defined, then DELEGATE_FIELD_CHILD is called. |
| // |
| // DELEGATE_FIELD_CHILD_VECTOR(id, field) - called for a variable-sized vector |
| // of child pointers. If this is not defined, and DELEGATE_GET_FIELD is, then |
| // DELEGATE_FIELD_CHILD is called on them. |
| // |
| // DELEGATE_FIELD_INT(id, field) - called for an integer field (bool, enum, |
| // Index, int32, or int64). |
| // |
| // DELEGATE_FIELD_INT_ARRAY(id, field) - called for a std::array of fixed size |
| // of integer values (like a SIMD mask). If this is not defined, and |
| // DELEGATE_GET_FIELD is, then DELEGATE_FIELD_INT is called on them. |
| // |
| // DELEGATE_FIELD_INT_VECTOR(id, field) - called for a variable-sized vector |
| // of integer values. If this is not defined, and DELEGATE_GET_FIELD is, then |
| // DELEGATE_FIELD_INT is called on them. |
| // |
| // DELEGATE_FIELD_LITERAL(id, field) - called for a Literal. |
| // |
| // DELEGATE_FIELD_NAME(id, field) - called for a Name. |
| // |
| // DELEGATE_FIELD_NAME_VECTOR(id, field) - called for a variable-sized vector of |
| // names (like try's catch tag names). If this is not defined, and |
| // DELEGATE_GET_FIELD is, then DELEGATE_FIELD_CHILD is called on them. |
| // |
| // DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) - called for a scope name definition |
| // (like a block's name). |
| // |
| // DELEGATE_FIELD_SCOPE_NAME_USE(id, field) - called for a scope name use (like |
| // a break's target). |
| // |
| // DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) - called for a variable-sized |
| // vector of scope names (like a switch's targets). If this is not defined, |
| // and DELEGATE_GET_FIELD is, then DELEGATE_FIELD_SCOPE_NAME_USE is called on |
| // them. |
| // |
| // DELEGATE_FIELD_NAME_KIND(id, field, kind) - called for a field that contains |
| // the name of a ModuleItemKind (i.e., a top-level module entity like a table |
| // or a function). If this is not defined then DELEGATE_FIELD_NAME is called |
| // instead. |
| // |
| // DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) - called for a variable- |
| // sized vector of DELEGATE_FIELD_NAME_KIND. If this is not defined, and |
| // DELEGATE_GET_FIELD is, then DELEGATE_FIELD_NAME_KIND is called on them. |
| // Or, if this is not defined by DELEGATE_FIELD_NAME_VECTOR is, then that is |
| // called. |
| // |
| // DELEGATE_FIELD_TYPE(id, field) - called for a Type. |
| // |
| // DELEGATE_FIELD_TYPE_VECTOR(id, field) - called for a variable-sized vector |
| // of Types. If this is not defined, and DELEGATE_GET_FIELD is, then |
| // DELEGATE_FIELD_TYPE is called on them. |
| // |
| // DELEGATE_FIELD_HEAPTYPE(id, field) - called for a HeapType. |
| // |
| // DELEGATE_FIELD_ADDRESS(id, field) - called for an Address. |
| |
| #ifndef DELEGATE_START |
| #define DELEGATE_START(id) |
| #endif |
| |
| #ifndef DELEGATE_END |
| #define DELEGATE_END(id) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_CHILD |
| #error please define DELEGATE_FIELD_CHILD(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD |
| #if defined(DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD) && !defined(DELEGATE_FIELD_OPTIONAL_CHILD) |
| #define DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(id, field) DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(id, field) |
| #elif !defined(DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD) && defined(DELEGATE_FIELD_OPTIONAL_CHILD) |
| #define DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(id, field) DELEGATE_FIELD_OPTIONAL_CHILD(id, field) |
| #elif !defined(DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD) && !defined(DELEGATE_FIELD_OPTIONAL_CHILD) |
| #define DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(id, field) DELEGATE_FIELD_CHILD(id, field) |
| #else |
| #error please define DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD |
| #define DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(id, field) DELEGATE_FIELD_CHILD(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_OPTIONAL_CHILD |
| #define DELEGATE_FIELD_OPTIONAL_CHILD(id, field) DELEGATE_FIELD_CHILD(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_CHILD_VECTOR |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_CHILD_VECTOR(id, field) \ |
| for (int i = int((DELEGATE_GET_FIELD(id, field)).size()) - 1; i >= 0; i--) { \ |
| DELEGATE_FIELD_CHILD(id, field[i]) \ |
| } |
| #else |
| #error please define DELEGATE_FIELD_CHILD_VECTOR(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_INT |
| #error please define DELEGATE_FIELD_INT(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_INT_ARRAY |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_INT_ARRAY(id, field) \ |
| for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ |
| DELEGATE_FIELD_INT(id, field[i]) \ |
| } |
| #else |
| #error please define DELEGATE_FIELD_INT_ARRAY(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_INT_VECTOR |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_INT_VECTOR(id, field) \ |
| for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ |
| DELEGATE_FIELD_INT(id, field[i]) \ |
| } |
| #else |
| #error please define DELEGATE_FIELD_INT_VECTOR(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_LITERAL |
| #error please define DELEGATE_FIELD_LITERAL(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_NAME |
| #error please define DELEGATE_FIELD_NAME(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_NAME_VECTOR |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_NAME_VECTOR(id, field) \ |
| for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ |
| DELEGATE_FIELD_NAME(id, field[i]) \ |
| } |
| #else |
| #error please define DELEGATE_FIELD_NAME_VECTOR(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_SCOPE_NAME_DEF |
| #error please define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_SCOPE_NAME_USE |
| #error please define DELEGATE_FIELD_SCOPE_NAME_USE(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) \ |
| for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ |
| DELEGATE_FIELD_SCOPE_NAME_USE(id, field[i]) \ |
| } |
| #else |
| #error please define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_NAME_KIND |
| #define DELEGATE_FIELD_NAME_KIND(id, field, kind) DELEGATE_FIELD_NAME(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_NAME_KIND_VECTOR |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) \ |
| for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ |
| DELEGATE_FIELD_NAME_KIND(id, field[i], kind) \ |
| } |
| #else |
| #define DELEGATE_FIELD_NAME_KIND_VECTOR(id, field, kind) \ |
| DELEGATE_FIELD_NAME_VECTOR(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_TYPE |
| #error please define DELEGATE_FIELD_TYPE(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_TYPE_VECTOR |
| #ifdef DELEGATE_GET_FIELD |
| #define DELEGATE_FIELD_TYPE_VECTOR(id, field) \ |
| for (Index i = 0; i < (DELEGATE_GET_FIELD(id, field)).size(); i++) { \ |
| DELEGATE_FIELD_TYPE(id, field[i]) \ |
| } |
| #else |
| #error please define DELEGATE_FIELD_TYPE_VECTOR(id, field) |
| #endif |
| #endif |
| |
| #ifndef DELEGATE_FIELD_HEAPTYPE |
| #error please define DELEGATE_FIELD_HEAPTYPE(id, field) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_ADDRESS |
| #error please define DELEGATE_FIELD_ADDRESS(id, field) |
| #endif |
| |
| // By default we emit a switch and cases, but that can be customized using the |
| // following: |
| |
| |
| #ifndef DELEGATE_FIELD_MAIN_START |
| #define DELEGATE_FIELD_MAIN_START \ |
| switch (DELEGATE_ID) { \ |
| case Expression::Id::InvalidId: \ |
| case Expression::Id::NumExpressionIds: { \ |
| WASM_UNREACHABLE("unexpected expression type"); \ |
| } |
| #endif |
| |
| #ifndef DELEGATE_FIELD_CASE_START |
| #define DELEGATE_FIELD_CASE_START(id) \ |
| case Expression::Id::id##Id: { \ |
| DELEGATE_START(id) |
| #endif |
| |
| #ifndef DELEGATE_FIELD_CASE_END |
| #define DELEGATE_FIELD_CASE_END(id) \ |
| DELEGATE_END(id) \ |
| break; \ |
| } |
| #endif |
| |
| #ifndef DELEGATE_FIELD_MAIN_END |
| #define DELEGATE_FIELD_MAIN_END } |
| #endif |
| |
| DELEGATE_FIELD_MAIN_START |
| |
| DELEGATE_FIELD_CASE_START(Block) |
| DELEGATE_FIELD_CHILD_VECTOR(Block, list) |
| DELEGATE_FIELD_SCOPE_NAME_DEF(Block, name) |
| DELEGATE_FIELD_CASE_END(Block) |
| |
| DELEGATE_FIELD_CASE_START(If) |
| DELEGATE_FIELD_OPTIONAL_CHILD(If, ifFalse) |
| DELEGATE_FIELD_CHILD(If, ifTrue) |
| DELEGATE_FIELD_CHILD(If, condition) |
| DELEGATE_FIELD_CASE_END(If) |
| |
| DELEGATE_FIELD_CASE_START(Loop) |
| DELEGATE_FIELD_CHILD(Loop, body) |
| DELEGATE_FIELD_SCOPE_NAME_DEF(Loop, name) |
| DELEGATE_FIELD_CASE_END(Loop) |
| |
| DELEGATE_FIELD_CASE_START(Break) |
| DELEGATE_FIELD_OPTIONAL_CHILD(Break, condition) |
| DELEGATE_FIELD_OPTIONAL_CHILD(Break, value) |
| DELEGATE_FIELD_SCOPE_NAME_USE(Break, name) |
| DELEGATE_FIELD_CASE_END(Break) |
| |
| DELEGATE_FIELD_CASE_START(Switch) |
| DELEGATE_FIELD_CHILD(Switch, condition) |
| DELEGATE_FIELD_OPTIONAL_CHILD(Switch, value) |
| DELEGATE_FIELD_SCOPE_NAME_USE(Switch, default_) |
| DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Switch, targets) |
| DELEGATE_FIELD_CASE_END(Switch) |
| |
| DELEGATE_FIELD_CASE_START(Call) |
| DELEGATE_FIELD_CHILD_VECTOR(Call, operands) |
| DELEGATE_FIELD_NAME_KIND(Call, target, ModuleItemKind::Function) |
| DELEGATE_FIELD_INT(Call, isReturn) |
| DELEGATE_FIELD_CASE_END(Call) |
| |
| DELEGATE_FIELD_CASE_START(CallIndirect) |
| DELEGATE_FIELD_CHILD(CallIndirect, target) |
| DELEGATE_FIELD_NAME_KIND(CallIndirect, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CHILD_VECTOR(CallIndirect, operands) |
| DELEGATE_FIELD_HEAPTYPE(CallIndirect, heapType) |
| DELEGATE_FIELD_INT(CallIndirect, isReturn) |
| DELEGATE_FIELD_CASE_END(CallIndirect) |
| |
| DELEGATE_FIELD_CASE_START(LocalGet) |
| DELEGATE_FIELD_INT(LocalGet, index) |
| DELEGATE_FIELD_CASE_END(LocalGet) |
| |
| DELEGATE_FIELD_CASE_START(LocalSet) |
| DELEGATE_FIELD_CHILD(LocalSet, value) |
| DELEGATE_FIELD_INT(LocalSet, index) |
| DELEGATE_FIELD_CASE_END(LocalSet) |
| |
| DELEGATE_FIELD_CASE_START(GlobalGet) |
| DELEGATE_FIELD_NAME_KIND(GlobalGet, name, ModuleItemKind::Global) |
| DELEGATE_FIELD_CASE_END(GlobalGet) |
| |
| DELEGATE_FIELD_CASE_START(GlobalSet) |
| DELEGATE_FIELD_CHILD(GlobalSet, value) |
| DELEGATE_FIELD_NAME_KIND(GlobalSet, name, ModuleItemKind::Global) |
| DELEGATE_FIELD_CASE_END(GlobalSet) |
| |
| DELEGATE_FIELD_CASE_START(Load) |
| DELEGATE_FIELD_CHILD(Load, ptr) |
| DELEGATE_FIELD_INT(Load, bytes) |
| DELEGATE_FIELD_INT(Load, signed_) |
| DELEGATE_FIELD_ADDRESS(Load, offset) |
| DELEGATE_FIELD_ADDRESS(Load, align) |
| DELEGATE_FIELD_INT(Load, isAtomic) |
| DELEGATE_FIELD_NAME_KIND(Load, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(Load) |
| |
| DELEGATE_FIELD_CASE_START(Store) |
| DELEGATE_FIELD_CHILD(Store, value) |
| DELEGATE_FIELD_CHILD(Store, ptr) |
| DELEGATE_FIELD_INT(Store, bytes) |
| DELEGATE_FIELD_ADDRESS(Store, offset) |
| DELEGATE_FIELD_ADDRESS(Store, align) |
| DELEGATE_FIELD_INT(Store, isAtomic) |
| DELEGATE_FIELD_TYPE(Store, valueType) |
| DELEGATE_FIELD_NAME_KIND(Store, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(Store) |
| |
| DELEGATE_FIELD_CASE_START(AtomicRMW) |
| DELEGATE_FIELD_CHILD(AtomicRMW, value) |
| DELEGATE_FIELD_CHILD(AtomicRMW, ptr) |
| DELEGATE_FIELD_INT(AtomicRMW, op) |
| DELEGATE_FIELD_INT(AtomicRMW, bytes) |
| DELEGATE_FIELD_ADDRESS(AtomicRMW, offset) |
| DELEGATE_FIELD_NAME_KIND(AtomicRMW, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(AtomicRMW) |
| |
| DELEGATE_FIELD_CASE_START(AtomicCmpxchg) |
| DELEGATE_FIELD_CHILD(AtomicCmpxchg, replacement) |
| DELEGATE_FIELD_CHILD(AtomicCmpxchg, expected) |
| DELEGATE_FIELD_CHILD(AtomicCmpxchg, ptr) |
| DELEGATE_FIELD_INT(AtomicCmpxchg, bytes) |
| DELEGATE_FIELD_ADDRESS(AtomicCmpxchg, offset) |
| DELEGATE_FIELD_NAME_KIND(AtomicCmpxchg, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(AtomicCmpxchg) |
| |
| DELEGATE_FIELD_CASE_START(AtomicWait) |
| DELEGATE_FIELD_CHILD(AtomicWait, timeout) |
| DELEGATE_FIELD_CHILD(AtomicWait, expected) |
| DELEGATE_FIELD_CHILD(AtomicWait, ptr) |
| DELEGATE_FIELD_ADDRESS(AtomicWait, offset) |
| DELEGATE_FIELD_TYPE(AtomicWait, expectedType) |
| DELEGATE_FIELD_NAME_KIND(AtomicWait, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(AtomicWait) |
| |
| DELEGATE_FIELD_CASE_START(AtomicNotify) |
| DELEGATE_FIELD_CHILD(AtomicNotify, notifyCount) |
| DELEGATE_FIELD_CHILD(AtomicNotify, ptr) |
| DELEGATE_FIELD_ADDRESS(AtomicNotify, offset) |
| DELEGATE_FIELD_NAME_KIND(AtomicNotify, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(AtomicNotify) |
| |
| DELEGATE_FIELD_CASE_START(AtomicFence) |
| DELEGATE_FIELD_INT(AtomicFence, order) |
| DELEGATE_FIELD_CASE_END(AtomicFence) |
| |
| DELEGATE_FIELD_CASE_START(Pause) |
| DELEGATE_FIELD_CASE_END(Pause) |
| |
| DELEGATE_FIELD_CASE_START(SIMDExtract) |
| DELEGATE_FIELD_CHILD(SIMDExtract, vec) |
| DELEGATE_FIELD_INT(SIMDExtract, op) |
| DELEGATE_FIELD_INT(SIMDExtract, index) |
| DELEGATE_FIELD_CASE_END(SIMDExtract) |
| |
| DELEGATE_FIELD_CASE_START(SIMDReplace) |
| DELEGATE_FIELD_CHILD(SIMDReplace, value) |
| DELEGATE_FIELD_CHILD(SIMDReplace, vec) |
| DELEGATE_FIELD_INT(SIMDReplace, op) |
| DELEGATE_FIELD_INT(SIMDReplace, index) |
| DELEGATE_FIELD_CASE_END(SIMDReplace) |
| |
| DELEGATE_FIELD_CASE_START(SIMDShuffle) |
| DELEGATE_FIELD_CHILD(SIMDShuffle, right) |
| DELEGATE_FIELD_CHILD(SIMDShuffle, left) |
| DELEGATE_FIELD_INT_ARRAY(SIMDShuffle, mask) |
| DELEGATE_FIELD_CASE_END(SIMDShuffle) |
| |
| DELEGATE_FIELD_CASE_START(SIMDTernary) |
| DELEGATE_FIELD_CHILD(SIMDTernary, c) |
| DELEGATE_FIELD_CHILD(SIMDTernary, b) |
| DELEGATE_FIELD_CHILD(SIMDTernary, a) |
| DELEGATE_FIELD_INT(SIMDTernary, op) |
| DELEGATE_FIELD_CASE_END(SIMDTernary) |
| |
| DELEGATE_FIELD_CASE_START(SIMDShift) |
| DELEGATE_FIELD_CHILD(SIMDShift, shift) |
| DELEGATE_FIELD_CHILD(SIMDShift, vec) |
| DELEGATE_FIELD_INT(SIMDShift, op) |
| DELEGATE_FIELD_CASE_END(SIMDShift) |
| |
| DELEGATE_FIELD_CASE_START(SIMDLoad) |
| DELEGATE_FIELD_CHILD(SIMDLoad, ptr) |
| DELEGATE_FIELD_INT(SIMDLoad, op) |
| DELEGATE_FIELD_ADDRESS(SIMDLoad, offset) |
| DELEGATE_FIELD_ADDRESS(SIMDLoad, align) |
| DELEGATE_FIELD_NAME_KIND(SIMDLoad, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(SIMDLoad) |
| |
| DELEGATE_FIELD_CASE_START(SIMDLoadStoreLane) |
| DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, vec) |
| DELEGATE_FIELD_CHILD(SIMDLoadStoreLane, ptr) |
| DELEGATE_FIELD_INT(SIMDLoadStoreLane, op) |
| DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, offset) |
| DELEGATE_FIELD_ADDRESS(SIMDLoadStoreLane, align) |
| DELEGATE_FIELD_INT(SIMDLoadStoreLane, index) |
| DELEGATE_FIELD_NAME_KIND(SIMDLoadStoreLane, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(SIMDLoadStoreLane) |
| |
| DELEGATE_FIELD_CASE_START(MemoryInit) |
| DELEGATE_FIELD_CHILD(MemoryInit, size) |
| DELEGATE_FIELD_CHILD(MemoryInit, offset) |
| DELEGATE_FIELD_CHILD(MemoryInit, dest) |
| DELEGATE_FIELD_NAME_KIND(MemoryInit, segment, ModuleItemKind::DataSegment) |
| DELEGATE_FIELD_NAME_KIND(MemoryInit, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(MemoryInit) |
| |
| DELEGATE_FIELD_CASE_START(DataDrop) |
| DELEGATE_FIELD_NAME_KIND(DataDrop, segment, ModuleItemKind::DataSegment) |
| DELEGATE_FIELD_CASE_END(DataDrop) |
| |
| DELEGATE_FIELD_CASE_START(MemoryCopy) |
| DELEGATE_FIELD_CHILD(MemoryCopy, size) |
| DELEGATE_FIELD_CHILD(MemoryCopy, source) |
| DELEGATE_FIELD_CHILD(MemoryCopy, dest) |
| DELEGATE_FIELD_NAME_KIND(MemoryCopy, sourceMemory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_NAME_KIND(MemoryCopy, destMemory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(MemoryCopy) |
| |
| DELEGATE_FIELD_CASE_START(MemoryFill) |
| DELEGATE_FIELD_CHILD(MemoryFill, size) |
| DELEGATE_FIELD_CHILD(MemoryFill, value) |
| DELEGATE_FIELD_CHILD(MemoryFill, dest) |
| DELEGATE_FIELD_NAME_KIND(MemoryFill, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(MemoryFill) |
| |
| DELEGATE_FIELD_CASE_START(Const) |
| DELEGATE_FIELD_LITERAL(Const, value) |
| DELEGATE_FIELD_CASE_END(Const) |
| |
| DELEGATE_FIELD_CASE_START(Unary) |
| DELEGATE_FIELD_CHILD(Unary, value) |
| DELEGATE_FIELD_INT(Unary, op) |
| DELEGATE_FIELD_CASE_END(Unary) |
| |
| DELEGATE_FIELD_CASE_START(Binary) |
| DELEGATE_FIELD_CHILD(Binary, right) |
| DELEGATE_FIELD_CHILD(Binary, left) |
| DELEGATE_FIELD_INT(Binary, op) |
| DELEGATE_FIELD_CASE_END(Binary) |
| |
| DELEGATE_FIELD_CASE_START(Select) |
| DELEGATE_FIELD_CHILD(Select, condition) |
| DELEGATE_FIELD_CHILD(Select, ifFalse) |
| DELEGATE_FIELD_CHILD(Select, ifTrue) |
| DELEGATE_FIELD_CASE_END(Select) |
| |
| DELEGATE_FIELD_CASE_START(Drop) |
| DELEGATE_FIELD_CHILD(Drop, value) |
| DELEGATE_FIELD_CASE_END(Drop) |
| |
| DELEGATE_FIELD_CASE_START(Return) |
| DELEGATE_FIELD_OPTIONAL_CHILD(Return, value) |
| DELEGATE_FIELD_CASE_END(Return) |
| |
| DELEGATE_FIELD_CASE_START(MemorySize) |
| DELEGATE_FIELD_NAME_KIND(MemorySize, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(MemorySize) |
| |
| DELEGATE_FIELD_CASE_START(MemoryGrow) |
| DELEGATE_FIELD_CHILD(MemoryGrow, delta) |
| DELEGATE_FIELD_NAME_KIND(MemoryGrow, memory, ModuleItemKind::Memory) |
| DELEGATE_FIELD_CASE_END(MemoryGrow) |
| |
| DELEGATE_FIELD_CASE_START(RefNull) |
| DELEGATE_FIELD_CASE_END(RefNull) |
| |
| DELEGATE_FIELD_CASE_START(RefIsNull) |
| DELEGATE_FIELD_CHILD(RefIsNull, value) |
| DELEGATE_FIELD_CASE_END(RefIsNull) |
| |
| DELEGATE_FIELD_CASE_START(RefFunc) |
| DELEGATE_FIELD_NAME_KIND(RefFunc, func, ModuleItemKind::Function) |
| DELEGATE_FIELD_CASE_END(RefFunc) |
| |
| DELEGATE_FIELD_CASE_START(RefEq) |
| DELEGATE_FIELD_CHILD(RefEq, right) |
| DELEGATE_FIELD_CHILD(RefEq, left) |
| DELEGATE_FIELD_CASE_END(RefEq) |
| |
| DELEGATE_FIELD_CASE_START(TableGet) |
| DELEGATE_FIELD_CHILD(TableGet, index) |
| DELEGATE_FIELD_NAME_KIND(TableGet, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableGet) |
| |
| DELEGATE_FIELD_CASE_START(TableSet) |
| DELEGATE_FIELD_CHILD(TableSet, value) |
| DELEGATE_FIELD_CHILD(TableSet, index) |
| DELEGATE_FIELD_NAME_KIND(TableSet, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableSet) |
| |
| DELEGATE_FIELD_CASE_START(TableSize) |
| DELEGATE_FIELD_NAME_KIND(TableSize, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableSize) |
| |
| DELEGATE_FIELD_CASE_START(TableGrow) |
| DELEGATE_FIELD_CHILD(TableGrow, delta) |
| DELEGATE_FIELD_CHILD(TableGrow, value) |
| DELEGATE_FIELD_NAME_KIND(TableGrow, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableGrow) |
| |
| DELEGATE_FIELD_CASE_START(TableFill) |
| DELEGATE_FIELD_CHILD(TableFill, size) |
| DELEGATE_FIELD_CHILD(TableFill, value) |
| DELEGATE_FIELD_CHILD(TableFill, dest) |
| DELEGATE_FIELD_NAME_KIND(TableFill, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableFill) |
| |
| DELEGATE_FIELD_CASE_START(TableCopy) |
| DELEGATE_FIELD_CHILD(TableCopy, size) |
| DELEGATE_FIELD_CHILD(TableCopy, source) |
| DELEGATE_FIELD_CHILD(TableCopy, dest) |
| DELEGATE_FIELD_NAME_KIND(TableCopy, sourceTable, ModuleItemKind::Table) |
| DELEGATE_FIELD_NAME_KIND(TableCopy, destTable, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableCopy) |
| |
| DELEGATE_FIELD_CASE_START(TableInit) |
| DELEGATE_FIELD_CHILD(TableInit, size) |
| DELEGATE_FIELD_CHILD(TableInit, offset) |
| DELEGATE_FIELD_CHILD(TableInit, dest) |
| DELEGATE_FIELD_NAME_KIND(TableInit, segment, ModuleItemKind::ElementSegment) |
| DELEGATE_FIELD_NAME_KIND(TableInit, table, ModuleItemKind::Table) |
| DELEGATE_FIELD_CASE_END(TableInit) |
| |
| DELEGATE_FIELD_CASE_START(ElemDrop) |
| DELEGATE_FIELD_NAME_KIND(ElemDrop, segment, ModuleItemKind::ElementSegment) |
| DELEGATE_FIELD_CASE_END(ElemDrop) |
| |
| DELEGATE_FIELD_CASE_START(Try) |
| DELEGATE_FIELD_SCOPE_NAME_USE(Try, delegateTarget) |
| DELEGATE_FIELD_CHILD_VECTOR(Try, catchBodies) |
| DELEGATE_FIELD_NAME_KIND_VECTOR(Try, catchTags, ModuleItemKind::Tag) |
| DELEGATE_FIELD_SCOPE_NAME_DEF(Try, name) |
| DELEGATE_FIELD_CHILD(Try, body) |
| DELEGATE_FIELD_CASE_END(Try) |
| |
| DELEGATE_FIELD_CASE_START(TryTable) |
| DELEGATE_FIELD_TYPE_VECTOR(TryTable, sentTypes) |
| DELEGATE_FIELD_INT_VECTOR(TryTable, catchRefs) |
| DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(TryTable, catchDests) |
| DELEGATE_FIELD_NAME_KIND_VECTOR(TryTable, catchTags, ModuleItemKind::Tag) |
| DELEGATE_FIELD_CHILD(TryTable, body) |
| DELEGATE_FIELD_CASE_END(TryTable) |
| |
| DELEGATE_FIELD_CASE_START(Throw) |
| DELEGATE_FIELD_CHILD_VECTOR(Throw, operands) |
| DELEGATE_FIELD_NAME_KIND(Throw, tag, ModuleItemKind::Tag) |
| DELEGATE_FIELD_CASE_END(Throw) |
| |
| DELEGATE_FIELD_CASE_START(Rethrow) |
| DELEGATE_FIELD_SCOPE_NAME_USE(Rethrow, target) |
| DELEGATE_FIELD_CASE_END(Rethrow) |
| |
| DELEGATE_FIELD_CASE_START(ThrowRef) |
| DELEGATE_FIELD_CHILD(ThrowRef, exnref) |
| DELEGATE_FIELD_CASE_END(ThrowRef) |
| |
| DELEGATE_FIELD_CASE_START(Nop) |
| DELEGATE_FIELD_CASE_END(Nop) |
| |
| DELEGATE_FIELD_CASE_START(Unreachable) |
| DELEGATE_FIELD_CASE_END(Unreachable) |
| |
| DELEGATE_FIELD_CASE_START(Pop) |
| DELEGATE_FIELD_CASE_END(Pop) |
| |
| DELEGATE_FIELD_CASE_START(TupleMake) |
| DELEGATE_FIELD_CHILD_VECTOR(TupleMake, operands) |
| DELEGATE_FIELD_CASE_END(TupleMake) |
| |
| DELEGATE_FIELD_CASE_START(TupleExtract) |
| DELEGATE_FIELD_CHILD(TupleExtract, tuple) |
| DELEGATE_FIELD_INT(TupleExtract, index) |
| DELEGATE_FIELD_CASE_END(TupleExtract) |
| |
| DELEGATE_FIELD_CASE_START(RefI31) |
| DELEGATE_FIELD_CHILD(RefI31, value) |
| DELEGATE_FIELD_CASE_END(RefI31) |
| |
| DELEGATE_FIELD_CASE_START(I31Get) |
| DELEGATE_FIELD_CHILD(I31Get, i31) |
| DELEGATE_FIELD_INT(I31Get, signed_) |
| DELEGATE_FIELD_CASE_END(I31Get) |
| |
| DELEGATE_FIELD_CASE_START(CallRef) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(CallRef, target) |
| DELEGATE_FIELD_CHILD_VECTOR(CallRef, operands) |
| DELEGATE_FIELD_INT(CallRef, isReturn) |
| DELEGATE_FIELD_CASE_END(CallRef) |
| |
| DELEGATE_FIELD_CASE_START(RefTest) |
| DELEGATE_FIELD_TYPE(RefTest, castType) |
| DELEGATE_FIELD_CHILD(RefTest, ref) |
| DELEGATE_FIELD_CASE_END(RefTest) |
| |
| DELEGATE_FIELD_CASE_START(RefCast) |
| DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(RefCast, desc) |
| DELEGATE_FIELD_CHILD(RefCast, ref) |
| DELEGATE_FIELD_CASE_END(RefCast) |
| |
| DELEGATE_FIELD_CASE_START(RefGetDesc) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(RefGetDesc, ref) |
| DELEGATE_FIELD_CASE_END(RefGetDesc) |
| |
| DELEGATE_FIELD_CASE_START(BrOn) |
| DELEGATE_FIELD_INT(BrOn, op) |
| DELEGATE_FIELD_SCOPE_NAME_USE(BrOn, name) |
| DELEGATE_FIELD_TYPE(BrOn, castType) |
| DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD(BrOn, desc) |
| DELEGATE_FIELD_CHILD(BrOn, ref) |
| DELEGATE_FIELD_CASE_END(BrOn) |
| |
| DELEGATE_FIELD_CASE_START(StructNew) |
| DELEGATE_FIELD_OPTIONAL_CHILD(StructNew, desc) |
| DELEGATE_FIELD_CHILD_VECTOR(StructNew, operands) |
| DELEGATE_FIELD_CASE_END(StructNew) |
| |
| DELEGATE_FIELD_CASE_START(StructGet) |
| DELEGATE_FIELD_INT(StructGet, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructGet, ref) |
| DELEGATE_FIELD_INT(StructGet, signed_) |
| DELEGATE_FIELD_INT(StructGet, order) |
| DELEGATE_FIELD_CASE_END(StructGet) |
| |
| DELEGATE_FIELD_CASE_START(StructSet) |
| DELEGATE_FIELD_INT(StructSet, index) |
| DELEGATE_FIELD_CHILD(StructSet, value) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructSet, ref) |
| DELEGATE_FIELD_INT(StructSet, order) |
| DELEGATE_FIELD_CASE_END(StructSet) |
| |
| DELEGATE_FIELD_CASE_START(StructRMW) |
| DELEGATE_FIELD_INT(StructRMW, op) |
| DELEGATE_FIELD_INT(StructRMW, index) |
| DELEGATE_FIELD_CHILD(StructRMW, value) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructRMW, ref) |
| DELEGATE_FIELD_INT(StructRMW, order) |
| DELEGATE_FIELD_CASE_END(StructRMW) |
| |
| DELEGATE_FIELD_CASE_START(StructCmpxchg) |
| DELEGATE_FIELD_INT(StructCmpxchg, index) |
| DELEGATE_FIELD_CHILD(StructCmpxchg, replacement) |
| DELEGATE_FIELD_CHILD(StructCmpxchg, expected) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StructCmpxchg, ref) |
| DELEGATE_FIELD_INT(StructCmpxchg, order) |
| DELEGATE_FIELD_CASE_END(StructCmpxchg) |
| |
| DELEGATE_FIELD_CASE_START(ArrayNew) |
| DELEGATE_FIELD_CHILD(ArrayNew, size) |
| DELEGATE_FIELD_OPTIONAL_CHILD(ArrayNew, init) |
| DELEGATE_FIELD_CASE_END(ArrayNew) |
| |
| DELEGATE_FIELD_CASE_START(ArrayNewData) |
| DELEGATE_FIELD_NAME_KIND(ArrayNewData, segment, ModuleItemKind::DataSegment) |
| DELEGATE_FIELD_CHILD(ArrayNewData, size) |
| DELEGATE_FIELD_CHILD(ArrayNewData, offset) |
| DELEGATE_FIELD_CASE_END(ArrayNewData) |
| |
| DELEGATE_FIELD_CASE_START(ArrayNewElem) |
| DELEGATE_FIELD_NAME_KIND(ArrayNewElem, segment, ModuleItemKind::ElementSegment) |
| DELEGATE_FIELD_CHILD(ArrayNewElem, size) |
| DELEGATE_FIELD_CHILD(ArrayNewElem, offset) |
| DELEGATE_FIELD_CASE_END(ArrayNewElem) |
| |
| DELEGATE_FIELD_CASE_START(ArrayNewFixed) |
| DELEGATE_FIELD_CHILD_VECTOR(ArrayNewFixed, values) |
| DELEGATE_FIELD_CASE_END(ArrayNewFixed) |
| |
| DELEGATE_FIELD_CASE_START(ArrayGet) |
| DELEGATE_FIELD_CHILD(ArrayGet, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayGet, ref) |
| DELEGATE_FIELD_INT(ArrayGet, signed_) |
| DELEGATE_FIELD_INT(ArraySet, order) |
| DELEGATE_FIELD_CASE_END(ArrayGet) |
| |
| DELEGATE_FIELD_CASE_START(ArraySet) |
| DELEGATE_FIELD_CHILD(ArraySet, value) |
| DELEGATE_FIELD_CHILD(ArraySet, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArraySet, ref) |
| DELEGATE_FIELD_INT(ArraySet, order) |
| DELEGATE_FIELD_CASE_END(ArraySet) |
| |
| DELEGATE_FIELD_CASE_START(ArrayLen) |
| DELEGATE_FIELD_CHILD(ArrayLen, ref) |
| DELEGATE_FIELD_CASE_END(ArrayLen) |
| |
| DELEGATE_FIELD_CASE_START(ArrayCopy) |
| DELEGATE_FIELD_CHILD(ArrayCopy, length) |
| DELEGATE_FIELD_CHILD(ArrayCopy, srcIndex) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayCopy, srcRef) |
| DELEGATE_FIELD_CHILD(ArrayCopy, destIndex) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayCopy, destRef) |
| DELEGATE_FIELD_CASE_END(ArrayCopy) |
| |
| DELEGATE_FIELD_CASE_START(ArrayFill) |
| DELEGATE_FIELD_CHILD(ArrayFill, size) |
| DELEGATE_FIELD_CHILD(ArrayFill, value) |
| DELEGATE_FIELD_CHILD(ArrayFill, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayFill, ref) |
| DELEGATE_FIELD_CASE_END(ArrayFill) |
| |
| DELEGATE_FIELD_CASE_START(ArrayInitData) |
| DELEGATE_FIELD_NAME_KIND(ArrayInitData, segment, ModuleItemKind::DataSegment) |
| DELEGATE_FIELD_CHILD(ArrayInitData, size) |
| DELEGATE_FIELD_CHILD(ArrayInitData, offset) |
| DELEGATE_FIELD_CHILD(ArrayInitData, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayInitData, ref) |
| DELEGATE_FIELD_CASE_END(ArrayInitData) |
| |
| DELEGATE_FIELD_CASE_START(ArrayInitElem) |
| DELEGATE_FIELD_NAME_KIND(ArrayInitElem, segment, ModuleItemKind::ElementSegment) |
| DELEGATE_FIELD_CHILD(ArrayInitElem, size) |
| DELEGATE_FIELD_CHILD(ArrayInitElem, offset) |
| DELEGATE_FIELD_CHILD(ArrayInitElem, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayInitElem, ref) |
| DELEGATE_FIELD_CASE_END(ArrayInitElem) |
| |
| DELEGATE_FIELD_CASE_START(ArrayRMW) |
| DELEGATE_FIELD_INT(ArrayRMW, op) |
| DELEGATE_FIELD_CHILD(ArrayRMW, value) |
| DELEGATE_FIELD_CHILD(ArrayRMW, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayRMW, ref) |
| DELEGATE_FIELD_INT(ArrayRMW, order) |
| DELEGATE_FIELD_CASE_END(ArrayRMW) |
| |
| DELEGATE_FIELD_CASE_START(ArrayCmpxchg) |
| DELEGATE_FIELD_CHILD(ArrayCmpxchg, replacement) |
| DELEGATE_FIELD_CHILD(ArrayCmpxchg, expected) |
| DELEGATE_FIELD_CHILD(ArrayCmpxchg, index) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ArrayCmpxchg, ref) |
| DELEGATE_FIELD_INT(ArrayCmpxchg, order) |
| DELEGATE_FIELD_CASE_END(ArrayCmpxchg) |
| |
| DELEGATE_FIELD_CASE_START(RefAs) |
| DELEGATE_FIELD_INT(RefAs, op) |
| DELEGATE_FIELD_CHILD(RefAs, value) |
| DELEGATE_FIELD_CASE_END(RefAs) |
| |
| DELEGATE_FIELD_CASE_START(StringNew) |
| DELEGATE_FIELD_INT(StringNew, op) |
| DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, end) |
| DELEGATE_FIELD_OPTIONAL_CHILD(StringNew, start) |
| DELEGATE_FIELD_CHILD(StringNew, ref) |
| DELEGATE_FIELD_CASE_END(StringNew) |
| |
| DELEGATE_FIELD_CASE_START(StringConst) |
| DELEGATE_FIELD_NAME(StringConst, string) |
| DELEGATE_FIELD_CASE_END(StringConst) |
| |
| DELEGATE_FIELD_CASE_START(StringMeasure) |
| DELEGATE_FIELD_INT(StringMeasure, op) |
| DELEGATE_FIELD_CHILD(StringMeasure, ref) |
| DELEGATE_FIELD_CASE_END(StringMeasure) |
| |
| DELEGATE_FIELD_CASE_START(StringEncode) |
| DELEGATE_FIELD_INT(StringEncode, op) |
| DELEGATE_FIELD_OPTIONAL_CHILD(StringEncode, start) |
| DELEGATE_FIELD_CHILD(StringEncode, array) |
| DELEGATE_FIELD_CHILD(StringEncode, str) |
| DELEGATE_FIELD_CASE_END(StringEncode) |
| |
| DELEGATE_FIELD_CASE_START(StringConcat) |
| DELEGATE_FIELD_CHILD(StringConcat, right) |
| DELEGATE_FIELD_CHILD(StringConcat, left) |
| DELEGATE_FIELD_CASE_END(StringConcat) |
| |
| DELEGATE_FIELD_CASE_START(StringEq) |
| DELEGATE_FIELD_INT(StringEq, op) |
| DELEGATE_FIELD_CHILD(StringEq, right) |
| DELEGATE_FIELD_CHILD(StringEq, left) |
| DELEGATE_FIELD_CASE_END(StringEq) |
| |
| DELEGATE_FIELD_CASE_START(StringTest) |
| DELEGATE_FIELD_CHILD(StringTest, ref) |
| DELEGATE_FIELD_CASE_END(StringTest) |
| |
| DELEGATE_FIELD_CASE_START(StringWTF16Get) |
| DELEGATE_FIELD_CHILD(StringWTF16Get, pos) |
| DELEGATE_FIELD_CHILD(StringWTF16Get, ref) |
| DELEGATE_FIELD_CASE_END(StringWTF16Get) |
| |
| DELEGATE_FIELD_CASE_START(StringSliceWTF) |
| DELEGATE_FIELD_CHILD(StringSliceWTF, end) |
| DELEGATE_FIELD_CHILD(StringSliceWTF, start) |
| DELEGATE_FIELD_CHILD(StringSliceWTF, ref) |
| DELEGATE_FIELD_CASE_END(StringSliceWTF) |
| |
| DELEGATE_FIELD_CASE_START(ContNew) |
| DELEGATE_FIELD_CHILD(ContNew, func) |
| DELEGATE_FIELD_CASE_END(ContNew) |
| |
| DELEGATE_FIELD_CASE_START(ContBind) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ContBind, cont) |
| DELEGATE_FIELD_CHILD_VECTOR(ContBind, operands) |
| DELEGATE_FIELD_CASE_END(ContBind) |
| |
| DELEGATE_FIELD_CASE_START(Suspend) |
| DELEGATE_FIELD_CHILD_VECTOR(Suspend, operands) |
| DELEGATE_FIELD_NAME_KIND(Suspend, tag, ModuleItemKind::Tag) |
| DELEGATE_FIELD_CASE_END(Suspend) |
| |
| DELEGATE_FIELD_CASE_START(Resume) |
| DELEGATE_FIELD_TYPE_VECTOR(Resume, sentTypes) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(Resume, cont) |
| DELEGATE_FIELD_CHILD_VECTOR(Resume, operands) |
| DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(Resume, handlerBlocks) |
| DELEGATE_FIELD_NAME_KIND_VECTOR(Resume, handlerTags, ModuleItemKind::Tag) |
| DELEGATE_FIELD_CASE_END(Resume) |
| |
| DELEGATE_FIELD_CASE_START(ResumeThrow) |
| DELEGATE_FIELD_TYPE_VECTOR(ResumeThrow, sentTypes) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(ResumeThrow, cont) |
| DELEGATE_FIELD_CHILD_VECTOR(ResumeThrow, operands) |
| DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(ResumeThrow, handlerBlocks) |
| DELEGATE_FIELD_NAME_KIND_VECTOR(ResumeThrow, handlerTags, ModuleItemKind::Tag) |
| DELEGATE_FIELD_NAME_KIND(ResumeThrow, tag, ModuleItemKind::Tag) |
| DELEGATE_FIELD_CASE_END(ResumeThrow) |
| |
| DELEGATE_FIELD_CASE_START(StackSwitch) |
| DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD(StackSwitch, cont) |
| DELEGATE_FIELD_CHILD_VECTOR(StackSwitch, operands) |
| DELEGATE_FIELD_NAME_KIND(StackSwitch, tag, ModuleItemKind::Tag) |
| DELEGATE_FIELD_CASE_END(StackSwitch) |
| |
| |
| DELEGATE_FIELD_MAIN_END |
| |
| #undef DELEGATE_ID |
| #undef DELEGATE_START |
| #undef DELEGATE_END |
| #undef DELEGATE_FIELD_CHILD |
| #undef DELEGATE_FIELD_IMMEDIATE_TYPED_CHILD |
| #undef DELEGATE_FIELD_OPTIONAL_CHILD |
| #undef DELEGATE_FIELD_OPTIONAL_IMMEDIATE_TYPED_CHILD |
| #undef DELEGATE_FIELD_CHILD_VECTOR |
| #undef DELEGATE_FIELD_INT |
| #undef DELEGATE_FIELD_INT_ARRAY |
| #undef DELEGATE_FIELD_INT_VECTOR |
| #undef DELEGATE_FIELD_LITERAL |
| #undef DELEGATE_FIELD_NAME |
| #undef DELEGATE_FIELD_NAME_VECTOR |
| #undef DELEGATE_FIELD_SCOPE_NAME_DEF |
| #undef DELEGATE_FIELD_SCOPE_NAME_USE |
| #undef DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR |
| #undef DELEGATE_FIELD_NAME_KIND |
| #undef DELEGATE_FIELD_NAME_KIND_VECTOR |
| #undef DELEGATE_FIELD_TYPE |
| #undef DELEGATE_FIELD_TYPE_VECTOR |
| #undef DELEGATE_FIELD_HEAPTYPE |
| #undef DELEGATE_FIELD_ADDRESS |
| #undef DELEGATE_GET_FIELD |
| |
| #undef DELEGATE_FIELD_MAIN_START |
| #undef DELEGATE_FIELD_MAIN_END |
| #undef DELEGATE_FIELD_CASE_START |
| #undef DELEGATE_FIELD_CASE_END |
