Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

11.1 KB
Raw Blame
;;! target = "x86_64"
;;! test = "optimize"
;;! flags = [ "-Wfunction-references=y", "-Otable-lazy-init=y" ]

;; This test is meant to simulate how typed funcrefs in a table may be
;; used for ICs (inline caches) in a Wasm module compiled from a dynamic
;; language. In native JIT engines, IC chains have head pointers that
;; are raw code pointers and IC-using code can call each with a few ops
;; (load pointer, call indirect). We'd like similar efficiency by
;; storing funcrefs for the first IC in each chain in a typed-funcref
;; table.

(module
  (type $ic-stub (func (param i32 i32 i32 i32) (result i32)))

  ;; This syntax declares a table that is exactly 100 elements, whose
  ;; elements are nullable function references, and whose default
  ;; value is `null`.
  (table $ic-sites 100 100 (ref null $ic-stub))

  (func $ic1 (param i32 i32 i32 i32) (result i32)
        local.get 0)

  ;; A function which uses ICs through `table.get` plus `call_ref`
  (func $call-ics-with-call-ref (param i32 i32 i32 i32) (result i32)
        (local $sum i32)

        ;; IC callsite index 1 (arbitrary).
        local.get 0
        local.get 1
        local.get 2
        local.get 3
        i32.const 1
        table.get $ic-sites
        call_ref $ic-stub
        local.get $sum
        i32.add
        local.set $sum

        ;; IC callsite index 2 (arbitrary).
        local.get 0
        local.get 1
        local.get 2
        local.get 3
        i32.const 2
        table.get $ic-sites
        call_ref $ic-stub
        local.get $sum
        i32.add
        local.set $sum

        local.get $sum)

  ;; Same as the above function, but uses `call_indirect` rather than
  ;; `call_ref`.
  (func $call-ics-with-call-indirect (param i32 i32 i32 i32) (result i32)
        (local $sum i32)

        ;; IC callsite index 1 (arbitrary).
        local.get 0
        local.get 1
        local.get 2
        local.get 3
        i32.const 1
        call_indirect $ic-sites (type $ic-stub)
        local.get $sum
        i32.add
        local.set $sum

        ;; IC callsite index 2 (arbitrary).
        local.get 0
        local.get 1
        local.get 2
        local.get 3
        i32.const 2
        call_indirect $ic-sites (type $ic-stub)
        local.get $sum
        i32.add
        local.set $sum

        local.get $sum)

  (global $ic-site0 (mut (ref $ic-stub)) (ref.func $ic1))
  (global $ic-site1 (mut (ref $ic-stub)) (ref.func $ic1))

  ;; Sort of similar to the previous two functions, but uses globals instead of
  ;; tables to store ICs. Mostly just here for comparison in terms of codegen.
  (func $call-ics-with-global-get (param i32 i32 i32 i32) (result i32)
        (local $sum i32)

        ;; IC callsite index 1 (arbitrary).
        local.get 0
        local.get 1
        local.get 2
        local.get 3
        global.get $ic-site0
        call_ref $ic-stub
        local.get $sum
        i32.add
        local.set $sum

        ;; IC callsite index 2 (arbitrary).
        local.get 0
        local.get 1
        local.get 2
        local.get 3
        global.get $ic-site1
        call_ref $ic-stub
        local.get $sum
        i32.add
        local.set $sum

        local.get $sum)
)

