This should also be used for fast-math and "algebraic" float operations.

Hi, i would like to try this. I have 2 questions though. Do you mean that we should add the float_error to this part of the code?

https://github.com/rust-lang/miri/blob/95558badc942353582b742b30950412d46d69a06/src/intrinsics/mod.rs#L247C1-L263C18

And should we use the same magnitude as the x86 instrinics?

Yes, all of those there except for sqrt should apply a float error.

There's no fixed value for the magnitude of the error so we might as well pick the same as the x86 intrinsic.

@rustbot claim

Hi, I think I successfully implemented it for all but 2 match arms because I don't know how to do it nicely. It is about the f*_algebraic operations:

  | "fadd_algebraic"
  | "fsub_algebraic"
  | "fmul_algebraic"
  | "fdiv_algebraic"
  | "frem_algebraic"
  => {
      let [a, b] = check_arg_count(args)?;
      let a = this.read_immediate(a)?;
      let b = this.read_immediate(b)?;
      let op = match intrinsic_name {
          "fadd_algebraic" => mir::BinOp::Add,
          "fsub_algebraic" => mir::BinOp::Sub,
          "fmul_algebraic" => mir::BinOp::Mul,
          "fdiv_algebraic" => mir::BinOp::Div,
          "frem_algebraic" => mir::BinOp::Rem,
          _ => bug!(),
      };
      let res = this.binary_op(op, &a, &b)?;
      // `binary_op` already called `generate_nan` if necessary.
      this.write_immediate(*res, dest)?;
  }

I don't know how I can nicely implement this.
I thought about converting to a scalar int to_scalar_int() and then matching on the float type converting to that type, applying the error, and then writing the scalar. But maybe there is a better way?

And the f*_fast operation. It says this in the code:
https://github.com/rust-lang/miri/blob/c2a376121b7756c73b250bdba82f92d8a47c25a4/src/intrinsics/mod.rs#L424C1-L426C51

Should I follow the second comment from RalfJung or this comment in the code?

Also, is this the conventional way of asking for help? Or is Zullip used more? Or another way?

Thanks for the help!

I don't think I quite understand what the problem is. I would propose you open a PR that implements this for one or two (blocks of) shims, so that we can give feedback on a concrete implementation, and hopefully that will help clarify these things as well.

Regarding asking for help, Zulip is a good place for that. :)

Should I follow the second comment from RalfJung or this comment in the code?

Note that this refers to different non-determinism than what the issue is about. That comment is about making the NaN payload bits and sign non-deterministic.