Function references

build.rs

@@ -30,6 +30,7 @@ fn main() -> anyhow::Result<()> {
  test_directory_module(out, "tests/misc_testsuite/threads", strategy)?;
  test_directory_module(out, "tests/misc_testsuite/memory64", strategy)?;
  test_directory_module(out, "tests/misc_testsuite/component-model", strategy)?;
+ test_directory_module(out, "tests/misc_testsuite/function-references", strategy)?;
  Ok(())
  })?;
 
@@ -39,6 +40,11 @@ fn main() -> anyhow::Result<()> {
  // out.
  if spec_tests > 0 {
  test_directory_module(out, "tests/spec_testsuite/proposals/memory64", strategy)?;
+ test_directory_module(
+ out,
+ "tests/spec_testsuite/proposals/function-references",
+ strategy,
+ )?;
  test_directory_module(
  out,
  "tests/spec_testsuite/proposals/multi-memory",
@@ -187,6 +193,30 @@ fn ignore(testsuite: &str, testname: &str, strategy: &str) -> bool {
  return true;
  }
 
+ // Tail calls are not yet implemented.
+ if testname.contains("return_call") {
+ return true;
+ }
+
+ if testsuite == "function_references" {
+ // The following tests fail due to function references not yet
+ // being exposed in the public API.
+ if testname == "ref_null" || testname == "local_init" {
+ return true;
+ }
+ // This test fails due to incomplete support for the various
+ // table/elem syntactic sugar in wasm-tools/wast.
+ if testname == "br_table" {
+ return true;
+ }
+ // This test fails due to the current implementation of type
+ // canonicalisation being broken as a result of
+ // #[derive(hash)] on WasmHeapType.
+ if testname == "type_equivalence" {
+ return true;
+ }
+ }
+
  match env::var("CARGO_CFG_TARGET_ARCH").unwrap().as_str() {
  "s390x" => {
  // FIXME: These tests fail under qemu due to a qemu bug.

cranelift/codegen/src/ir/trapcode.rs

@@ -51,6 +51,9 @@ pub enum TrapCode {
 
  /// A user-defined trap code.
  User(u16),
+
+ /// A null reference was encountered which was required to be non-null.
+ NullReference,
 }
 
 impl TrapCode {
@@ -68,6 +71,7 @@ impl TrapCode {
  TrapCode::BadConversionToInteger,
  TrapCode::UnreachableCodeReached,
  TrapCode::Interrupt,
+ TrapCode::NullReference,
  ]
  }
 }
@@ -88,6 +92,7 @@ impl Display for TrapCode {
  UnreachableCodeReached => "unreachable",
  Interrupt => "interrupt",
  User(x) => return write!(f, "user{}", x),
+ NullReference => "null_reference",
  };
  f.write_str(identifier)
  }
@@ -110,6 +115,7 @@ impl FromStr for TrapCode {
  "bad_toint" => Ok(BadConversionToInteger),
  "unreachable" => Ok(UnreachableCodeReached),
  "interrupt" => Ok(Interrupt),
+ "null_reference" => Ok(NullReference),
  _ if s.starts_with("user") => s[4..].parse().map(User).map_err(|_| ()),
  _ => Err(()),
  }

cranelift/codegen/src/verifier/mod.rs

@@ -1175,7 +1175,10 @@ impl<'a> Verifier<'a> {
  errors.report((
  inst,
  self.context(inst),
- format!("has an invalid controlling type {}", ctrl_type),
+ format!(
+ "has an invalid controlling type {} (allowed set is {:?})",
+ ctrl_type, value_typeset
+ ),
  ));
  }
 

cranelift/filetests/src/test_wasm/env.rs

@@ -13,6 +13,7 @@ use cranelift_codegen::{
 };
 use cranelift_wasm::{
  DummyEnvironment, FuncEnvironment, FuncIndex, ModuleEnvironment, TargetEnvironment,
+ TypeConvert, TypeIndex, WasmHeapType,
 };
 
 pub struct ModuleEnv {
@@ -235,6 +236,12 @@ impl<'data> ModuleEnvironment<'data> for ModuleEnv {
  }
 }
 
+impl TypeConvert for ModuleEnv {
+ fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+ todo!()
+ }
+}
+
 pub struct FuncEnv<'a> {
  pub inner: cranelift_wasm::DummyFuncEnvironment<'a>,
  pub config: TestConfig,
@@ -261,6 +268,12 @@ impl<'a> FuncEnv<'a> {
  }
 }
 
+impl TypeConvert for FuncEnv<'_> {
+ fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+ todo!()
+ }
+}
+
 impl<'a> TargetEnvironment for FuncEnv<'a> {
  fn target_config(&self) -> TargetFrontendConfig {
  self.inner.target_config()
@@ -622,4 +635,14 @@ impl<'a> FuncEnvironment for FuncEnv<'a> {
  fn is_x86(&self) -> bool {
  self.config.target.contains("x86_64")
  }
+
+ fn translate_call_ref(
+ &mut self,
+ _builder: &mut cranelift_frontend::FunctionBuilder<'_>,
+ _ty: ir::SigRef,
+ _func: ir::Value,
+ _args: &[ir::Value],
+ ) -> cranelift_wasm::WasmResult<ir::Inst> {
+ unimplemented!()
+ }
 }

cranelift/wasm/src/code_translator.rs

@@ -81,7 +81,6 @@ use crate::translation_utils::{
 };
 use crate::wasm_unsupported;
 use crate::{FuncIndex, GlobalIndex, MemoryIndex, TableIndex, TypeIndex, WasmResult};
-use core::convert::TryInto;
 use core::{i32, u32};
 use cranelift_codegen::ir::condcodes::{FloatCC, IntCC};
 use cranelift_codegen::ir::immediates::Offset32;
@@ -1152,7 +1151,8 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
  translate_fcmp(FloatCC::LessThanOrEqual, builder, state)
  }
  Operator::RefNull { hty } => {
- state.push1(environ.translate_ref_null(builder.cursor(), (*hty).try_into()?)?)
+ let hty = environ.convert_heap_type(*hty);
+ state.push1(environ.translate_ref_null(builder.cursor(), hty)?)
  }
  Operator::RefIsNull => {
  let value = state.pop1();
@@ -2337,16 +2337,74 @@ pub fn translate_operator<FE: FuncEnvironment + ?Sized>(
  state.push1(builder.ins().iadd(dot32, c));
  }
 
- Operator::CallRef { .. }
- | Operator::ReturnCallRef { .. }
- | Operator::BrOnNull { .. }
- | Operator::BrOnNonNull { .. }
- | Operator::RefAsNonNull => {
+ Operator::ReturnCallRef { type_index: _ } => {
  return Err(wasm_unsupported!(
- "proposed function-references operator {:?}",
+ "proposed tail-call operator for function references {:?}",
  op
  ));
  }
+ Operator::BrOnNull { relative_depth } => {
+ let r = state.pop1();
+ let (br_destination, inputs) = translate_br_if_args(*relative_depth, state);
+ let is_null = environ.translate_ref_is_null(builder.cursor(), r)?;
+ let else_block = builder.create_block();
+ canonicalise_brif(builder, is_null, br_destination, inputs, else_block, &[]);
+
+ builder.seal_block(else_block); // The only predecessor is the current block.
+ builder.switch_to_block(else_block);
+ state.push1(r);
+ }
+ Operator::BrOnNonNull { relative_depth } => {
+ // We write this a bit differently from the spec to avoid an extra
+ // block/branch and the typed accounting thereof. Instead of the
+ // spec's approach, it's described as such:
+ // Peek the value val from the stack.
+ // If val is ref.null ht, then: pop the value val from the stack.
+ // Else: Execute the instruction (br relative_depth).
+ let is_null = environ.translate_ref_is_null(builder.cursor(), state.peek1())?;
+ let (br_destination, inputs) = translate_br_if_args(*relative_depth, state);
+ let else_block = builder.create_block();
+ canonicalise_brif(builder, is_null, else_block, &[], br_destination, inputs);
+
+ // In the null case, pop the ref
+ state.pop1();
+
+ builder.seal_block(else_block); // The only predecessor is the current block.
+
+ // The rest of the translation operates on our is null case, which is
+ // currently an empty block
+ builder.switch_to_block(else_block);
+ }
+ Operator::CallRef { type_index } => {
+ // Get function signature
+ // `index` is the index of the function's signature and `table_index` is the index of
+ // the table to search the function in.
+ let (sigref, num_args) = state.get_indirect_sig(builder.func, *type_index, environ)?;
+ let callee = state.pop1();
+
+ // Bitcast any vector arguments to their default type, I8X16, before calling.
+ let args = state.peekn_mut(num_args);
+ bitcast_wasm_params(environ, sigref, args, builder);
+
+ let call =
+ environ.translate_call_ref(builder, sigref, callee, state.peekn(num_args))?;
+
+ let inst_results = builder.inst_results(call);
+ debug_assert_eq!(
+ inst_results.len(),
+ builder.func.dfg.signatures[sigref].returns.len(),
+ "translate_call_ref results should match the call signature"
+ );
+ state.popn(num_args);
+ state.pushn(inst_results);
+ }
+ Operator::RefAsNonNull => {
+ let r = state.pop1();
+ let is_null = environ.translate_ref_is_null(builder.cursor(), r)?;
+ builder.ins().trapnz(is_null, ir::TrapCode::NullReference);
+ state.push1(r);
+ }
+
  Operator::I31New | Operator::I31GetS | Operator::I31GetU => {
  unimplemented!("GC operators not yet implemented")
  }

cranelift/wasm/src/environ/dummy.rs

@@ -11,8 +11,8 @@ use crate::state::FuncTranslationState;
 use crate::WasmType;
 use crate::{
  DataIndex, DefinedFuncIndex, ElemIndex, FuncIndex, Global, GlobalIndex, GlobalInit, Heap,
- HeapData, HeapStyle, Memory, MemoryIndex, Table, TableIndex, TypeIndex, WasmFuncType,
- WasmResult,
+ HeapData, HeapStyle, Memory, MemoryIndex, Table, TableIndex, TypeConvert, TypeIndex,
+ WasmFuncType, WasmHeapType, WasmResult,
 };
 use core::convert::TryFrom;
 use cranelift_codegen::cursor::FuncCursor;
@@ -251,6 +251,12 @@ impl<'dummy_environment> DummyFuncEnvironment<'dummy_environment> {
  }
 }
 
+impl<'dummy_environment> TypeConvert for DummyFuncEnvironment<'dummy_environment> {
+ fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+ unimplemented!()
+ }
+}
+
 impl<'dummy_environment> TargetEnvironment for DummyFuncEnvironment<'dummy_environment> {
  fn target_config(&self) -> TargetFrontendConfig {
  self.mod_info.config
@@ -279,7 +285,7 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
  WasmType::F32 => ir::types::F32,
  WasmType::F64 => ir::types::F64,
  WasmType::V128 => ir::types::I8X16,
- WasmType::FuncRef | WasmType::ExternRef => ir::types::R64,
+ WasmType::Ref(_) => ir::types::R64,
  },
  })
  }