;; function u0:0(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
;;     region0 = 123 ""
;;     region1 = 160 ""
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
;;     gv2 = load.i64 notrap aligned region1 gv1+24
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
;; @0039                               jump block1
;;
;;                                 block1:
;; @0039                               return v2
;; }
;;
;; function u0:1(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
;;     region0 = 123 ""
;;     region1 = 160 ""
;;     region2 = 93 ""
;;     region3 = 117 ""
;;     region4 = 120 ""
;;     region5 = 100 ""
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
;;     gv2 = load.i64 notrap aligned region1 gv1+24
;;     sig0 = (i64 vmctx, i32, i64) -> i64 tail
;;     sig1 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
;;     fn0 = colocated u805306368:6 sig0
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
;; @0048                               v11 = load.i64 notrap aligned readonly can_move region2 v0+48
;;                                     v62 = iconst.i64 8
;; @0048                               v14 = iadd v11, v62  ; v62 = 8
;; @0048                               v17 = load.i64 user6 aligned region3 v14
;; @0048                               v18 = iconst.i64 -2
;; @0048                               v19 = band v17, v18  ; v18 = -2
;; @0048                               brif v17, block3(v19), block2
;;
;;                                 block2 cold:
;; @003c                               v6 = iconst.i32 0
;;                                     v61 = iconst.i64 1
;; @0048                               v23 = call fn0(v0, v6, v61)  ; v6 = 0, v61 = 1
;; @0048                               jump block3(v23)
;;
;;                                 block3(v20: i64):
;; @004a                               v24 = load.i64 user16 aligned readonly region4 v20+8
;; @004a                               v25 = load.i64 notrap aligned readonly region5 v20+24
;; @004a                               v26 = call_indirect sig1, v24(v25, v0, v2, v3, v4, v5)
;;                                     v69 = iconst.i64 16
;; @005b                               v40 = iadd.i64 v11, v69  ; v69 = 16
;; @005b                               v43 = load.i64 user6 aligned region3 v40
;; @0048                               v70 = iconst.i64 -2
;; @005b                               v71 = band v43, v70  ; v70 = -2
;; @005b                               brif v43, block5(v71), block4
;;
;;                                 block4 cold:
;; @003c                               v72 = iconst.i32 0
;;                                     v68 = iconst.i64 2
;; @005b                               v49 = call fn0(v0, v72, v68)  ; v72 = 0, v68 = 2
;; @005b                               jump block5(v49)
;;
;;                                 block5(v46: i64):
;; @005d                               v50 = load.i64 user16 aligned readonly region4 v46+8
;; @005d                               v51 = load.i64 notrap aligned readonly region5 v46+24
;; @005d                               v52 = call_indirect sig1, v50(v51, v0, v2, v3, v4, v5)
;; @0066                               jump block1
;;
;;                                 block1:
;; @0061                               v54 = iadd.i32 v52, v26
;; @0066                               return v54
;; }
;;
;; function u0:2(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
;;     region0 = 123 ""
;;     region1 = 160 ""
;;     region2 = 93 ""
;;     region3 = 117 ""
;;     region4 = 120 ""
;;     region5 = 100 ""
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
;;     gv2 = load.i64 notrap aligned region1 gv1+24
;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
;;     sig1 = (i64 vmctx, i32, i64) -> i64 tail
;;     fn0 = colocated u805306368:6 sig1
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
;; @0075                               v11 = load.i64 notrap aligned readonly can_move region2 v0+48
;;                                     v62 = iconst.i64 8
;; @0075                               v14 = iadd v11, v62  ; v62 = 8
;; @0075                               v17 = load.i64 user6 aligned region3 v14
;; @0075                               v18 = iconst.i64 -2
;; @0075                               v19 = band v17, v18  ; v18 = -2
;; @0075                               brif v17, block3(v19), block2
;;
;;                                 block2 cold:
;; @0069                               v6 = iconst.i32 0
;;                                     v61 = iconst.i64 1
;; @0075                               v23 = call fn0(v0, v6, v61)  ; v6 = 0, v61 = 1
;; @0075                               jump block3(v23)
;;
;;                                 block3(v20: i64):
;; @0075                               v24 = load.i64 user7 aligned readonly region4 v20+8
;; @0075                               v25 = load.i64 notrap aligned readonly region5 v20+24
;; @0075                               v26 = call_indirect sig0, v24(v25, v0, v2, v3, v4, v5)
;;                                     v69 = iconst.i64 16
;; @0087                               v40 = iadd.i64 v11, v69  ; v69 = 16
;; @0087                               v43 = load.i64 user6 aligned region3 v40
;; @0075                               v70 = iconst.i64 -2
;; @0087                               v71 = band v43, v70  ; v70 = -2
;; @0087                               brif v43, block5(v71), block4
;;
;;                                 block4 cold:
;; @0069                               v72 = iconst.i32 0
;;                                     v68 = iconst.i64 2
;; @0087                               v49 = call fn0(v0, v72, v68)  ; v72 = 0, v68 = 2
;; @0087                               jump block5(v49)
;;
;;                                 block5(v46: i64):
;; @0087                               v50 = load.i64 user7 aligned readonly region4 v46+8
;; @0087                               v51 = load.i64 notrap aligned readonly region5 v46+24
;; @0087                               v52 = call_indirect sig0, v50(v51, v0, v2, v3, v4, v5)
;; @0091                               jump block1
;;
;;                                 block1:
;; @008c                               v54 = iadd.i32 v52, v26
;; @0091                               return v54
;; }
;;
;; function u0:3(i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail {
;;     region0 = 123 ""
;;     region1 = 160 ""
;;     region2 = 250 ""
;;     region3 = 120 ""
;;     region4 = 100 ""
;;     region5 = 135 ""
;;     gv0 = vmctx
;;     gv1 = load.i64 notrap aligned readonly can_move region0 gv0+8
;;     gv2 = load.i64 notrap aligned region1 gv1+24
;;     sig0 = (i64 vmctx, i64, i32, i32, i32, i32) -> i32 tail
;;     stack_limit = gv2
;;
;;                                 block0(v0: i64, v1: i64, v2: i32, v3: i32, v4: i32, v5: i32):
;; @009e                               v7 = load.i64 notrap aligned region2 v0+64
;; @00a0                               v8 = load.i64 user16 aligned readonly region3 v7+8
;; @00a0                               v9 = load.i64 notrap aligned readonly region4 v7+24
;; @00a0                               v10 = call_indirect sig0, v8(v9, v0, v2, v3, v4, v5)
;; @00af                               v12 = load.i64 notrap aligned region5 v0+80
;; @00b1                               v13 = load.i64 user16 aligned readonly region3 v12+8
;; @00b1                               v14 = load.i64 notrap aligned readonly region4 v12+24
;; @00b1                               v15 = call_indirect sig0, v13(v14, v0, v2, v3, v4, v5)
;; @00ba                               jump block1
;;
;;                                 block1:
;; @00b5                               v16 = iadd.i32 v15, v10
;; @00ba                               return v16
;; }