anchor.diff:  %% have clobbered the sources.
   %%
   
  -validate_bif(Op, Fail, Ss, Dst, Vst) ->
  -    validate_src(Ss, Vst),
  -    validate_bif_1(bif, Op, Fail, Ss, Dst, Vst, Vst).
  -
  -validate_gc_bif(Op, Fail, Ss, Dst, Live, #vst{current=St0}=Vst0) ->
  -    validate_src(Ss, Vst0),
  -    verify_live(Live, Vst0),
  -    verify_y_init(Vst0),
  -
  -    %% Heap allocations and X registers are killed regardless of whether we
  -    %% fail or not, as we may fail after GC.
  -    St = kill_heap_allocation(St0),
  -    Vst = prune_x_regs(Live, Vst0#vst{current=St}),
  -    validate_src(Ss, Vst),
  -
  -    validate_bif_1(gc_bif, Op, Fail, Ss, Dst, Vst, Vst).
  +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
  
positive.code:     Vs = Vs0#{ Ref => Entry#value{type=Type} },
      Vst#vst{current=St#st{vs=Vs}}.
  
  new_value(Type, Op, Ss, #vst{current=#st{vs=Vs0}=St,ref_ctr=Counter}=Vst) ->
      Ref = #value_ref{id=Counter},
      Vs = Vs0#{ Ref => #value{op=Op,args=Ss,type=Type} },
  
negative.code:     error(ambiguous_catch_try_state).
  
  %% Handle the remaining floating point instructions here.
  vi_float({fconv,Src,{fr,_}=Dst}, Vst) ->
      assert_term(Src, Vst),
  
  