@@ -464,6 +470,16 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
  Ok(pos.ins().Call(ir::Opcode::Call, INVALID, callee, args).0)
  }
 
+ fn translate_call_ref(
+ &mut self,
+ _builder: &mut FunctionBuilder,
+ _sig_ref: ir::SigRef,
+ _callee: ir::Value,
+ _call_args: &[ir::Value],
+ ) -> WasmResult<ir::Inst> {
+ todo!("Implement dummy translate_call_ref")
+ }
+
  fn translate_memory_grow(
  &mut self,
  mut pos: FuncCursor,
@@ -658,6 +674,12 @@ impl<'dummy_environment> FuncEnvironment for DummyFuncEnvironment<'dummy_environ
  }
 }
 
+impl TypeConvert for DummyEnvironment {
+ fn lookup_heap_type(&self, _index: TypeIndex) -> WasmHeapType {
+ unimplemented!()
+ }
+}
+
 impl TargetEnvironment for DummyEnvironment {
  fn target_config(&self) -> TargetFrontendConfig {
  self.info.config
@@ -683,7 +705,7 @@ impl<'data> ModuleEnvironment<'data> for DummyEnvironment {
  WasmType::F32 => ir::types::F32,
  WasmType::F64 => ir::types::F64,
  WasmType::V128 => ir::types::I8X16,
- WasmType::FuncRef | WasmType::ExternRef => reference_type,
+ WasmType::Ref(_) => reference_type,
  })
  };
  sig.params.extend(wasm.params().iter().map(&mut cvt));

