How to validate the ref.func instruction

[CharlieTap]

I'm working on a single pass validator and I'm a little bit confused as to how to validate the ref.func instruction. My understanding is that the function index in the instruction must exist in C.refs. I populate refs by adding all function indices found in a module with the exception of the start function index and also the current function index if we are currently validating a functions instruction.

Which seemed correct looking at these two tests:

(assert_invalid
  (module (func $f (drop (ref.func $f))))
  "undeclared function reference"
)
(assert_invalid
  (module (start $f) (func $f (drop (ref.func $f))))
  "undeclared function reference"
)

However I'm failing this test from the table_grow script so I must be misunderstanding 😅

(module
  (table $t 0x10 funcref)
  (elem declare func $f)
  (func $f (export "grow") (result i32)
    (table.grow $t (ref.func $f) (i32.const 0xffff_fff0))
  )
)

[rossberg]

I populate refs by adding all function indices found in a module with the exception of the start function index and also the current function index if we are currently validating a functions instruction.

Why are you excluding the current function?

[CharlieTap]

Purely because of this test

(assert_invalid
  (module (func $f (drop (ref.func $f))))
  "undeclared function reference"
)

I assumed that this meant that you can't reference a function inside of itself, or something to that effect

[rossberg]

C.refs is initialised here:

C.refs is the set funcidx(module with funcs = ε with start = ε), i.e., the set of function indices occurring in the module, except in its functions or start function.

This is saying that C.refs must only include function indices that occur outside any function. Hence, the latter example fails because the only occurrence of $f is inside a function, while in the other test, $f does also occur in an element segment, so outside a function.

[CharlieTap]

Ah okay, for those in the future, a more verbose way of describing it would be the sum of function indices found in expressions and descriptors of:

• exports
• tables
• globals
• data segments
• element segments

[bashor]

@rossberg I'm just wondering why it's done that way. Why we can't refer any function in code section without forward declaration?

[tlively]

The original rationale was that engines might have to do some extra work (like generate extra wrappers) for referenced functions as compared to non-referenced functions. To avoid having to conservatively do all that extra work for all functions, we wanted it to be possible to tell exactly which functions will be referenced before parsing the code section.

[rossberg]

To add to @tlively's answer, Wasm is supposed to support streaming compilation, i.e., the engine needs to have all necessary knowledge about a function when it reaches it in a single-pass compilation scheme for modules, even when that module isn't fully downloaded yet.