orca_wasm/ir/
types.rs

1//! Intermediate representation of sections in a wasm module.
2
3use std::cmp::PartialEq;
4use std::fmt::Formatter;
5use std::fmt::{self};
6use std::mem::discriminant;
7use std::slice::Iter;
8
9use wasm_encoder::reencode::Reencode;
10use wasm_encoder::{AbstractHeapType, Encode};
11
12use wasmparser::types::TypeIdentifier;
13use wasmparser::{ConstExpr, HeapType, Operator, RefType, ValType};
14
15use crate::error::Error;
16use crate::ir::id::{CustomSectionID, FunctionID, GlobalID, ModuleID, TypeID};
17
18type Result<T> = std::result::Result<T, Error>;
19
20/// Orca's Datatype. Combination of multiple [`wasmparser`] datatypes.
21///
22/// [ValType]: https://docs.rs/wasmparser/latest/wasmparser/enum.ValType.html
23#[derive(Debug, Clone, Eq, Hash, PartialEq, Copy)]
24pub enum DataType {
25    I8,
26    I16,
27    I32,
28    I64,
29    F32,
30    F64,
31    V128,
32    FuncRef,
33    FuncRefNull,
34    ExternRef,
35    ExternRefNull,
36    Any,
37    AnyNull,
38    None,
39    NoExtern,
40    NoFunc,
41    Eq,
42    EqNull,
43    Struct,
44    StructNull,
45    Array,
46    ArrayNull,
47    I31,
48    I31Null,
49    Exn,
50    NoExn,
51    Module { ty_id: u32, nullable: bool },
52    RecGroup(u32),
53    CoreTypeId(u32), // TODO: Look at this
54    Cont,
55    NoCont,
56}
57
58impl fmt::Display for DataType {
59    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
60        match *self {
61            DataType::I8 => write!(f, "DataType: I8"),
62            DataType::I16 => write!(f, "DataType: I16"),
63            DataType::I32 => write!(f, "DataType: I32"),
64            DataType::I64 => write!(f, "DataType: I64"),
65            DataType::F32 => write!(f, "DataType: F32"),
66            DataType::F64 => write!(f, "DataType: F64"),
67            DataType::V128 => write!(f, "DataType: V128"),
68            DataType::FuncRef => write!(f, "DataType: FuncRef"),
69            DataType::ExternRef => write!(f, "DataType: ExternRef"),
70            DataType::Any => write!(f, "DataType: Any"),
71            DataType::None => write!(f, "DataType: None"),
72            DataType::NoExtern => write!(f, "DataType: NoExtern"),
73            DataType::NoFunc => write!(f, "DataType: NoFunc"),
74            DataType::Eq => write!(f, "DataType: Eq"),
75            DataType::Struct => write!(f, "DataType: Struct"),
76            DataType::Array => write!(f, "DataType: Array"),
77            DataType::I31 => write!(f, "DataType: I31"),
78            DataType::Exn => write!(f, "DataType: Exn"),
79            DataType::NoExn => write!(f, "DataType: NoExn"),
80            DataType::Module { ty_id, nullable } => {
81                write!(f, "module: {ty_id}, nullable: {nullable}",)
82            }
83            DataType::RecGroup(idx) => write!(f, "recgroup: {idx}"),
84            DataType::CoreTypeId(idx) => write!(f, "coretypeid: {idx}"),
85            DataType::Cont => write!(f, "cont"),
86            DataType::NoCont => write!(f, "nocont"),
87            DataType::FuncRefNull => write!(f, "funcref: null"),
88            DataType::ExternRefNull => write!(f, "externref: null"),
89            DataType::AnyNull => write!(f, "any: null"),
90            DataType::EqNull => write!(f, "eq: null"),
91            DataType::StructNull => write!(f, "struct: null"),
92            DataType::ArrayNull => write!(f, "array: null"),
93            DataType::I31Null => write!(f, "i31: null"),
94        }
95    }
96}
97
98impl From<wasmparser::StorageType> for DataType {
99    fn from(value: wasmparser::StorageType) -> Self {
100        match value {
101            wasmparser::StorageType::I8 => DataType::I8,
102            wasmparser::StorageType::I16 => DataType::I16,
103            wasmparser::StorageType::Val(val) => DataType::from(val),
104        }
105    }
106}
107
108impl From<DataType> for wasm_encoder::StorageType {
109    fn from(value: DataType) -> Self {
110        match value {
111            DataType::I8 => wasm_encoder::StorageType::I8,
112            DataType::I16 => wasm_encoder::StorageType::I16,
113            _ => wasm_encoder::StorageType::Val(wasm_encoder::ValType::from(&value)),
114        }
115    }
116}
117
118impl From<ValType> for DataType {
119    fn from(value: ValType) -> Self {
120        match value {
121            ValType::I32 => DataType::I32,
122            ValType::I64 => DataType::I64,
123            ValType::F32 => DataType::F32,
124            ValType::F64 => DataType::F64,
125            ValType::V128 => DataType::V128,
126            ValType::Ref(ref_type) => match ref_type.heap_type() {
127                wasmparser::HeapType::Abstract { shared: _, ty } => match ty {
128                    wasmparser::AbstractHeapType::Func => {
129                        if ref_type.is_nullable() {
130                            DataType::FuncRefNull
131                        } else {
132                            DataType::FuncRef
133                        }
134                    }
135                    wasmparser::AbstractHeapType::Extern => {
136                        if ref_type.is_nullable() {
137                            DataType::ExternRefNull
138                        } else {
139                            DataType::ExternRef
140                        }
141                    }
142                    wasmparser::AbstractHeapType::Any => {
143                        if ref_type.is_nullable() {
144                            DataType::AnyNull
145                        } else {
146                            DataType::Any
147                        }
148                    }
149                    wasmparser::AbstractHeapType::None => DataType::None,
150                    wasmparser::AbstractHeapType::NoExtern => DataType::NoExtern,
151                    wasmparser::AbstractHeapType::NoFunc => DataType::NoFunc,
152                    wasmparser::AbstractHeapType::Eq => {
153                        if ref_type.is_nullable() {
154                            DataType::EqNull
155                        } else {
156                            DataType::Eq
157                        }
158                    }
159                    wasmparser::AbstractHeapType::Struct => {
160                        if ref_type.is_nullable() {
161                            DataType::StructNull
162                        } else {
163                            DataType::Struct
164                        }
165                    }
166                    wasmparser::AbstractHeapType::Array => {
167                        if ref_type.is_nullable() {
168                            DataType::ArrayNull
169                        } else {
170                            DataType::Array
171                        }
172                    }
173                    wasmparser::AbstractHeapType::I31 => {
174                        if ref_type.is_nullable() {
175                            DataType::I31Null
176                        } else {
177                            DataType::I31
178                        }
179                    }
180                    wasmparser::AbstractHeapType::Exn => DataType::Exn,
181                    wasmparser::AbstractHeapType::NoExn => DataType::NoExn,
182                    wasmparser::AbstractHeapType::Cont => DataType::Cont,
183                    wasmparser::AbstractHeapType::NoCont => DataType::NoCont,
184                },
185                wasmparser::HeapType::Concrete(u) => match u {
186                    wasmparser::UnpackedIndex::Module(idx) => DataType::Module {
187                        ty_id: *ModuleID(idx),
188                        nullable: ref_type.is_nullable(),
189                    },
190                    wasmparser::UnpackedIndex::RecGroup(idx) => DataType::RecGroup(idx),
191                    wasmparser::UnpackedIndex::Id(_id) => panic!("Not supported yet!"),
192                },
193            },
194        }
195    }
196}
197
198/// Converts from Orca's DataType to [`wasm_encoder::ValType`].
199///
200/// [`wasm_encoder::ValType`]: https://docs.rs/wasm-encoder/0.214.0/wasm_encoder/enum.ValType.html
201impl From<&DataType> for wasm_encoder::ValType {
202    fn from(ty: &DataType) -> Self {
203        match ty {
204            DataType::I8 | DataType::I16 => panic!("Not valtype equivalent!"),
205            DataType::I32 => wasm_encoder::ValType::I32,
206            DataType::I64 => wasm_encoder::ValType::I64,
207            DataType::F32 => wasm_encoder::ValType::F32,
208            DataType::F64 => wasm_encoder::ValType::F64,
209            DataType::V128 => wasm_encoder::ValType::V128,
210            DataType::FuncRef => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
211                nullable: false,
212                heap_type: wasm_encoder::HeapType::Abstract {
213                    shared: false,
214                    ty: AbstractHeapType::Func,
215                },
216            }),
217            DataType::ExternRef => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
218                nullable: false,
219                heap_type: wasm_encoder::HeapType::Abstract {
220                    shared: false,
221                    ty: AbstractHeapType::Extern,
222                },
223            }),
224            DataType::Any => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
225                nullable: false,
226                heap_type: wasm_encoder::HeapType::Abstract {
227                    shared: false,
228                    ty: AbstractHeapType::Any,
229                },
230            }),
231            DataType::None => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
232                nullable: false,
233                heap_type: wasm_encoder::HeapType::Abstract {
234                    shared: false,
235                    ty: AbstractHeapType::None,
236                },
237            }),
238            DataType::NoExtern => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
239                nullable: false,
240                heap_type: wasm_encoder::HeapType::Abstract {
241                    shared: false,
242                    ty: AbstractHeapType::NoExtern,
243                },
244            }),
245            DataType::NoFunc => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
246                nullable: false,
247                heap_type: wasm_encoder::HeapType::Abstract {
248                    shared: false,
249                    ty: AbstractHeapType::NoFunc,
250                },
251            }),
252            DataType::Eq => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
253                nullable: false,
254                heap_type: wasm_encoder::HeapType::Abstract {
255                    shared: false,
256                    ty: AbstractHeapType::Eq,
257                },
258            }),
259            DataType::Struct => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
260                nullable: false,
261                heap_type: wasm_encoder::HeapType::Abstract {
262                    shared: false,
263                    ty: AbstractHeapType::Struct,
264                },
265            }),
266            DataType::Array => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
267                nullable: false,
268                heap_type: wasm_encoder::HeapType::Abstract {
269                    shared: false,
270                    ty: AbstractHeapType::Array,
271                },
272            }),
273            DataType::I31 => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
274                nullable: false,
275                heap_type: wasm_encoder::HeapType::Abstract {
276                    shared: false,
277                    ty: AbstractHeapType::I31,
278                },
279            }),
280            DataType::Exn => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
281                nullable: false,
282                heap_type: wasm_encoder::HeapType::Abstract {
283                    shared: false,
284                    ty: AbstractHeapType::Exn,
285                },
286            }),
287            DataType::NoExn => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
288                nullable: false,
289                heap_type: wasm_encoder::HeapType::Abstract {
290                    shared: false,
291                    ty: AbstractHeapType::NoExn,
292                },
293            }),
294            DataType::Module { ty_id, nullable } => {
295                wasm_encoder::ValType::Ref(wasm_encoder::RefType {
296                    nullable: *nullable,
297                    heap_type: wasm_encoder::HeapType::Concrete(*ty_id),
298                })
299            }
300            DataType::RecGroup(idx) => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
301                nullable: false,
302                heap_type: wasm_encoder::HeapType::Concrete(*idx),
303            }),
304            DataType::CoreTypeId(idx) => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
305                nullable: false,
306                heap_type: wasm_encoder::HeapType::Concrete(*idx),
307            }),
308            DataType::Cont => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
309                nullable: false,
310                heap_type: wasm_encoder::HeapType::Abstract {
311                    shared: false,
312                    ty: AbstractHeapType::Cont,
313                },
314            }),
315            DataType::NoCont => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
316                nullable: false,
317                heap_type: wasm_encoder::HeapType::Abstract {
318                    shared: false,
319                    ty: AbstractHeapType::NoCont,
320                },
321            }),
322            DataType::FuncRefNull => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
323                nullable: true,
324                heap_type: wasm_encoder::HeapType::Abstract {
325                    shared: false,
326                    ty: AbstractHeapType::Func,
327                },
328            }),
329            DataType::ExternRefNull => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
330                nullable: true,
331                heap_type: wasm_encoder::HeapType::Abstract {
332                    shared: false,
333                    ty: AbstractHeapType::Extern,
334                },
335            }),
336            DataType::AnyNull => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
337                nullable: true,
338                heap_type: wasm_encoder::HeapType::Abstract {
339                    shared: false,
340                    ty: AbstractHeapType::Any,
341                },
342            }),
343            DataType::EqNull => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
344                nullable: true,
345                heap_type: wasm_encoder::HeapType::Abstract {
346                    shared: false,
347                    ty: AbstractHeapType::Eq,
348                },
349            }),
350            DataType::StructNull => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
351                nullable: true,
352                heap_type: wasm_encoder::HeapType::Abstract {
353                    shared: false,
354                    ty: AbstractHeapType::Struct,
355                },
356            }),
357            DataType::ArrayNull => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
358                nullable: true,
359                heap_type: wasm_encoder::HeapType::Abstract {
360                    shared: false,
361                    ty: AbstractHeapType::Array,
362                },
363            }),
364            DataType::I31Null => wasm_encoder::ValType::Ref(wasm_encoder::RefType {
365                nullable: true,
366                heap_type: wasm_encoder::HeapType::Abstract {
367                    shared: false,
368                    ty: AbstractHeapType::I31,
369                },
370            }),
371        }
372    }
373}
374
375impl From<&DataType> for ValType {
376    fn from(ty: &DataType) -> Self {
377        match ty {
378            DataType::I8 | DataType::I16 => panic!("No valtype equivalent!"),
379            DataType::I32 => ValType::I32,
380            DataType::I64 => ValType::I64,
381            DataType::F32 => ValType::F32,
382            DataType::F64 => ValType::F64,
383            DataType::V128 => ValType::V128,
384            DataType::FuncRef => ValType::FUNCREF,
385            DataType::ExternRef => ValType::EXTERNREF,
386            DataType::Any => ValType::Ref(
387                RefType::new(
388                    false,
389                    wasmparser::HeapType::Abstract {
390                        shared: false,
391                        ty: wasmparser::AbstractHeapType::Any,
392                    },
393                )
394                .unwrap(),
395            ),
396            DataType::None => ValType::Ref(
397                RefType::new(
398                    false,
399                    wasmparser::HeapType::Abstract {
400                        shared: false,
401                        ty: wasmparser::AbstractHeapType::None,
402                    },
403                )
404                .unwrap(),
405            ),
406            DataType::NoExtern => ValType::Ref(
407                RefType::new(
408                    false,
409                    wasmparser::HeapType::Abstract {
410                        shared: false,
411                        ty: wasmparser::AbstractHeapType::NoExtern,
412                    },
413                )
414                .unwrap(),
415            ),
416            DataType::NoFunc => ValType::Ref(
417                RefType::new(
418                    false,
419                    wasmparser::HeapType::Abstract {
420                        shared: false,
421                        ty: wasmparser::AbstractHeapType::NoFunc,
422                    },
423                )
424                .unwrap(),
425            ),
426            DataType::Eq => ValType::Ref(
427                RefType::new(
428                    false,
429                    wasmparser::HeapType::Abstract {
430                        shared: false,
431                        ty: wasmparser::AbstractHeapType::Eq,
432                    },
433                )
434                .unwrap(),
435            ),
436            DataType::Struct => ValType::Ref(
437                RefType::new(
438                    false,
439                    wasmparser::HeapType::Abstract {
440                        shared: false,
441                        ty: wasmparser::AbstractHeapType::Struct,
442                    },
443                )
444                .unwrap(),
445            ),
446            DataType::Array => ValType::Ref(
447                RefType::new(
448                    false,
449                    wasmparser::HeapType::Abstract {
450                        shared: false,
451                        ty: wasmparser::AbstractHeapType::Array,
452                    },
453                )
454                .unwrap(),
455            ),
456            DataType::I31 => ValType::Ref(
457                RefType::new(
458                    false,
459                    wasmparser::HeapType::Abstract {
460                        shared: false,
461                        ty: wasmparser::AbstractHeapType::I31,
462                    },
463                )
464                .unwrap(),
465            ),
466            DataType::Exn => ValType::Ref(
467                RefType::new(
468                    false,
469                    wasmparser::HeapType::Abstract {
470                        shared: false,
471                        ty: wasmparser::AbstractHeapType::Exn,
472                    },
473                )
474                .unwrap(),
475            ),
476            DataType::NoExn => ValType::Ref(
477                RefType::new(
478                    false,
479                    wasmparser::HeapType::Abstract {
480                        shared: false,
481                        ty: wasmparser::AbstractHeapType::NoExn,
482                    },
483                )
484                .unwrap(),
485            ),
486            DataType::Module { ty_id, nullable } => ValType::Ref(
487                RefType::new(
488                    *nullable,
489                    wasmparser::HeapType::Concrete(wasmparser::UnpackedIndex::Module(*ty_id)),
490                )
491                .unwrap(),
492            ),
493            DataType::RecGroup(idx) => ValType::Ref(
494                RefType::new(
495                    false,
496                    wasmparser::HeapType::Concrete(wasmparser::UnpackedIndex::RecGroup(*idx)),
497                )
498                .unwrap(),
499            ),
500            DataType::CoreTypeId(_idx) => panic!("Not Supported Yet!"),
501            DataType::Cont => ValType::Ref(
502                RefType::new(
503                    false,
504                    wasmparser::HeapType::Abstract {
505                        shared: false,
506                        ty: wasmparser::AbstractHeapType::Cont,
507                    },
508                )
509                .unwrap(),
510            ),
511            DataType::NoCont => ValType::Ref(
512                RefType::new(
513                    false,
514                    wasmparser::HeapType::Abstract {
515                        shared: false,
516                        ty: wasmparser::AbstractHeapType::NoCont,
517                    },
518                )
519                .unwrap(),
520            ),
521            DataType::FuncRefNull => ValType::Ref(
522                RefType::new(
523                    true,
524                    wasmparser::HeapType::Abstract {
525                        shared: false,
526                        ty: wasmparser::AbstractHeapType::Func,
527                    },
528                )
529                .unwrap(),
530            ),
531            DataType::ExternRefNull => ValType::Ref(
532                RefType::new(
533                    true,
534                    wasmparser::HeapType::Abstract {
535                        shared: false,
536                        ty: wasmparser::AbstractHeapType::Extern,
537                    },
538                )
539                .unwrap(),
540            ),
541            DataType::AnyNull => ValType::Ref(
542                RefType::new(
543                    true,
544                    wasmparser::HeapType::Abstract {
545                        shared: false,
546                        ty: wasmparser::AbstractHeapType::Any,
547                    },
548                )
549                .unwrap(),
550            ),
551            DataType::EqNull => ValType::Ref(
552                RefType::new(
553                    true,
554                    wasmparser::HeapType::Abstract {
555                        shared: false,
556                        ty: wasmparser::AbstractHeapType::Eq,
557                    },
558                )
559                .unwrap(),
560            ),
561            DataType::StructNull => ValType::Ref(
562                RefType::new(
563                    true,
564                    wasmparser::HeapType::Abstract {
565                        shared: false,
566                        ty: wasmparser::AbstractHeapType::Struct,
567                    },
568                )
569                .unwrap(),
570            ),
571            DataType::ArrayNull => ValType::Ref(
572                RefType::new(
573                    true,
574                    wasmparser::HeapType::Abstract {
575                        shared: false,
576                        ty: wasmparser::AbstractHeapType::Array,
577                    },
578                )
579                .unwrap(),
580            ),
581            DataType::I31Null => ValType::Ref(
582                RefType::new(
583                    true,
584                    wasmparser::HeapType::Abstract {
585                        shared: false,
586                        ty: wasmparser::AbstractHeapType::I31,
587                    },
588                )
589                .unwrap(),
590            ),
591        }
592    }
593}
594
595/// Converts [`ValType`] to [`wasm_encoder::ValType`].
596///
597/// [`wasm_encoder::ValType`]: https://docs.rs/wasm-encoder/0.214.0/wasm_encoder/enum.ValType.html
598/// [`ValType`]: https://docs.rs/wasmparser/latest/wasmparser/enum.ValType.html
599pub fn valtype_to_wasmencoder_type(val_type: &ValType) -> wasm_encoder::ValType {
600    let mut reencoder = wasm_encoder::reencode::RoundtripReencoder;
601    reencoder.val_type(*val_type).unwrap()
602}
603
604#[derive(Debug, Clone)]
605/// Data Segment in a wasm module.
606pub struct DataSegment {
607    /// The kind of data segment.
608    pub kind: DataSegmentKind,
609    /// The data of the data segment.
610    pub data: Vec<u8>,
611}
612
613impl DataSegment {
614    pub fn from_wasmparser(data: wasmparser::Data) -> Result<DataSegment> {
615        Ok(DataSegment {
616            kind: DataSegmentKind::from_wasmparser(data.kind)?,
617            data: data.data.to_vec(),
618        })
619    }
620}
621
622/// The kind of data segment.
623#[derive(Debug, Clone)]
624pub enum DataSegmentKind {
625    /// The data segment is passive.
626    Passive,
627    /// The data segment is active.
628    Active {
629        /// The memory index for the data segment.
630        memory_index: u32,
631        /// The memory offset where this active data segment will be automatically
632        /// initialized.
633        offset_expr: InitExpr,
634    },
635}
636
637impl DataSegmentKind {
638    pub(crate) fn from_wasmparser(kind: wasmparser::DataKind) -> Result<DataSegmentKind> {
639        Ok(match kind {
640            wasmparser::DataKind::Passive => DataSegmentKind::Passive,
641            wasmparser::DataKind::Active {
642                memory_index,
643                offset_expr,
644            } => DataSegmentKind::Active {
645                memory_index,
646                offset_expr: InitExpr::eval(&offset_expr),
647            },
648        })
649    }
650}
651
652#[derive(Debug, Clone)]
653/// Kind of Element
654pub enum ElementKind<'a> {
655    Passive,
656    Active {
657        table_index: Option<u32>,
658        offset_expr: ConstExpr<'a>,
659    },
660    Declared,
661}
662
663impl ElementKind<'_> {
664    pub(crate) fn from_wasmparser(kind: wasmparser::ElementKind) -> Result<ElementKind> {
665        match kind {
666            wasmparser::ElementKind::Passive => Ok(ElementKind::Passive),
667            wasmparser::ElementKind::Declared => Ok(ElementKind::Declared),
668            wasmparser::ElementKind::Active {
669                table_index,
670                offset_expr,
671            } => Ok(ElementKind::Active {
672                table_index,
673                offset_expr,
674            }),
675        }
676    }
677}
678
679#[derive(Debug, Clone)]
680/// Type of element
681pub enum ElementItems<'a> {
682    Functions(Vec<FunctionID>),
683    ConstExprs {
684        ty: RefType,
685        exprs: Vec<ConstExpr<'a>>,
686    },
687}
688
689impl ElementItems<'_> {
690    pub(crate) fn from_wasmparser(items: wasmparser::ElementItems) -> Result<ElementItems> {
691        match items {
692            wasmparser::ElementItems::Functions(reader) => {
693                let functions = reader
694                    .into_iter()
695                    .collect::<std::result::Result<Vec<_>, _>>()?;
696                // unsure how to avoid a second iteration (cast while iterating above)
697                let fids = functions.iter().map(|id| FunctionID(*id)).collect();
698                Ok(ElementItems::Functions(fids))
699            }
700            wasmparser::ElementItems::Expressions(ref_type, reader) => {
701                let exprs = reader
702                    .into_iter()
703                    .collect::<std::result::Result<Vec<_>, _>>()?;
704                Ok(ElementItems::ConstExprs {
705                    ty: ref_type,
706                    exprs,
707                })
708            }
709        }
710    }
711}
712
713#[derive(Debug, Clone)]
714/// Mode of Function in case the function is mark as instrumented
715pub enum FuncInstrMode {
716    Entry,
717    Exit,
718}
719
720#[derive(Default, Debug, Clone)]
721/// Instrumentation Data that is stored with every function
722pub struct FuncInstrFlag<'a> {
723    /// boolean flag to say whether there are special instrumentation
724    /// modes to resolve for this function (see InstrumentationMode variants)
725    pub has_special_instr: bool,
726    pub current_mode: Option<FuncInstrMode>,
727    pub entry: Vec<Operator<'a>>,
728    pub exit: Vec<Operator<'a>>,
729}
730
731impl fmt::Display for FuncInstrFlag<'_> {
732    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
733        let FuncInstrFlag {
734            has_special_instr,
735            entry,
736            exit,
737            current_mode: _,
738        } = self;
739        if !self.has_instr() {
740            write!(f, "Not Instrumented")?;
741        }
742        write!(
743            f,
744            "Has special instrumentation: {}\n \
745             Func Entry: {:?} instructions\n \
746             Func Exit: {:?} instructions",
747            has_special_instr,
748            entry.len(),
749            exit.len()
750        )
751    }
752}
753
754impl PartialEq for FuncInstrFlag<'_> {
755    fn eq(&self, other: &Self) -> bool {
756        // Using pattern match to help identify when this function needs to be extended in the future
757        let Self {
758            has_special_instr,
759            entry,
760            exit,
761            current_mode,
762        } = self;
763        let mut result = *has_special_instr == other.has_special_instr;
764        result &= entry.eq(&other.entry);
765        result &= exit.eq(&other.exit);
766        result &= discriminant(current_mode) == discriminant(&other.current_mode);
767
768        result
769    }
770}
771
772impl Eq for FuncInstrFlag<'_> {}
773
774impl<'a> FuncInstrFlag<'a> {
775    pub fn has_instr(&self) -> bool {
776        // Using pattern match to help identify when this function needs to be extended in the future
777        let Self {
778            entry,
779            exit,
780            has_special_instr: _,
781            current_mode: _,
782        } = self;
783        !entry.is_empty() || !exit.is_empty()
784    }
785
786    pub fn has_special_instr(&self) -> bool {
787        self.has_special_instr
788    }
789
790    /// Add an instruction to the current FuncInstrMode's list
791    pub fn add_instr(&mut self, val: Operator<'a>) {
792        self.has_special_instr = true;
793        match self.current_mode {
794            None => {
795                panic!("Current mode is not set...cannot inject instructions!")
796            }
797            Some(FuncInstrMode::Entry) => self.entry.push(val),
798            Some(FuncInstrMode::Exit) => self.exit.push(val),
799        }
800    }
801
802    /// Get an instruction to the current FuncInstrMode's list
803    pub fn get_instr(&self, idx: usize) -> &Operator {
804        match self.current_mode {
805            None => {
806                panic!("Current mode is not set...cannot grab instruction without context!")
807            }
808            Some(FuncInstrMode::Entry) => self.entry.get(idx).unwrap(),
809            Some(FuncInstrMode::Exit) => self.exit.get(idx).unwrap(),
810        }
811    }
812
813    /// Can be called after finishing some instrumentation to reset the mode.
814    pub fn finish_instr(&mut self) {
815        self.current_mode = None
816    }
817}
818
819#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
820/// Mode of Instruction in case the instruction is marked as Instrumented
821pub enum InstrumentationMode {
822    Before,
823    After,
824    Alternate,
825
826    // special modes
827    SemanticAfter,
828    BlockEntry,
829    BlockExit,
830    BlockAlt,
831}
832
833#[derive(Default, Debug, Clone)]
834/// Instrumentation Data that is stored with every instruction
835pub struct InstrumentationFlag<'a> {
836    pub current_mode: Option<InstrumentationMode>,
837    pub before: Vec<Operator<'a>>,
838    pub after: Vec<Operator<'a>>,
839    /// None means to replace with no instructions (effectively removing the original)
840    /// Some(vec) means to replace with the vec of instructions
841    /// Some(empty vec) means there is no alt instrumentation
842    pub alternate: Option<Vec<Operator<'a>>>,
843
844    // special modes
845    pub semantic_after: Vec<Operator<'a>>,
846    pub block_entry: Vec<Operator<'a>>,
847    pub block_exit: Vec<Operator<'a>>,
848    /// None means to replace with no instructions (effectively removing the original)
849    /// Some(vec) means to replace with the vec of instructions
850    /// Some(empty vec) means there is no alt instrumentation
851    pub block_alt: Option<Vec<Operator<'a>>>,
852}
853
854impl fmt::Display for InstrumentationFlag<'_> {
855    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
856        let InstrumentationFlag {
857            before,
858            after,
859            alternate,
860            semantic_after,
861            block_entry,
862            block_exit,
863            block_alt,
864            current_mode: _,
865        } = self;
866        if !self.has_instr() {
867            write!(f, "Not Instrumented")?;
868        }
869        write!(
870            f,
871            "Before: {:?} instructions\n \
872                   After: {:?} instructions\n \
873                   Alternate: {:?} instructions\n \
874                   Semantic After: {:?} instructions\n \
875                   Block Entry: {:?} instructions\n \
876                   Block Exit: {:?} instructions\n \
877                   Block Alt: {:?} instructions",
878            before.len(),
879            after.len(),
880            alternate.as_ref().unwrap().len(),
881            semantic_after.len(),
882            block_entry.len(),
883            block_exit.len(),
884            block_alt.as_ref().unwrap().len()
885        )
886    }
887}
888
889impl PartialEq for InstrumentationFlag<'_> {
890    fn eq(&self, other: &Self) -> bool {
891        // Using pattern match to help identify when this function needs to be extended in the future
892        let Self {
893            before,
894            after,
895            alternate,
896            semantic_after,
897            block_entry,
898            block_exit,
899            block_alt,
900            current_mode,
901        } = self;
902        let mut result = before.eq(&other.before);
903        result &= after.eq(&other.after);
904        result &= *alternate == other.alternate;
905        result &= semantic_after.eq(&other.semantic_after);
906        result &= block_entry.eq(&other.block_entry);
907        result &= block_exit.eq(&other.block_exit);
908        result &= block_alt.eq(&other.block_alt);
909        result &= *current_mode == other.current_mode;
910
911        result
912    }
913}
914
915impl Eq for InstrumentationFlag<'_> {}
916
917impl<'a> InstrumentationFlag<'a> {
918    pub fn has_instr(&self) -> bool {
919        // Using pattern match to help identify when this function needs to be extended in the future
920        let Self {
921            before,
922            after,
923            alternate,
924            semantic_after,
925            block_entry,
926            block_exit,
927            block_alt,
928            current_mode: _,
929        } = self;
930        !before.is_empty()
931            || !after.is_empty()
932            || !alternate.is_none() // Some(vec![]) means instruction removal!
933            || !semantic_after.is_empty()
934            || !block_entry.is_empty()
935            || !block_exit.is_empty()
936            || !block_alt.is_none() // Some(vec![]) means block removal!
937    }
938
939    /// Add an instruction to the current InstrumentationMode's list
940    /// Returns whether the instrumentation was a 'special' mode
941    pub fn add_instr(&mut self, op: &Operator, val: Operator<'a>) -> bool {
942        match self.current_mode {
943            None => {
944                panic!("Current mode is not set...cannot inject instructions!")
945            }
946            Some(InstrumentationMode::Before) => {
947                self.before.push(val);
948                false
949            }
950            Some(InstrumentationMode::After) => {
951                self.after.push(val);
952                false
953            }
954            Some(InstrumentationMode::Alternate) => {
955                match &mut self.alternate {
956                    None => self.alternate = Some(vec![val]),
957                    Some(alternate) => alternate.push(val),
958                }
959                false
960            }
961            Some(InstrumentationMode::SemanticAfter) => {
962                // self.semantic_after.push(val);
963                // true
964                if Self::is_block_style_op(op) || Self::is_branching_op(op) {
965                    self.semantic_after.push(val);
966                    true
967                } else {
968                    // instrumentation type not applicable!
969                    panic!(
970                        "Cannot apply semantic after instrumentation mode to op type: {:?}",
971                        op
972                    );
973                }
974            }
975            Some(InstrumentationMode::BlockEntry) => {
976                if Self::is_block_style_op(op) {
977                    self.block_entry.push(val);
978                    true
979                } else {
980                    // instrumentation type not applicable!
981                    panic!(
982                        "Cannot apply block entry instrumentation mode to op type: {:?}",
983                        op
984                    );
985                }
986            }
987            Some(InstrumentationMode::BlockExit) => {
988                if Self::is_block_style_op(op) {
989                    self.block_exit.push(val);
990                    true
991                } else {
992                    // instrumentation type not applicable!
993                    panic!(
994                        "Cannot apply block exit instrumentation mode to op type: {:?}",
995                        op
996                    );
997                }
998            }
999            Some(InstrumentationMode::BlockAlt) => {
1000                if Self::is_block_style_op(op) {
1001                    match &mut self.block_alt {
1002                        None => self.block_alt = Some(vec![val]),
1003                        Some(block_alt) => block_alt.push(val),
1004                    }
1005                    true
1006                } else {
1007                    // instrumentation type not applicable!
1008                    panic!(
1009                        "Cannot apply block alternate instrumentation mode to op type: {:?}",
1010                        op
1011                    );
1012                }
1013            }
1014        }
1015    }
1016
1017    pub fn clear_instr(&mut self, mode: InstrumentationMode) {
1018        match mode {
1019            InstrumentationMode::Before => {
1020                self.before.clear();
1021            }
1022            InstrumentationMode::After => self.after.clear(),
1023            InstrumentationMode::Alternate => {
1024                self.alternate = None;
1025            }
1026            InstrumentationMode::SemanticAfter => self.semantic_after.clear(),
1027            InstrumentationMode::BlockEntry => self.block_entry.clear(),
1028            InstrumentationMode::BlockExit => self.block_exit.clear(),
1029            InstrumentationMode::BlockAlt => {
1030                self.block_alt = None;
1031            }
1032        }
1033    }
1034
1035    fn is_block_style_op(op: &Operator) -> bool {
1036        matches!(
1037            op,
1038            Operator::Block { .. }
1039                | Operator::Loop { .. }
1040                | Operator::If { .. }
1041                | Operator::Else { .. }
1042        )
1043    }
1044
1045    fn is_branching_op(op: &Operator) -> bool {
1046        matches!(
1047            op,
1048            Operator::Br { .. }
1049                | Operator::BrIf { .. }
1050                | Operator::BrTable { .. }
1051                | Operator::BrOnCast { .. }
1052                | Operator::BrOnCastFail { .. }
1053                | Operator::BrOnNull { .. }
1054                | Operator::BrOnNonNull { .. }
1055        )
1056    }
1057
1058    /// Get an instruction to the current InstrumentationMode's list
1059    pub fn get_instr(&self, idx: usize) -> &Operator {
1060        match self.current_mode {
1061            None => {
1062                panic!("Current mode is not set...cannot grab instruction without context!")
1063            }
1064            Some(InstrumentationMode::Before) => self.before.get(idx).unwrap(),
1065            Some(InstrumentationMode::After) => self.after.get(idx).unwrap(),
1066            Some(InstrumentationMode::Alternate) => match &self.alternate {
1067                None => panic!("No alternate instructions to pull idx '{}' from", idx),
1068                Some(alternate) => alternate.get(idx).unwrap(),
1069            },
1070            Some(InstrumentationMode::SemanticAfter) => self.semantic_after.get(idx).unwrap(),
1071            Some(InstrumentationMode::BlockEntry) => self.block_entry.get(idx).unwrap(),
1072            Some(InstrumentationMode::BlockExit) => self.block_exit.get(idx).unwrap(),
1073            Some(InstrumentationMode::BlockAlt) => match &self.block_alt {
1074                None => panic!("No block alt instructions to pull idx '{}' from", idx),
1075                Some(block_alt) => block_alt.get(idx).unwrap(),
1076            },
1077        }
1078    }
1079
1080    /// Can be called after finishing some instrumentation to reset the mode.
1081    pub fn finish_instr(&mut self) {
1082        self.current_mode = None
1083    }
1084}
1085
1086/// Used to represent a unique location in a wasm component or module.
1087#[derive(Debug, Clone, Copy)]
1088pub enum Location {
1089    Component {
1090        mod_idx: ModuleID,
1091        func_idx: FunctionID,
1092        instr_idx: usize,
1093    },
1094    Module {
1095        func_idx: FunctionID,
1096        instr_idx: usize,
1097    },
1098}
1099
1100#[derive(Debug, Default, Clone)]
1101/// Body of a function in a wasm module
1102pub struct Body<'a> {
1103    /// Local variables of the function, given as tuples of (# of locals, type).
1104    /// Note that these do not include the function parameters which are given
1105    /// indices before the locals. So if a function has 2 parameters and a local
1106    /// defined here then local indices 0 and 1 will refer to the parameters and
1107    /// index 2 will refer to the local here.
1108    pub locals: Vec<(u32, DataType)>,
1109    pub num_locals: u32,
1110    // accessing operators by .0 is not very clear
1111    pub instructions: Vec<Instruction<'a>>,
1112    pub num_instructions: usize,
1113    pub name: Option<String>,
1114}
1115
1116// 'b should outlive 'a
1117impl<'a, 'b> Body<'a>
1118where
1119    'b: 'a,
1120{
1121    /// Push a new operator (instruction) to the end of the body
1122    pub fn push_op(&mut self, op: Operator<'b>) {
1123        self.instructions.push(Instruction::new(op));
1124        self.num_instructions += 1;
1125    }
1126
1127    /// Get some operator (instruction) at the specified index of the body
1128    pub fn get_op(&self, idx: usize) -> &Operator {
1129        &self.instructions[idx].op
1130    }
1131
1132    /// Get the instrumentation of some operator in the body
1133    pub fn get_instr_flag(&self, idx: usize) -> &InstrumentationFlag {
1134        &self.instructions[idx].instr_flag
1135    }
1136
1137    /// Get the instrumentation of some operator in the body
1138    pub fn clear_instr(&mut self, idx: usize, mode: InstrumentationMode) {
1139        self.instructions[idx].instr_flag.clear_instr(mode);
1140    }
1141
1142    /// Push an end operator (instruction) to the end of the body
1143    pub fn end(&mut self) {
1144        self.push_op(Operator::End);
1145    }
1146}
1147
1148#[derive(Debug, Clone)]
1149pub struct Instruction<'a> {
1150    pub op: Operator<'a>,
1151    pub instr_flag: InstrumentationFlag<'a>,
1152}
1153impl<'a, 'b> Instruction<'a>
1154where
1155    'b: 'a,
1156{
1157    pub fn new(op: Operator<'b>) -> Self {
1158        Self {
1159            op,
1160            instr_flag: InstrumentationFlag::default(),
1161        }
1162    }
1163
1164    pub fn add_instr(&mut self, val: Operator<'a>) -> bool {
1165        self.instr_flag.add_instr(&self.op, val)
1166    }
1167
1168    pub fn extract_op(&'a self) -> Operator<'a> {
1169        self.op.clone()
1170    }
1171}
1172
1173/// A constant expression which is produced in WebAssembly, typically used in global
1174/// initializers or element/data offsets.
1175#[derive(Debug, Clone)]
1176pub struct InitExpr {
1177    exprs: Vec<Instructions>,
1178}
1179
1180/// Set of instructions that can be used in Initialisatin Expressions
1181#[derive(Debug, Copy, Clone)]
1182pub enum Instructions {
1183    /// An immediate constant value
1184    Value(Value),
1185    /// A constant value referenced by the global specified
1186    Global(GlobalID),
1187    /// A null reference
1188    RefNull(RefType),
1189    /// A function initializer
1190    RefFunc(FunctionID),
1191    /// Struct Initializer
1192    StructNew(TypeID),
1193    /// Struct Default
1194    StructNewDefault(TypeID),
1195    /// Array Initializer
1196    ArrayNew(TypeID),
1197    /// Default Initialisation
1198    ArrayNewDefault(TypeID),
1199    /// Fixed Array
1200    RefArrayFixed {
1201        array_type_index: u32,
1202        array_size: u32,
1203    },
1204    /// Array from Data
1205    RefArrayData {
1206        array_type_index: u32,
1207        array_data_index: u32,
1208    },
1209    /// Array from Elem
1210    RefArrayElem {
1211        array_type_index: u32,
1212        array_elem_index: u32,
1213    },
1214    RefI31,
1215}
1216
1217impl InitExpr {
1218    /// Create a new initialisation expression given a vector of Instructions
1219    pub fn new(instructions: Vec<Instructions>) -> Self {
1220        InitExpr {
1221            exprs: instructions,
1222        }
1223    }
1224
1225    pub(crate) fn eval(init: &ConstExpr) -> InitExpr {
1226        use wasmparser::Operator::*;
1227        let mut reader = init.get_operators_reader();
1228        let mut instrs = vec![];
1229        loop {
1230            let val = match reader.read().unwrap() {
1231                I32Const { value } => Instructions::Value(Value::I32(value)),
1232                I64Const { value } => Instructions::Value(Value::I64(value)),
1233                F32Const { value } => Instructions::Value(Value::F32(f32::from_bits(value.bits()))),
1234                F64Const { value } => Instructions::Value(Value::F64(f64::from_bits(value.bits()))),
1235                V128Const { value } => Instructions::Value(Value::V128(v128_to_u128(&value))),
1236                GlobalGet { global_index } => Instructions::Global(GlobalID(global_index)),
1237                // Marking nullable as true as it's a null reference
1238                RefNull { hty } => Instructions::RefNull(RefType::new(true, hty).unwrap()),
1239                RefFunc { function_index } => Instructions::RefFunc(FunctionID(function_index)),
1240                StructNew { struct_type_index } => {
1241                    Instructions::StructNew(TypeID(struct_type_index))
1242                }
1243                StructNewDefault { struct_type_index } => {
1244                    Instructions::StructNewDefault(TypeID(struct_type_index))
1245                }
1246                ArrayNew { array_type_index } => Instructions::ArrayNew(TypeID(array_type_index)),
1247                ArrayNewDefault { array_type_index } => {
1248                    Instructions::ArrayNewDefault(TypeID(array_type_index))
1249                }
1250                ArrayNewFixed {
1251                    array_type_index,
1252                    array_size,
1253                } => Instructions::RefArrayFixed {
1254                    array_type_index,
1255                    array_size,
1256                },
1257                ArrayNewData {
1258                    array_type_index,
1259                    array_data_index,
1260                } => Instructions::RefArrayData {
1261                    array_data_index,
1262                    array_type_index,
1263                },
1264                ArrayNewElem {
1265                    array_type_index,
1266                    array_elem_index,
1267                } => Instructions::RefArrayElem {
1268                    array_type_index,
1269                    array_elem_index,
1270                },
1271                RefI31 => Instructions::RefI31,
1272                End => break,
1273                _ => panic!("Invalid constant expression"),
1274            };
1275            instrs.push(val);
1276        }
1277        reader.ensure_end().unwrap();
1278        InitExpr { exprs: instrs }
1279    }
1280
1281    pub(crate) fn to_wasmencoder_type(&self) -> wasm_encoder::ConstExpr {
1282        let mut bytes = vec![];
1283        for instr in self.exprs.iter() {
1284            match instr {
1285                Instructions::Value(v) => match v {
1286                    Value::I32(v) => wasm_encoder::Instruction::I32Const(*v).encode(&mut bytes),
1287                    Value::I64(v) => wasm_encoder::Instruction::I64Const(*v).encode(&mut bytes),
1288                    Value::F32(v) => wasm_encoder::Instruction::F32Const(*v).encode(&mut bytes),
1289                    Value::F64(v) => wasm_encoder::Instruction::F64Const(*v).encode(&mut bytes),
1290                    Value::V128(v) => {
1291                        wasm_encoder::Instruction::V128Const(*v as i128).encode(&mut bytes)
1292                    }
1293                },
1294                Instructions::Global(g) => {
1295                    wasm_encoder::Instruction::GlobalGet(**g).encode(&mut bytes)
1296                }
1297                Instructions::RefNull(ty) => {
1298                    wasm_encoder::Instruction::RefNull(match ty.heap_type() {
1299                        HeapType::Abstract { shared, ty } => match ty {
1300                            wasmparser::AbstractHeapType::Func => {
1301                                wasm_encoder::HeapType::Abstract {
1302                                    ty: AbstractHeapType::Func,
1303                                    shared,
1304                                }
1305                            }
1306                            wasmparser::AbstractHeapType::Extern => {
1307                                wasm_encoder::HeapType::Abstract {
1308                                    ty: AbstractHeapType::Extern,
1309                                    shared,
1310                                }
1311                            }
1312                            wasmparser::AbstractHeapType::Any => wasm_encoder::HeapType::Abstract {
1313                                ty: AbstractHeapType::Any,
1314                                shared,
1315                            },
1316                            wasmparser::AbstractHeapType::None => {
1317                                wasm_encoder::HeapType::Abstract {
1318                                    ty: AbstractHeapType::None,
1319                                    shared,
1320                                }
1321                            }
1322                            wasmparser::AbstractHeapType::NoExtern => {
1323                                wasm_encoder::HeapType::Abstract {
1324                                    ty: AbstractHeapType::NoExtern,
1325                                    shared,
1326                                }
1327                            }
1328                            wasmparser::AbstractHeapType::NoFunc => {
1329                                wasm_encoder::HeapType::Abstract {
1330                                    ty: AbstractHeapType::NoFunc,
1331                                    shared,
1332                                }
1333                            }
1334                            wasmparser::AbstractHeapType::Eq => wasm_encoder::HeapType::Abstract {
1335                                ty: AbstractHeapType::Eq,
1336                                shared,
1337                            },
1338                            wasmparser::AbstractHeapType::Struct => {
1339                                wasm_encoder::HeapType::Abstract {
1340                                    ty: AbstractHeapType::Struct,
1341                                    shared,
1342                                }
1343                            }
1344                            wasmparser::AbstractHeapType::Array => {
1345                                wasm_encoder::HeapType::Abstract {
1346                                    ty: AbstractHeapType::Array,
1347                                    shared,
1348                                }
1349                            }
1350                            wasmparser::AbstractHeapType::I31 => wasm_encoder::HeapType::Abstract {
1351                                ty: AbstractHeapType::I31,
1352                                shared,
1353                            },
1354                            wasmparser::AbstractHeapType::Exn => wasm_encoder::HeapType::Abstract {
1355                                ty: AbstractHeapType::Exn,
1356                                shared,
1357                            },
1358                            wasmparser::AbstractHeapType::NoExn => {
1359                                wasm_encoder::HeapType::Abstract {
1360                                    ty: AbstractHeapType::NoExn,
1361                                    shared,
1362                                }
1363                            }
1364                            wasmparser::AbstractHeapType::Cont => {
1365                                wasm_encoder::HeapType::Abstract {
1366                                    ty: AbstractHeapType::Cont,
1367                                    shared,
1368                                }
1369                            }
1370                            wasmparser::AbstractHeapType::NoCont => {
1371                                wasm_encoder::HeapType::Abstract {
1372                                    ty: AbstractHeapType::NoCont,
1373                                    shared,
1374                                }
1375                            }
1376                        },
1377                        HeapType::Concrete(id) => {
1378                            if let Some(mod_id) = id.as_module_index() {
1379                                wasm_encoder::HeapType::Concrete(mod_id)
1380                            } else if let Some(rg_id) = id.as_rec_group_index() {
1381                                wasm_encoder::HeapType::Concrete(rg_id)
1382                            } else if let Some(core) = id.as_core_type_id() {
1383                                wasm_encoder::HeapType::Concrete(core.index() as u32)
1384                            } else {
1385                                panic!("Did not unpack concrete type!")
1386                            }
1387                        }
1388                    })
1389                    .encode(&mut bytes)
1390                }
1391                Instructions::RefFunc(f) => {
1392                    wasm_encoder::Instruction::RefFunc(**f).encode(&mut bytes)
1393                }
1394                Instructions::StructNew(id) => {
1395                    wasm_encoder::Instruction::StructNew(**id).encode(&mut bytes);
1396                }
1397                Instructions::ArrayNew(id) => {
1398                    wasm_encoder::Instruction::ArrayNew(**id).encode(&mut bytes);
1399                }
1400
1401                Instructions::StructNewDefault(id) => {
1402                    wasm_encoder::Instruction::StructNewDefault(**id).encode(&mut bytes);
1403                }
1404                Instructions::ArrayNewDefault(id) => {
1405                    wasm_encoder::Instruction::ArrayNewDefault(**id).encode(&mut bytes);
1406                }
1407                Instructions::RefArrayFixed {
1408                    array_type_index,
1409                    array_size,
1410                } => {
1411                    wasm_encoder::Instruction::ArrayNewFixed {
1412                        array_size: *array_size,
1413                        array_type_index: *array_type_index,
1414                    }
1415                    .encode(&mut bytes);
1416                }
1417                Instructions::RefArrayData {
1418                    array_type_index,
1419                    array_data_index,
1420                } => {
1421                    wasm_encoder::Instruction::ArrayNewData {
1422                        array_data_index: *array_data_index,
1423                        array_type_index: *array_type_index,
1424                    }
1425                    .encode(&mut bytes);
1426                }
1427                Instructions::RefArrayElem {
1428                    array_type_index,
1429                    array_elem_index,
1430                } => {
1431                    wasm_encoder::Instruction::ArrayNewElem {
1432                        array_elem_index: *array_elem_index,
1433                        array_type_index: *array_type_index,
1434                    }
1435                    .encode(&mut bytes);
1436                }
1437                Instructions::RefI31 => wasm_encoder::Instruction::RefI31.encode(&mut bytes),
1438            }
1439        }
1440        wasm_encoder::ConstExpr::raw(bytes)
1441    }
1442}
1443
1444/// Constant values that can show up in WebAssembly
1445#[derive(Debug, Clone, Copy)]
1446pub enum Value {
1447    /// A constant 32-bit integer
1448    I32(i32),
1449    /// A constant 64-bit integer
1450    I64(i64),
1451    /// A constant 32-bit float
1452    F32(f32),
1453    /// A constant 64-bit float
1454    F64(f64),
1455    /// A constant 128-bit vector register
1456    V128(u128),
1457}
1458
1459impl fmt::Display for Value {
1460    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
1461        match self {
1462            Value::I32(i) => i.fmt(f),
1463            Value::I64(i) => i.fmt(f),
1464            Value::F32(i) => i.fmt(f),
1465            Value::F64(i) => i.fmt(f),
1466            Value::V128(i) => i.fmt(f),
1467        }
1468    }
1469}
1470
1471#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1472pub enum BlockType {
1473    /// The block produces consumes nor produces any values.
1474    Empty,
1475    /// The block produces a singular value of the given type ([] -> \[t]).
1476    Type(DataType),
1477    /// The block is described by a function type.
1478    ///
1479    /// The index is to a function type in the types section.
1480    FuncType(TypeID),
1481}
1482
1483impl From<wasmparser::BlockType> for BlockType {
1484    fn from(value: wasmparser::BlockType) -> Self {
1485        match value {
1486            wasmparser::BlockType::Empty => BlockType::Empty,
1487            wasmparser::BlockType::FuncType(u) => BlockType::FuncType(TypeID(u)),
1488            wasmparser::BlockType::Type(val) => BlockType::Type(DataType::from(val)),
1489        }
1490    }
1491}
1492
1493impl From<BlockType> for wasmparser::BlockType {
1494    fn from(ty: BlockType) -> Self {
1495        match ty {
1496            BlockType::Empty => wasmparser::BlockType::Empty,
1497            BlockType::FuncType(u) => wasmparser::BlockType::FuncType(*u),
1498            BlockType::Type(data) => wasmparser::BlockType::Type(ValType::from(&data)),
1499        }
1500    }
1501}
1502
1503/// Intermediate Representation of Custom Sections
1504#[derive(Clone, Debug, Default)]
1505pub struct CustomSections<'a> {
1506    custom_sections: Vec<CustomSection<'a>>,
1507}
1508
1509impl<'a> CustomSections<'a> {
1510    pub fn new(custom_sections: Vec<(&'a str, &'a [u8])>) -> Self {
1511        CustomSections {
1512            custom_sections: custom_sections
1513                .iter()
1514                .map(|cs| CustomSection::new(cs.0, cs.1))
1515                .collect(),
1516        }
1517    }
1518
1519    /// Get a custom section ID by name
1520    pub fn get_id(&self, name: String) -> Option<CustomSectionID> {
1521        for (index, section) in self.custom_sections.iter().enumerate() {
1522            if section.name == name {
1523                return Some(CustomSectionID(index as u32));
1524            }
1525        }
1526        None
1527    }
1528
1529    /// Get a custom section by its ID
1530    pub fn get_by_id(&self, custom_section_id: CustomSectionID) -> &CustomSection {
1531        if *custom_section_id < self.custom_sections.len() as u32 {
1532            return &self.custom_sections[*custom_section_id as usize];
1533        }
1534        panic!("Invalid custom section ID");
1535    }
1536
1537    /// Delete a Custom Section by its ID
1538    pub fn delete(&mut self, id: CustomSectionID) {
1539        if *id < self.custom_sections.len() as u32 {
1540            self.custom_sections.remove(*id as usize);
1541        }
1542    }
1543
1544    /// Number of custom sections
1545    pub fn len(&self) -> usize {
1546        self.custom_sections.len()
1547    }
1548
1549    /// Check if there are any custom sections
1550    pub fn is_empty(&self) -> bool {
1551        self.custom_sections.is_empty()
1552    }
1553
1554    /// Creates an iterable over the custom sections
1555    pub fn iter(&self) -> Iter<'_, CustomSection<'a>> {
1556        self.custom_sections.iter()
1557    }
1558}
1559
1560/// Intermediate Representation of a single Custom Section
1561#[derive(Clone, Debug)]
1562pub struct CustomSection<'a> {
1563    pub name: &'a str,
1564    pub data: &'a [u8],
1565}
1566
1567impl<'a> CustomSection<'a> {
1568    /// Create a new custom section
1569    pub fn new(name: &'a str, data: &'a [u8]) -> Self {
1570        CustomSection { name, data }
1571    }
1572}
1573
1574#[allow(clippy::identity_op)]
1575pub(crate) fn v128_to_u128(value: &wasmparser::V128) -> u128 {
1576    let n = value.bytes();
1577    ((n[0] as u128) << 0)
1578        | ((n[1] as u128) << 8)
1579        | ((n[2] as u128) << 16)
1580        | ((n[3] as u128) << 24)
1581        | ((n[4] as u128) << 32)
1582        | ((n[5] as u128) << 40)
1583        | ((n[6] as u128) << 48)
1584        | ((n[7] as u128) << 56)
1585        | ((n[8] as u128) << 64)
1586        | ((n[9] as u128) << 72)
1587        | ((n[10] as u128) << 80)
1588        | ((n[11] as u128) << 88)
1589        | ((n[12] as u128) << 96)
1590        | ((n[13] as u128) << 104)
1591        | ((n[14] as u128) << 112)
1592        | ((n[15] as u128) << 120)
1593}
orca_wasm/ir/types.rs

orca_wasm/ir/
types.rs