cranelift/wasm/src/environ/spec.rs

@@ -9,8 +9,8 @@
 use crate::state::FuncTranslationState;
 use crate::{
  DataIndex, ElemIndex, FuncIndex, Global, GlobalIndex, GlobalInit, Heap, HeapData, Memory,
- MemoryIndex, SignatureIndex, Table, TableIndex, Tag, TagIndex, TypeIndex, WasmError,
- WasmFuncType, WasmResult, WasmType,
+ MemoryIndex, SignatureIndex, Table, TableIndex, Tag, TagIndex, TypeConvert, TypeIndex,
+ WasmError, WasmFuncType, WasmHeapType, WasmResult,
 };
 use core::convert::From;
 use cranelift_codegen::cursor::FuncCursor;
@@ -44,7 +44,7 @@ pub enum GlobalVariable {
 }
 
 /// Environment affecting the translation of a WebAssembly.
-pub trait TargetEnvironment {
+pub trait TargetEnvironment: TypeConvert {
  /// Get the information needed to produce Cranelift IR for the given target.
  fn target_config(&self) -> TargetFrontendConfig;
 
@@ -70,7 +70,7 @@ pub trait TargetEnvironment {
  /// 32-bit architectures. If you override this, then you should also
  /// override `FuncEnvironment::{translate_ref_null, translate_ref_is_null}`
  /// as well.
- fn reference_type(&self, ty: WasmType) -> ir::Type {
+ fn reference_type(&self, ty: WasmHeapType) -> ir::Type {
  let _ = ty;
  match self.pointer_type() {
  ir::types::I32 => ir::types::R32,
@@ -208,6 +208,22 @@ pub trait FuncEnvironment: TargetEnvironment {
  Ok(pos.ins().call(callee, call_args))
  }
 
+ /// Translate a `call_ref` WebAssembly instruction at `pos`.
+ ///
+ /// Insert instructions at `pos` for an indirect call to the
+ /// function `callee`. The `callee` value will have type `Ref`.
+ ///
+ /// The signature `sig_ref` was previously created by `make_indirect_sig()`.
+ ///
+ /// Return the call instruction whose results are the WebAssembly return values.
+ fn translate_call_ref(
+ &mut self,
+ builder: &mut FunctionBuilder,
+ sig_ref: ir::SigRef,
+ callee: ir::Value,
+ call_args: &[ir::Value],
+ ) -> WasmResult<ir::Inst>;
+
  /// Translate a `memory.grow` WebAssembly instruction.
  ///
  /// The `index` provided identifies the linear memory to grow, and `heap` is the heap reference
@@ -373,7 +389,11 @@ pub trait FuncEnvironment: TargetEnvironment {
  /// null sentinel is not a null reference type pointer for your type. If you
  /// override this method, then you should also override
  /// `translate_ref_is_null` as well.
- fn translate_ref_null(&mut self, mut pos: FuncCursor, ty: WasmType) -> WasmResult<ir::Value> {
+ fn translate_ref_null(
+ &mut self,
+ mut pos: FuncCursor,
+ ty: WasmHeapType,
+ ) -> WasmResult<ir::Value> {
  let _ = ty;
  Ok(pos.ins().null(self.reference_type(ty)))
  }
@@ -547,7 +567,7 @@ pub trait FuncEnvironment: TargetEnvironment {
 /// An object satisfying the `ModuleEnvironment` trait can be passed as argument to the
 /// [`translate_module`](fn.translate_module.html) function. These methods should not be called
 /// by the user, they are only for `cranelift-wasm` internal use.
-pub trait ModuleEnvironment<'data> {
+pub trait ModuleEnvironment<'data>: TypeConvert {
  /// Provides the number of types up front. By default this does nothing, but
  /// implementations can use this to preallocate memory if desired.
  fn reserve_types(&mut self, _num: u32) -> WasmResult<()> {