anchor.diff:  %%%   fmove Src {fr,_}		%% Move INTO floating point register.
   %%%
   
  -float_op(Ss, Dst, Vst0) ->
  +is_float_arith_bif(fadd, [_, _]) -> true;
  +is_float_arith_bif(fdiv, [_, _]) -> true;
  +is_float_arith_bif(fmul, [_, _]) -> true;
  +is_float_arith_bif(fnegate, [_]) -> true;
  +is_float_arith_bif(fsub, [_, _]) -> true;
  +is_float_arith_bif(_, _) -> false.
  +
  +validate_float_arith_bif(Ss, Dst, Vst0) ->
       _ = [assert_freg_set(S, Vst0) || S <- Ss],
       assert_fls(cleared, Vst0),
       Vst = set_fls(cleared, Vst0),
  
positive.code: call_types(_, A, Vst) ->
      {any, get_call_args(A, Vst), false}.
  
  will_bif_succeed(fadd, [_,_], _Vst) ->
      maybe;
  will_bif_succeed(fdiv, [_,_], _Vst) ->
      maybe;
  will_bif_succeed(fmul, [_,_], _Vst) ->
      maybe;
  will_bif_succeed(fnegate, [_], _Vst) ->
      maybe;
  will_bif_succeed(fsub, [_,_], _Vst) ->
      maybe;
  will_bif_succeed(Op, Ss, Vst) ->
      Args = [normalize(get_term_type(Arg, Vst)) || Arg <- Ss],
      beam_call_types:will_succeed(erlang, Op, Args).
  
  will_call_succeed({extfunc,M,F,A}, Vst) ->
      beam_call_types:will_succeed(M, F, get_call_args(A, Vst));
  
negative.code: %% have clobbered the sources.
  %%
  
  validate_bif(Kind, Op, Fail, Ss, Dst, OrigVst, Vst0) ->
      assert_float_checked(Vst0),
      case {will_bif_succeed(Op, Ss, Vst0), Fail} of
          {yes, _} ->
              %% This BIF cannot fail (neither throw nor branch), handle it here
              %% without updating catch state.
              validate_bif_1(Kind, Op, cannot_fail, Ss, Dst, OrigVst, Vst0);
          {no, 0} ->
              %% The stack will be scanned, so Y registers must be initialized.
              Vst = branch_exception(Vst0),
              verify_y_init(Vst),
              kill_state(Vst);
          {no, _} ->
              %% The next instruction is never executed, this is essentially a
              %% direct jump.
              branch(Fail, Vst0, fun(SuccVst) -> kill_state(SuccVst) end);
          {maybe, 0} ->
              %% The BIF might throw an exception, make sure that any catch state
              %% is updated.
              Vst = branch_exception(Vst0),
              validate_bif_1(Kind, Op, Fail, Ss, Dst, OrigVst, Vst);
          {maybe, _} ->
              validate_bif_1(Kind, Op, Fail, Ss, Dst, OrigVst, Vst0)
      end.
  
  validate_bif_1(Kind, Op, cannot_fail, Ss, Dst, OrigVst, Vst0) ->
      %% This BIF explicitly cannot fail; it will not jump to a guard nor throw
  