Lines Matching refs:Vdb
83 function({function,Name,Arity,As0,Vb,Vdb}, St0) ->
86 {Fun,St2} = cg_fun(Vb, As0, Vdb, St1),
93 cg_fun(Les, Hvs, Vdb, St0) ->
101 stk=[]}, 0, Vdb),
102 {B2,_Aft,St3} = cg_list(Les, 0, Vdb, Bef, St2#cg{btype=exit,
115 cg(Le, Vdb, Bef, St) ->
116 cg(Le#l.ke, Le, Vdb, Bef, St).
118 cg({block,Es}, Le, Vdb, Bef, St) ->
119 block_cg(Es, Le, Vdb, Bef, St);
120 cg({match,M,Rs}, Le, Vdb, Bef, St) ->
121 match_cg(M, Rs, Le, Vdb, Bef, St);
122 cg({match_fail,F}, Le, Vdb, Bef, St) ->
123 match_fail_cg(F, Le, Vdb, Bef, St);
124 cg({call,Func,As,Rs}, Le, Vdb, Bef, St) ->
125 call_cg(Func, As, Rs, Le, Vdb, Bef, St);
126 cg({enter,Func,As}, Le, Vdb, Bef, St) ->
127 enter_cg(Func, As, Le, Vdb, Bef, St);
128 cg({bif,Bif,As,Rs}, Le, Vdb, Bef, St) ->
129 bif_cg(Bif, As, Rs, Le, Vdb, Bef, St);
130 cg({receive_loop,Te,Rvar,Rm,Tes,Rs}, Le, Vdb, Bef, St) ->
131 recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St);
132 cg(receive_next, Le, Vdb, Bef, St) ->
133 recv_next_cg(Le, Vdb, Bef, St);
135 cg({'try',Ta,Vs,Tb,Evs,Th,Rs}, Le, Vdb, Bef, St) ->
136 try_cg(Ta, Vs, Tb, Evs, Th, Rs, Le, Vdb, Bef, St);
137 cg({'catch',Cb,R}, Le, Vdb, Bef, St) ->
138 catch_cg(Cb, R, Le, Vdb, Bef, St);
139 cg({set,Var,Con}, Le, Vdb, Bef, St) -> set_cg(Var, Con, Le, Vdb, Bef, St);
140 cg({return,Rs}, Le, Vdb, Bef, St) -> return_cg(Rs, Le, Vdb, Bef, St);
141 cg({break,Bs}, Le, Vdb, Bef, St) -> break_cg(Bs, Le, Vdb, Bef, St);
149 cg_list(Kes, I, Vdb, Bef, St0) ->
154 {Keis,Intb,Stb} = cg(Ke, Vdb, Inta, Sta),
212 match_cg(M, Rs, Le, Vdb, Bef, St0) ->
214 {Sis,Int0} = adjust_stack(Bef, I, I+1, Vdb),
220 clear_dead(Int1#sr{reg=Reg}, I, Vdb),
254 match_fail_cg({function_clause,As}, Le, Vdb, Bef, St) ->
256 {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
259 match_fail_cg({badmatch,Term}, Le, Vdb, Bef, St) ->
261 Int0 = clear_dead(Bef, Le#l.i, Vdb),
262 {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
265 match_fail_cg({case_clause,Reason}, Le, Vdb, Bef, St) ->
267 Int0 = clear_dead(Bef, Le#l.i, Vdb),
268 {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
271 match_fail_cg(if_clause, Le, Vdb, Bef, St) ->
272 Int0 = clear_dead(Bef, Le#l.i, Vdb),
273 {Sis,Int1} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
275 match_fail_cg({try_clause,Reason}, Le, Vdb, Bef, St) ->
277 Int0 = clear_dead(Bef, Le#l.i, Vdb),
278 {Sis,Int} = adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb),
302 cg_block(Kes0, I, Vdb, Bef, St0) ->
308 cg_basic_block(Kes1, Fb, LastI, Args, Vdb, Bef, St0);
310 cg_list(Kes1, I, Vdb, Bef, St0)
312 {Kes3,Int2,St2} = cg_block(Rest, I, Vdb, Int1, St1),
344 cg_basic_block(Kes, Fb, Lf, As, Vdb, Bef, St0) ->
347 Stk = extend_stack(Bef, Lf, Lf+1, Vdb),
349 X0_v0 = x0_vars(As, Fb, Lf, Vdb),
351 flatmapfoldl(fun(Ke, St) -> cg_basic_block(Ke, St, Lf, Vdb) end,
355 cg_basic_block(Ke, {Inta,X0v,Sta}, _Lf, Vdb) when element(1, Ke#l.ke) =:= need_heap ->
356 {Keis,Intb,Stb} = cg(Ke, Vdb, Inta, Sta),
358 cg_basic_block(Ke, {Inta,X0_v1,Sta}, Lf, Vdb) ->
359 {Sis,Intb} = save_carefully(Inta, Ke#l.i, Lf+1, Vdb),
362 {Keis,Inte,Stb} = cg(Ke, Vdb, Intd, Sta),
384 extend_stack(Bef, Fb, Lf, Vdb) ->
385 Stk0 = clear_dead_stk(Bef#sr.stk, Fb, Vdb),
386 Saves = [V || {V,F,L} <- Vdb,
393 save_carefully(Bef, Fb, Lf, Vdb) ->
396 New = [ {V,F,L} || {V,F,L} <- Vdb,
415 x0_vars([{var,V}|_], Fb, _Lf, Vdb) ->
416 {V,F,_L} = VFL = vdb_find(V, Vdb),
417 x0_vars1([VFL], Fb, F, Vdb);
418 x0_vars([X0|_], Fb, Lf, Vdb) ->
419 x0_vars1([{X0,Lf,Lf}], Fb, Lf, Vdb).
421 x0_vars1(X0, Fb, Xf, Vdb) ->
422 Vs0 = [VFL || {_V,F,L}=VFL <- Vdb,
546 select_cons(#l{ke={val_clause,{cons,Es},B},i=I,vdb=Vdb}, V, Tf, Vf, Bef, St0) ->
547 {Eis,Int,St1} = select_extract_cons(V, Es, I, Vdb, Bef, St0),
559 select_binary(#l{ke={val_clause,{binary,{var,Ivar}},B},i=I,vdb=Vdb},
561 Int0 = clear_dead(Bef, I, Vdb),
571 select_bin_seg(#l{ke={val_clause,{bin_seg,Size,U,T,Fs,Es},B},i=I,vdb=Vdb},
574 I, Vdb, Bef, St0),
579 I, Vdb, Bef, St) ->
582 case vdb_find(Hd, Vdb) of
594 {Es,clear_dead(Aft, I, Vdb),St}.
610 select_val(#l{ke={val_clause,{tuple,Es},B},i=I,vdb=Vdb}, V, Vf, Bef, St0) ->
611 {Eis,Int,St1} = select_extract_tuple(V, Es, I, Vdb, Bef, St0),
622 select_extract_tuple(Src, Vs, I, Vdb, Bef, St) ->
624 case vdb_find(V, Vdb) of
637 select_extract_cons(Src, [{var,Hd}, {var,Tl}], I, Vdb, Bef, St) ->
638 {Es,Aft} = case {vdb_find(Hd, Vdb), vdb_find(Tl, Vdb)} of
654 Int1 = clear_dead(Int0, I, Vdb),
660 guard_clause_cg(#l{ke={guard_clause,G,B},vdb=Vdb}, Fail, Bef, St0) ->
661 {Gis,Int,St1} = guard_cg(G, Fail, Vdb, Bef, St0),
677 guard_cg(#l{ke={test,Test,As},i=I,vdb=_Tdb}, Fail, Vdb, Bef, St) ->
678 test_cg(Test, As, Fail, I, Vdb, Bef, St);
679 guard_cg(G, _Fail, Vdb, Bef, St) ->
681 {Gis,Aft,St1} = cg(G, Vdb, Bef, St),
692 protected_cg(Ts, [], Fail, I, Vdb, Bef, St0) ->
694 {Tis,Aft,St1} = guard_cg_list(Ts, Fail, I, Vdb, Bef,
697 protected_cg(Ts, Rs, _Fail, I, Vdb, Bef, St0) ->
700 {Tis,Aft,St3} = guard_cg_list(Ts, Pfail, I, Vdb, Bef,
713 test_cg(Test, As, Fail, I, Vdb, Bef, St) ->
717 Int = clear_dead(Bef, I, Vdb),
719 clear_dead(Int, I, Vdb),
723 Int = clear_dead(Bef, I, Vdb),
725 clear_dead(Int, I, Vdb),
755 guard_cg_list(Kes, Fail, I, Vdb, Bef, St0) ->
759 guard_cg(Ke, Fail, Vdb, Inta, Sta),
787 call_cg({var,V}, As, Rs, Le, Vdb, Bef, St0) ->
788 {Sis,Int} = cg_setup_call(As++[{var,V}], Bef, Le#l.i, Vdb),
793 {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
796 call_cg({remote,Mod,Name}, As, Rs, Le, Vdb, Bef, St0)
799 {Sis,Int} = cg_setup_call(As++[Mod,Name], Bef, Le#l.i, Vdb),
807 {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
809 call_cg(Func, As, Rs, Le, Vdb, Bef, St0) ->
810 {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
816 {Frees,Aft} = free_dead(clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb)),
839 enter_cg({var,V}, As, Le, Vdb, Bef, St0) ->
840 {Sis,Int} = cg_setup_call(As++[{var,V}], Bef, Le#l.i, Vdb),
844 clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
846 enter_cg({remote,Mod,Name}=Func, As, Le, Vdb, Bef, St0)
849 {Sis,Int} = cg_setup_call(As++[Mod,Name], Bef, Le#l.i, Vdb),
855 clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
857 enter_cg(Func, As, Le, Vdb, Bef, St0) ->
858 {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
863 clear_dead(Int#sr{reg=clear_regs(Int#sr.reg)}, Le#l.i, Vdb),
911 bif_cg(dsetelement, [Index0,Tuple0,New0], _Rs, Le, Vdb, Bef, St0) ->
915 clear_dead(Bef, Le#l.i, Vdb), St0};
916 bif_cg({make_fun,Func,Arity,Index,Uniq}, As, Rs, Le, Vdb, Bef, St0) ->
918 {Sis,Int} = cg_setup_call(As, Bef, Le#l.i, Vdb),
927 clear_dead(Int#sr{reg=Reg}, Le#l.i, Vdb),
929 bif_cg(Bif, As, [{var,V}], Le, Vdb, Bef, St0) ->
940 true -> adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb);
944 Int1 = clear_dead(Int0, Le#l.i, Vdb),
949 clear_dead(Int, Le#l.i, Vdb), St0}.
958 recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, Vdb, Bef, St0) ->
959 {Sis,Int0} = adjust_stack(Bef, Le#l.i, Le#l.i, Vdb),
971 clear_dead(Int2#sr{reg=Reg}, Le#l.i, Vdb),
1008 recv_next_cg(Le, Vdb, Bef, St) ->
1009 {Sis,Aft} = adjust_stack(Bef, Le#l.i, Le#l.i+1, Vdb),
1015 try_cg(Ta, Vs, Tb, Evs, Th, Rs, Le, Vdb, Bef, St0) ->
1022 {Ais,Int2,St4} = cg(Ta, Vdb, Int1, St3#cg{break=B,in_catch=true}),
1025 {Bis,Baft,St6} = cg(Tb, Vdb, Int3#sr{reg=load_vars(Vs, Int3#sr.reg)}, St5),
1026 {His,Haft,St7} = cg(Th, Vdb, Int3#sr{reg=load_vars(Evs, Int3#sr.reg)}, St6),
1033 clear_dead(Aft, Le#l.i, Vdb),
1038 catch_cg(C, {var,R}, Le, Vdb, Bef, St0) ->
1049 clear_dead(Aft, Le#l.i, Vdb),
1062 set_cg([{var,R}], {cons,Es}, Le, Vdb, Bef, St) ->
1066 Int0 = clear_dead(Bef, Le#l.i, Vdb),
1070 set_cg([{var,R}], {old_binary,Segs}, Le, Vdb, Bef, St) ->
1074 Int0 = clear_dead(Bef, Le#l.i, Vdb),
1078 set_cg([{var,R}], {binary,Segs}, Le, Vdb, Bef, #cg{in_catch=InCatch}=St) ->
1086 true -> adjust_stack(Int0, Le#l.i, Le#l.i+1, Vdb);
1089 Aft = clear_dead(Int1, Le#l.i, Vdb),
1092 set_cg([{var,R}], Con, Le, Vdb, Bef, St) ->
1106 {Ais,clear_dead(Int, Le#l.i, Vdb),St};
1107 set_cg([], {binary,Segs}, Le, Vdb, Bef, St) ->
1113 Aft = clear_dead(Bef, Le#l.i, Vdb),
1115 set_cg([], {old_binary,Segs}, Le, Vdb, Bef, St) ->
1121 {Ais,clear_dead(Bef, Le#l.i, Vdb),St};
1122 set_cg([], _, Le, Vdb, Bef, St) ->
1124 {[],clear_dead(Bef, Le#l.i, Vdb), St}.
1288 return_cg(Rs, Le, Vdb, Bef, St) ->
1289 {Ms,Int} = cg_setup_call(Rs, Bef, Le#l.i, Vdb),
1293 break_cg(Bs, Le, Vdb, Bef, St) ->
1294 {Ms,Int} = cg_setup_call(Bs, Bef, Le#l.i, Vdb),
1310 cg_setup_call(As, Bef, I, Vdb) ->
1311 {Ms,Int0} = cg_call_args(As, Bef, I, Vdb),
1313 Int1 = Int0#sr{stk=clear_dead_stk(Int0#sr.stk, I, Vdb),res=[]},
1314 {Sis,Int2} = adjust_stack(Int1, I, I+1, Vdb),
1328 cg_call_args(As, Bef, I, Vdb) ->
1330 Unsaved = unsaved_registers(Regs0, Bef#sr.stk, I, I+1, Vdb),
1352 unsaved_registers(Regs, Stk, Fb, Lf, Vdb) ->
1353 [V || {V,F,L} <- Vdb,
1434 clear_dead(Sr, Until, Vdb) ->
1435 Sr#sr{reg=clear_dead_reg(Sr, Until, Vdb),
1436 stk=clear_dead_stk(Sr#sr.stk, Until, Vdb)}.
1438 clear_dead_reg(Sr, Until, Vdb) ->
1440 case vdb_find(V, Vdb) of
1449 clear_dead_stk(Stk, Until, Vdb) ->
1451 case vdb_find(V, Vdb) of
1486 adjust_stack(Bef, Fb, Lf, Vdb) ->
1488 {Stk1,Saves} = save_stack(Stk0, Fb, Lf, Vdb),
1496 save_stack(Stk0, Fb, Lf, Vdb) ->
1498 New = [ {V,F,L} || {V,F,L} <- Vdb,