anchor.diff:      [{iff,clint0,?pass(core_lint_module)},
        {delay,
         [{unless,no_copt,
  -       [{core_old_inliner,fun test_old_inliner/1,fun core_old_inliner/1},
  +       [{core_old_inliner,fun test_old_inliner/1,fun core_old_inliner/2},
   	{iff,doldinline,{listing,"oldinline"}},
   	{pass,sys_core_fold},
   	{iff,dcorefold,{listing,"corefold"}},
  -	{core_inline_module,fun test_core_inliner/1,fun core_inline_module/1},
  +	{core_inline_module,fun test_core_inliner/1,fun core_inline_module/2},
   	{iff,dinline,{listing,"inline"}},
           {core_fold_after_inlining,fun test_any_inliner/1,
  -         fun core_fold_module_after_inlining/1},
  +         fun core_fold_module_after_inlining/2},
   	?pass(core_transforms)]},
          {iff,dcopt,{listing,"copt"}},
          {iff,'to_core',{done,"core"}}]}
  
positive.code: collect_asm([X | Rest], R) ->
      collect_asm(Rest, R#asm_module{code=R#asm_module.code++[X]}).
  
  beam_consult_asm(St) ->
      case file:consult(St#compile.ifile) of
  	{ok, Forms0} ->
              Encoding = epp:read_encoding(St#compile.ifile),
  	    {Module, Forms} = preprocess_asm_forms(Forms0),
  	    {ok,St#compile{module=Module, code=Forms, encoding=Encoding}};
  	{error,E} ->
  	    Es = [{St#compile.ifile,[{none,?MODULE,{open,E}}]}],
  	    {error,St#compile{errors=St#compile.errors ++ Es}}
      end.
  
  read_beam_file(St) ->
      case file:read_file(St#compile.ifile) of
  	{ok,Beam} ->
  	    Infile = St#compile.ifile,
  	    case no_native_compilation(Infile, St) of
  		true ->
  		    {ok,St#compile{module=none,code=none}};
  		false ->
  		    Mod0 = filename:rootname(filename:basename(Infile)),
  		    Mod = list_to_atom(Mod0),
  		    {ok,St#compile{module=Mod,code=Beam,ofile=Infile}}
  	    end;
  	{error,E} ->
  	    Es = [{St#compile.ifile,[{none,?MODULE,{open,E}}]}],
  
negative.code: 	    Es = [{St0#compile.ifile,[{none,?MODULE,{bad_return,Name,Other}}]}],
  	    {error,St0#compile{errors=St0#compile.errors ++ Es}}
      end;
  fold_comp([], _Run, Code, St) -> {ok,Code,St}.
  
  run_tc({Name,Fun}, Code, St) ->
      T1 = erlang:monotonic_time(),
      Val = (catch Fun(Code, St)),
      T2 = erlang:monotonic_time(),
      Elapsed = erlang:convert_time_unit(T2 - T1, native, millisecond),
      Mem0 = erts_debug:flat_size(Val)*erlang:system_info(wordsize),
  