anchor.diff:           branched=gb_trees:empty() :: branched_tab(),
            %% All defined labels
            labels=gb_sets:empty()    :: label_set(),
  -         %% Argument information of other functions in the module
  +         %% Information of other functions in the module
            ft=gb_trees:empty()       :: ft_tab(),
            %% Counter for #value_ref{} creation
            ref_ctr=0                 :: index()
           }).
   
  -index_parameter_types([{function,_,_,Entry,Code0}|Fs], Acc0) ->
  +build_function_table([{function,_,Arity,Entry,Code0}|Fs], Acc0) ->
       Code = dropwhile(fun({label,L}) when L =:= Entry -> false;
   			(_) -> true
   		     end, Code0),
       case Code of
   	[{label,Entry}|Is] ->
  -	    Acc = index_parameter_types_1(Is, Entry, Acc0),
  -	    index_parameter_types(Fs, Acc);
  +	    Info = #{ arity => Arity,
  +                  parameter_types => find_parameter_types(Is, #{}) },
  +	    build_function_table(Fs, [{Entry, Info} | Acc0]);
   	_ ->
   	    %% Something is seriously wrong. Ignore it for now.
   	    %% It will be detected and diagnosed later.
  -	    index_parameter_types(Fs, Acc0)
  -    end;
  -index_parameter_types([], Acc) ->
  +	    build_function_table(Fs, Acc0)
  +    end;
  +build_function_table([], Acc) ->
       gb_trees:from_orddict(sort(Acc)).
   
  -index_parameter_types_1([{'%', {type_info, Reg, Type0}} | Is], Entry, Acc) ->
  +find_parameter_types([{'%', {type_info, Reg, Type0}} | Is], Acc) ->
       Type = case Type0 of
                   match_context -> #ms{};
                   _ -> Type0
               end,
  -    Key = {Entry, Reg},
  -    index_parameter_types_1(Is, Entry, [{Key, Type} | Acc]);
  -index_parameter_types_1(_, _, Acc) ->
  +    find_parameter_types(Is, Acc#{ Reg => Type });
  +find_parameter_types(_, Acc) ->
       Acc.
   
   validate_1(Is, Name, Arity, Entry, Ft) ->
  
positive.code:     assert_durable_term({x, X}, Vst),
      verify_remote_args_1(X - 1, Vst).
  
  verify_local_args(-1, _Lbl, _CtxIds, _Vst) ->
      ok;
  verify_local_args(X, Lbl, CtxRefs, Vst) ->
      Reg = {x, X},
      assert_not_fragile(Reg, Vst),
      case get_movable_term_type(Reg, Vst) of
  
negative.code: %%  format as used in the compiler and in .S files.
  
  validate(Module, Fs) ->
      Ft = build_function_table(Fs, []),
      validate_0(Module, Fs, Ft).
  
  validate_0(_Module, [], _) -> [];
  