mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-16 14:25:56 +00:00
Code Issues Projects Releases Wiki Activity
Files
c5a69daae35aacf16d477f902970da15806d1ec4
mercury/compiler/vn_util.m
Zoltan Somogyi d1855187e5 Implement new methods of handling failures and the end points of branched 
Estimated hours taken: 260

Implement new methods of handling failures and the end points of branched
control structures.

compiler/notes/failure.html:
	Fix an omission about the handling of resume_is_known in if-then-elses.
	(This omission lead to a bug in the implementation.)

	Optimize cuts across multi goals when curfr is known to be equal
	to maxfr.

	Clarify the wording in several places.

compiler/code_info.m:
	Completely rewrite the methods for handling failure.

	Separate the fields of code_info into three classes: those which
	do not change after initialization, those which record state that
	depends on where in the HLDS goal we are, and those which contain
	persistent data such as label and cell counters.

	Rename grab_code_info and slap_code_info as remember_position
	and reset_to_position, and add a wrapper around the remembered
	code_info to make it harder to make mistakes in its use.
	(Only the location-dependent fields of the remembered code_info
	are used, but putting only them into a separate data structure would
	result in more, not less, memory being allocated.)

	Gather the predicates that deal with handling branched control
	structures into a submodule.

	Reorder the declarations and definitions of access predicates
	to conform to the new order of fields.

	Reorder the declarations and definitions of the failure handling
	submodule to better reflect the separation of higher-level and
	lower-level predicates.

compiler/code_gen.m:
	Replace code_gen__generate_{det,semi,non}_goal_2 with a single
	predicate, since for most HLDS constructs the code here is the same
	anyway (the called preds check the code model when needed).

	Move classification of the various kinds of unifications to unify_gen,
	since that is where it belongs.

	Move responsibility for initializing the code generator's trace
	info to code_info.

	Move the generation of code for negations to ite_gen, since the
	handling of negations is a cut-down version of the handling of
	negations. This should make the required double maintenance easier,
	and more likely to happen.

compiler/disj_gen.m:
compiler/ite_gen.m:
	These are the two modules that handle most failures; they have
	undergone a significant rewrite. As part of this rewrite, factor
	out the remaining common code between model_non and model_{det,semi}
	goals.

compiler/unify_gen.m:
	Move classification of the various kinds of unifications here from
	code_gen. This allows us to keep several previously exported
	predicates private.

compiler/call_gen.m:
	Factor out some code that was common to ordinary calls, higher order
	calls and method calls. Move the common code that checks whether
	we are doing tracing to trace.m.

	Replace call_gen__generate_{det,semi,nondet}_builtin with a single
	predicate.

	Delete the commented out call_gen__generate_complicated_unify,
	since it will never be needed and in any case suffered from
	significant code rot.

compiler/llds.m:
	Change the mkframe instruction so that depending on one of its
	arguments, it can create either ordinary frames, or the cut-down
	frames used by the new failure handling algorithm (they have only
	three fixed fields: prevfr, redoip and redofr).

compiler/llds_out.m:
	Emit a #define MR_USE_REDOFR before including mercury_imp.h, to
	tell the runtime we are using the new failure handling scheme.
	This effectively changes the grade of the compiled module.

	Emit MR_stackvar and MR_framevar instead of detstackvar and framevar.
	This is a step towards cleaning up the name-space, and a step towards
	making both start numbering at 0. For the time being, the compiler
	internally still starts counting framevars at 0; the code in llds_out.m
	adds a +1 offset.

compiler/trace.m:
	Change the way trace info is initialized to fit in with the new
	requirements of code_info.m.

	Move the "are we tracing" check from the callers to the implementation
	of trace__prepare_for_call.

compiler/*.m:
	Minor changes in accordance with the major ones above.

compiler/options.m:
	Introduce a new option, allow_hijacks, which is set to "yes" by
	default. It is not used yet, but the idea is that when it is set to no,
	the code generator will not generate code that hijacks the nondet
	stack frame of another procedure invocation; instead, it will create
	a new temporary nondet stack frame. If the current procedure is
	model_non, it will have three fields: prevfr, redoip and redofr.
	If the current procedure is model_det or model_semi, it will have
	a fourth field that is set to the value of MR_sp. The idea is that
	the runtime system, which will be able to distinguish between
	ordinary frames (whose size is at least 5 words), 3-word and 4-word
	temporary frames, will now be able to use the redofr slots of
	all three kinds of frames and the fourth slot values of 4-word
	temporary frames as the addresses relative to which framevars
	and detstackvars respectively ought to be offset in stack layouts.

compiler/handle_options.m:
	Turn off allow_hijacks if the gc method is accurate.

runtime/mercury_stacks.h:
	Change the definitions for the nondet stack handling macros
	to accommodate the new nondet stack handling discipline.
	Define a new macro for creating temp nondet frames.

	Define MR_based_stackvar and MR_based_framevar (both of which start
	numbering slots at 1), and express other references, including
	MR_stackvar and MR_framevar and backward compatible definitions of
	detstackvar and framevar for hand-written C code, in terms of those
	two.

runtime/mercury_stack_trace.[ch]:
	Add a new function to print a dump of the fixed elements nondet stack,
	for debugging my changes. (The dump does not include variable values.)

runtime/mercury_trace_internal.c:
	Add a new undocumented command "D" for dumping the nondet stack
	(users should not know about this command, since the output is
	intelligible only to implementors).

	Add a new command "toggle_echo" that can cause the debugger to echo
	all commands. When the input to the debugger is redirected, this
	echo causes the output of the session to be much more readable.

runtime/mercury_wrapper.c:
	Save the address of the artificial bottom nondet stack frame,
	so that the new function in mercury_stack_trace.c can find out
	where to stop.

runtime/mercury_engine.c:
runtime/mercury_wrapper.c:
	Put MR_STACK_TRACE_THIS_MODULE at the tops of these modules, so that
	the labels they define (e.g. do_fail and global_success) are registered
	in the label table when their module initialization functions are
	called. This is necessary for a meaningful nondet stack dump.

runtime/mercury_grade.h:
	Add a new component to the grade string that specifies whether
	the code was compiled with the old or the new method of handling
	the nondet stack. This is important, because modules compiled
	with different nondet stack handling disciplines are not compatible.
	This component depends on whether MR_USE_REDOFR is defined or not.

runtime/mercury_imp.h:
	If MR_DISABLE_REDOFR is defined, undefine off MR_USE_REDOFR before
	including mercury_grade.h. This is to allow people to continue
	working on un-updated workspaces after this change is installed;
	they should put "EXTRA_CFLAGS = -DMR_DISABLE_REDOFR" into
	Mmake.stage.params. (This way their stage1 will use the new method
	of handling failure, while their stage2 2&3 will use the old one.)

	This change should be undone once all our workspaces have switched
	over to the new failure handling method.

tests/hard_coded/cut_test.{m,exp}:
	A new test case to tickle the various ways of handling cuts in the
	new code generator.

tests/hard_coded/Mmakefile:
	Enable the new test case.
1998-07-20 10:04:02 +00:00

1380 lines
39 KiB
Mathematica
Raw Blame History

%-----------------------------------------------------------------------------%
% Copyright (C) 1995-1998 The University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%-----------------------------------------------------------------------------%
% vn_util.m - utility predicates for value numbering.
% Main author: zs.
%-----------------------------------------------------------------------------%
:- module vn_util.
:- interface.
:- import_module list, bool, std_util.
:- import_module llds, vn_type, vn_table.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
% Submodule for the forward phase of vn_block__handle_instr
:- interface.
:- pred vn_util__find_specials(vnlval, list(vnlval)).
:- mode vn_util__find_specials(in, out) is det.
:- pred vn_util__convert_to_vnlval_and_insert(list(lval), vnlvalset, vnlvalset).
% :- mode vn_util__convert_to_vnlval_and_insert(in, di, uo) is det.
:- mode vn_util__convert_to_vnlval_and_insert(in, in, out) is det.
:- implementation.
:- import_module int, float, string, set, map, require.
:- import_module opt_util.
vn_util__find_specials(vn_reg(_, _), []).
vn_util__find_specials(vn_temp(_, _), []).
vn_util__find_specials(vn_stackvar(_), []).
vn_util__find_specials(vn_framevar(_), []).
vn_util__find_specials(vn_succip, [vn_succip]).
vn_util__find_specials(vn_maxfr, [vn_maxfr]).
vn_util__find_specials(vn_curfr, [vn_curfr]).
vn_util__find_specials(vn_prevfr(Vn), [vn_prevfr(Vn)]).
vn_util__find_specials(vn_redoip(Vn), [vn_redoip(Vn)]).
vn_util__find_specials(vn_redofr(Vn), [vn_redofr(Vn)]).
vn_util__find_specials(vn_succip(Vn), [vn_succip(Vn)]).
vn_util__find_specials(vn_succfr(Vn), [vn_succfr(Vn)]).
vn_util__find_specials(vn_hp, [vn_hp]).
vn_util__find_specials(vn_sp, [vn_sp]).
vn_util__find_specials(vn_field(_, _, _), []).
vn_util__find_specials(vn_mem_ref(_), []).
vn_util__convert_to_vnlval_and_insert([], Liveset, Liveset).
vn_util__convert_to_vnlval_and_insert([Lval | Lvals], Liveset0, Liveset) :-
vn_util__no_access_lval_to_vnlval(Lval, MaybeVnlval),
(
MaybeVnlval = yes(Vnlval),
set__insert(Liveset0, Vnlval, Liveset1)
;
MaybeVnlval = no,
Liveset1 = Liveset0
),
vn_util__convert_to_vnlval_and_insert(Lvals, Liveset1, Liveset).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- interface.
% Convert an rval into a vnrval and hence into a vn.
:- pred vn_util__rval_to_vn(rval, vn, vn_tables, vn_tables).
% :- mode vn_util__rval_to_vn(in, out, di, uo) is det.
:- mode vn_util__rval_to_vn(in, out, in, out) is det.
:- pred vn_util__lval_to_vn(lval, vn, vn_tables, vn_tables).
% :- mode vn_util__lval_to_vn(in, out, di, uo) is det.
:- mode vn_util__lval_to_vn(in, out, in, out) is det.
:- pred vn_util__lval_to_vnlval(lval, vnlval, vn_tables, vn_tables).
% :- mode vn_util__lval_to_vnlval(in, out, di, uo) is det.
:- mode vn_util__lval_to_vnlval(in, out, in, out) is det.
:- pred vn_util__is_const_expr(vn, bool, vn_tables).
:- mode vn_util__is_const_expr(in, out, in) is det.
% Find out what vns, if any, are needed to access a vnlval.
:- pred vn_util__vnlval_access_vns(vnlval, list(vn)).
:- mode vn_util__vnlval_access_vns(in, out) is det.
% Turn an vnlval into an lval if possible.
:- pred vn_util__no_access_vnlval_to_lval(vnlval, maybe(lval)).
:- mode vn_util__no_access_vnlval_to_lval(in, out) is det.
% Do the reverse.
:- pred vn_util__no_access_lval_to_vnlval(lval, maybe(vnlval)).
:- mode vn_util__no_access_lval_to_vnlval(in, out) is det.
:- pred vn_util__find_sub_vns(vnrval, list(vn)).
:- mode vn_util__find_sub_vns(in, out) is det.
% Find all lvals inside a given rval.
:- pred vn_util__find_lvals_in_rval(rval, list(lval)).
:- mode vn_util__find_lvals_in_rval(in, out) is det.
:- pred vn_util__find_lvals_in_rvals(list(rval), list(lval)).
:- mode vn_util__find_lvals_in_rvals(in, out) is det.
% Find out whether a vn is needed in two or more assignments.
:- pred vn_util__is_vn_shared(vn, vnrval, list(vn_src), vn_tables).
:- mode vn_util__is_vn_shared(in, in, in, in) is semidet.
% Find out which uses of a vn actually require an assignment.
:- pred vn_util__real_uses(list(vn_src), list(vn_src), vn_tables).
% :- mode vn_util__real_uses(di, uo, in) is semidet.
:- mode vn_util__real_uses(in, out, in) is semidet.
% Choose the cheapest location from a given list of locations.
% Access time is the only consideration. There are three cost levels:
% registers and temporaries; stackvars and framevars; fields.
% Fail only if the input list is empty.
:- pred vn_util__choose_cheapest_loc(list(vnlval), vnlval).
:- mode vn_util__choose_cheapest_loc(in, out) is semidet.
:- pred vn_util__classify_loc_cost(vnlval, int).
:- mode vn_util__classify_loc_cost(in, out) is det.
:- implementation.
%-----------------------------------------------------------------------------%
vn_util__rval_to_vn(Rval, Vn, VnTables0, VnTables) :-
(
Rval = lval(Lval),
vn_util__lval_to_vn(Lval, Vn, VnTables0, VnTables)
;
Rval = var(_),
error("value_number should never get rval: var")
;
Rval = create(Tag, Args, Unique, Label, Msg),
vn_util__vnrval_to_vn(vn_create(Tag, Args, Unique, Label, Msg),
Vn, VnTables0, VnTables)
;
Rval = mkword(Tag, Rval1),
vn_util__rval_to_vn(Rval1, SubVn, VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_mkword(Tag, SubVn), Vn,
VnTables1, VnTables)
;
Rval = const(Const),
vn_util__vnrval_to_vn(vn_const(Const), Vn,
VnTables0, VnTables)
;
Rval = unop(Unop, Rval1),
vn_util__rval_to_vn(Rval1, SubVn, VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_unop(Unop, SubVn), Vn,
VnTables1, VnTables)
;
Rval = binop(Binop, Rval1, Rval2),
vn_util__rval_to_vn(Rval1, SubVn1, VnTables0, VnTables1),
vn_util__rval_to_vn(Rval2, SubVn2, VnTables1, VnTables2),
vn_util__vnrval_to_vn(vn_binop(Binop, SubVn1, SubVn2), Vn,
VnTables2, VnTables)
;
Rval = mem_addr(MemRef),
vn_util__mem_ref_to_vn(MemRef, Vn, VnTables0, VnTables)
).
:- pred vn_util__mem_ref_to_vn(mem_ref, vn, vn_tables, vn_tables).
% :- mode vn_util__mem_ref_to_vn(in, out, di, uo) is det.
:- mode vn_util__mem_ref_to_vn(in, out, in, out) is det.
vn_util__mem_ref_to_vn(MemRef, Vn, VnTables0, VnTables) :-
(
MemRef = stackvar_ref(Slot),
vn_util__vnrval_to_vn(vn_stackvar_addr(Slot), Vn,
VnTables0, VnTables)
;
MemRef = framevar_ref(Slot),
vn_util__vnrval_to_vn(vn_framevar_addr(Slot), Vn,
VnTables0, VnTables)
;
MemRef = heap_ref(Rval, Tag, Field),
vn_util__rval_to_vn(Rval, SubVn, VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_heap_addr(SubVn, Tag, Field), Vn,
VnTables1, VnTables)
).
:- pred vn_util__vnrval_to_vn(vnrval, vn, vn_tables, vn_tables).
% :- mode vn_util__vnrval_to_vn(in, out, di, uo) is det.
:- mode vn_util__vnrval_to_vn(in, out, in, out) is det.
vn_util__vnrval_to_vn(Vnrval, Vn, VnTables0, VnTables) :-
vn_util__simplify_vnrval(Vnrval, Vnrval1, VnTables0, VnTables1),
( vn_table__search_assigned_vn(Vnrval1, Vn_prime, VnTables1) ->
( vn_util__vnrval_may_share_vn(Vnrval1) ->
Vn = Vn_prime,
VnTables = VnTables1
;
vn_table__record_new_vnrval(Vnrval1, Vn,
VnTables1, VnTables)
)
;
vn_table__record_first_vnrval(Vnrval1, Vn, VnTables1, VnTables)
).
:- pred vn_util__vnrval_may_share_vn(vnrval).
:- mode vn_util__vnrval_may_share_vn(in) is semidet.
vn_util__vnrval_may_share_vn(Vnrval) :-
(
Vnrval = vn_unop(cast_to_unsigned, _)
->
fail
;
true
).
% Simplify the vnrval by partially evaluating expressions involving
% constants. To make this simpler, swap the arguments of commutative
% expressions around to put the constants on the right side.
% For the time being we assume ideal integers and reals.
% Eventually, we will have to introduce a mechanism to allow
% programmers to prescribe orders of evaluation.
% We also assume that the compiler's arithmetic is at least as
% accurate as the target machine's arithmetic.
% The simplification has to be done on vnrvals and not on rvals
% even though this complicates the code. The reason is that an
% expression such as r1 + 4 can be simplified if we know that
% r1 was defined as r2 + 8.
% XXX more simplification opportunities exist
:- pred vn_util__simplify_vnrval(vnrval, vnrval, vn_tables, vn_tables).
% :- mode vn_util__simplify_vnrval(in, out, di, uo) is det.
:- mode vn_util__simplify_vnrval(in, out, in, out) is det.
vn_util__simplify_vnrval(Vnrval0, Vnrval, VnTables0, VnTables) :-
(
Vnrval0 = vn_binop(Binop, Vn1, Vn2),
vn_util__simplify_vnrval_binop(Binop, Vn1, Vn2, VnrvalPrime,
VnTables0, VnTablesPrime)
->
Vnrval = VnrvalPrime,
VnTables = VnTablesPrime
;
Vnrval = Vnrval0,
VnTables = VnTables0
).
:- pred vn_util__simplify_vnrval_binop(binary_op, vn, vn, vnrval,
vn_tables, vn_tables).
% :- mode vn_util__simplify_vnrval_binop(in, in, in, out, di, uo) is semidet.
:- mode vn_util__simplify_vnrval_binop(in, in, in, out, in, out) is semidet.
vn_util__simplify_vnrval_binop(Binop, Vn1, Vn2, Vnrval, VnTables0, VnTables) :-
vn_table__lookup_defn(Vn1, Vnrval1,
"vn_util__simplify_vnrval_binop", VnTables0),
vn_table__lookup_defn(Vn2, Vnrval2,
"vn_util__simplify_vnrval_binop", VnTables0),
(
Binop = (+),
(
% c1+c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2))
->
I is I1 + I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% c1+e21+c22 => e21+c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_binop((+), Vn21, Vn22),
vn_table__lookup_defn(Vn22, Vnrval22,
"vn_util__simplify_vnrval", VnTables0),
Vnrval22 = vn_const(int_const(I22))
->
I is I1 + I22,
vn_util__vnrval_to_vn(vn_const(int_const(I)), VnConst,
VnTables0, VnTables),
Vnrval = vn_binop((+), Vn21, VnConst)
;
% c1+e2 => e2+c1
Vnrval1 = vn_const(int_const(_I1)),
Vnrval2 = vn_binop((+), _Vn21, _Vn22)
->
Vnrval = vn_binop((+), Vn2, Vn1),
VnTables = VnTables0
;
% e11+c12+c2 => e11+c
Vnrval1 = vn_binop((+), Vn11, Vn12),
vn_table__lookup_defn(Vn12, Vnrval12,
"vn_util__simplify_vnrval", VnTables0),
Vnrval12 = vn_const(int_const(I12)),
Vnrval2 = vn_const(int_const(I2))
->
I is I12 + I2,
vn_util__vnrval_to_vn(vn_const(int_const(I)),
VnConst, VnTables0, VnTables),
Vnrval = vn_binop((+), Vn11, VnConst)
;
% e11+c12+e21+c22 => e11+e21+c
Vnrval1 = vn_binop((+), Vn11, Vn12),
vn_table__lookup_defn(Vn12, Vnrval12,
"vn_util__simplify_vnrval", VnTables0),
Vnrval12 = vn_const(int_const(I12)),
Vnrval2 = vn_binop((+), Vn21, Vn22),
vn_table__lookup_defn(Vn22, Vnrval22,
"vn_util__simplify_vnrval", VnTables0),
Vnrval22 = vn_const(int_const(I22))
->
I is I12 + I22,
vn_util__vnrval_to_vn(vn_binop((+), Vn11, Vn21), VnExpr,
VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_const(int_const(I)),
VnConst, VnTables1, VnTables),
Vnrval = vn_binop((+), VnExpr, VnConst)
;
% e11+c12+e2 => e11+e2+c12
Vnrval1 = vn_binop((+), Vn11, Vn12),
vn_table__lookup_defn(Vn12, Vnrval12,
"vn_util__simplify_vnrval", VnTables0),
Vnrval12 = vn_const(int_const(_I12)),
Vnrval2 = vn_binop((+), _Vn21, _Vn22)
->
vn_util__vnrval_to_vn(vn_binop((+), Vn11, Vn2), VnExpr,
VnTables0, VnTables),
Vnrval = vn_binop((+), VnExpr, Vn12)
;
% e+0 => e
Vnrval2 = vn_const(int_const(0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (float_plus),
(
% c1+c2 => c
Vnrval1 = vn_const(float_const(F1)),
Vnrval2 = vn_const(float_const(F2))
->
F is F1 + F2,
Vnrval = vn_const(float_const(F)),
VnTables = VnTables0
;
% c1+e21+c22 => e21+c
Vnrval1 = vn_const(float_const(F1)),
Vnrval2 = vn_binop((float_plus), Vn21, Vn22),
vn_table__lookup_defn(Vn22, Vnrval22,
"vn_util__simplify_vnrval", VnTables0),
Vnrval22 = vn_const(float_const(F22))
->
F is F1 + F22,
vn_util__vnrval_to_vn(vn_const(float_const(F)), VnConst,
VnTables0, VnTables),
Vnrval = vn_binop((float_plus), Vn21, VnConst)
;
% c1+e2 => e2+c1
Vnrval1 = vn_const(float_const(_F1)),
Vnrval2 = vn_binop((float_plus), _Vn21, _Vn22)
->
Vnrval = vn_binop((float_plus), Vn2, Vn1),
VnTables = VnTables0
;
% e11+c12+c2 => e11+c
Vnrval1 = vn_binop((float_plus), Vn11, Vn12),
vn_table__lookup_defn(Vn12, Vnrval12,
"vn_util__simplify_vnrval", VnTables0),
Vnrval12 = vn_const(float_const(F12)),
Vnrval2 = vn_const(float_const(F2))
->
F is F12 + F2,
vn_util__vnrval_to_vn(vn_const(float_const(F)),
VnConst, VnTables0, VnTables),
Vnrval = vn_binop((float_plus), Vn11, VnConst)
;
% e11+c12+e21+c22 => e11+e21+c
Vnrval1 = vn_binop((float_plus), Vn11, Vn12),
vn_table__lookup_defn(Vn12, Vnrval12,
"vn_util__simplify_vnrval", VnTables0),
Vnrval12 = vn_const(float_const(F12)),
Vnrval2 = vn_binop((float_plus), Vn21, Vn22),
vn_table__lookup_defn(Vn22, Vnrval22,
"vn_util__simplify_vnrval", VnTables0),
Vnrval22 = vn_const(float_const(F22))
->
F is F12 + F22,
vn_util__vnrval_to_vn(vn_binop((float_plus), Vn11,
Vn21), VnExpr, VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_const(float_const(F)),
VnConst, VnTables1, VnTables),
Vnrval = vn_binop((float_plus), VnExpr, VnConst)
;
% e11+c12+e2 => e11+e2+c12
Vnrval1 = vn_binop((float_plus), Vn11, Vn12),
vn_table__lookup_defn(Vn12, Vnrval12,
"vn_util__simplify_vnrval", VnTables0),
Vnrval12 = vn_const(float_const(_F12)),
Vnrval2 = vn_binop((float_plus), _Vn21, _Vn22)
->
vn_util__vnrval_to_vn(vn_binop((float_plus), Vn11,
Vn2), VnExpr, VnTables0, VnTables),
Vnrval = vn_binop((float_plus), VnExpr, Vn12)
;
% e+0 => e
Vnrval2 = vn_const(float_const(0.0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (-),
(
% e1-c2 => e1+c
Vnrval2 = vn_const(int_const(I2))
->
NI2 is 0 - I2,
vn_util__vnrval_to_vn(vn_const(int_const(NI2)), VnConst,
VnTables0, VnTables1),
vn_util__simplify_vnrval(vn_binop((+), Vn1, VnConst),
Vnrval, VnTables1, VnTables)
;
% c1-e2 => 0-e2+c1
Vnrval1 = vn_const(int_const(I1)),
I1 \= 0
->
vn_util__vnrval_to_vn(vn_const(int_const(0)), VnConst0,
VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_binop((-), VnConst0, Vn2),
VnExpr, VnTables1, VnTables2),
vn_util__simplify_vnrval(vn_binop((+), VnExpr, Vn1),
Vnrval, VnTables2, VnTables)
;
% e1-e1 => 0
Vn1 = Vn2
->
Vnrval = vn_const(int_const(0)),
VnTables = VnTables0
;
% e-0 => e
Vnrval2 = vn_const(int_const(0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (float_minus),
(
% e1-c2 => e1+c
Vnrval2 = vn_const(float_const(F2))
->
NF2 is 0.0 - F2,
vn_util__vnrval_to_vn(vn_const(float_const(NF2)),
VnConst, VnTables0, VnTables1),
vn_util__simplify_vnrval(vn_binop((float_plus), Vn1,
VnConst), Vnrval, VnTables1, VnTables)
;
% c1-e2 => 0-e2+c1
Vnrval1 = vn_const(float_const(F1)),
F1 \= 0.0
->
vn_util__vnrval_to_vn(vn_const(float_const(0.0)),
VnConst0, VnTables0, VnTables1),
vn_util__vnrval_to_vn(vn_binop((float_minus), VnConst0,
Vn2), VnExpr, VnTables1, VnTables2),
vn_util__simplify_vnrval(vn_binop((float_plus), VnExpr,
Vn1), Vnrval, VnTables2, VnTables)
;
% e1-e1 => 0
Vn1 = Vn2
->
Vnrval = vn_const(int_const(0)),
VnTables = VnTables0
;
% e-0 => e
Vnrval2 = vn_const(float_const(0.0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (*),
(
% c1*c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2))
->
I is I1 * I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% e*1 => e
Vnrval2 = vn_const(int_const(1))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
% 1*e => e
Vnrval1 = vn_const(int_const(1))
->
Vnrval = Vnrval2,
VnTables = VnTables0
;
fail
)
;
Binop = (float_times),
(
% c1*c2 => c
Vnrval1 = vn_const(float_const(F1)),
Vnrval2 = vn_const(float_const(F2))
->
F is F1 * F2,
Vnrval = vn_const(float_const(F)),
VnTables = VnTables0
;
% e*1 => e
Vnrval2 = vn_const(float_const(1.0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
% 1*e => e
Vnrval1 = vn_const(float_const(1.0))
->
Vnrval = Vnrval2,
VnTables = VnTables0
;
fail
)
;
Binop = (/),
(
% c1/c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2)),
I2 \= 0
->
I is I1 // I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% e/1 => e
Vnrval2 = vn_const(int_const(1))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (float_divide),
(
% c1/c2 => c
Vnrval1 = vn_const(float_const(F1)),
Vnrval2 = vn_const(float_const(F2)),
F2 \= 0.0
->
F is F1 / F2,
Vnrval = vn_const(float_const(F)),
VnTables = VnTables0
;
% e/1 => e
Vnrval2 = vn_const(float_const(1.0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = ('|'),
(
% c1\/c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2))
->
I is I1 \/ I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% e\/0 => e
Vnrval2 = vn_const(int_const(0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
% 0\/e => e
Vnrval1 = vn_const(int_const(0))
->
Vnrval = Vnrval2,
VnTables = VnTables0
;
% e\/e => e
Vn1 = Vn2
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (&),
(
% c1/\c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2))
->
I is I1 /\ I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% e/\0 => 0
Vnrval2 = vn_const(int_const(0))
->
Vnrval = vn_const(int_const(0)),
VnTables = VnTables0
;
% 0/\e => 0
Vnrval1 = vn_const(int_const(0))
->
Vnrval = vn_const(int_const(0)),
VnTables = VnTables0
;
% e/\e => e
Vn1 = Vn2
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (>>),
(
% c1>>c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2))
->
I is I1 >> I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% e>>0 => e
Vnrval2 = vn_const(int_const(0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = (<<),
(
% c1<<c2 => c
Vnrval1 = vn_const(int_const(I1)),
Vnrval2 = vn_const(int_const(I2))
->
I is I1 << I2,
Vnrval = vn_const(int_const(I)),
VnTables = VnTables0
;
% e<<0 => e
Vnrval2 = vn_const(int_const(0))
->
Vnrval = Vnrval1,
VnTables = VnTables0
;
fail
)
;
Binop = eq,
(
% e==e => true
Vn1 = Vn2
->
Vnrval = vn_const(true),
VnTables = VnTables0
;
% otherwise, c1==c2 => false
% (true case handled above)
Vnrval1 = vn_const(_C1),
Vnrval2 = vn_const(_C2)
->
Vnrval = vn_const(false),
VnTables = VnTables0
;
% tag(mktag(e))==e => true
Vnrval1 = vn_unop(tag, WordVn),
Vnrval2 = vn_unop(mktag, Tag),
vn_table__lookup_defn(WordVn, WordVnrval,
"vn_util__simplify_vnrval_binop", VnTables0),
WordVnrval = vn_mkword(Tag, _)
->
Vnrval = vn_const(true),
VnTables = VnTables0
;
fail
)
;
Binop = ne,
(
% e!=e => false
Vn1 = Vn2
->
Vnrval = vn_const(false),
VnTables = VnTables0
;
% otherwise, c1!=c2 => true
% (false case handled above)
Vnrval1 = vn_const(_C1),
Vnrval2 = vn_const(_C2)
->
Vnrval = vn_const(true),
VnTables = VnTables0
;
% tag(mktag(e))!=e => false
Vnrval1 = vn_unop(tag, WordVn),
Vnrval2 = vn_unop(mktag, Tag),
vn_table__lookup_defn(WordVn, WordVnrval,
"vn_util__simplify_vnrval_binop", VnTables0),
WordVnrval = vn_mkword(Tag, _)
->
Vnrval = vn_const(false),
VnTables = VnTables0
;
fail
)
;
Binop = (>=),
vn_util__simplify_int_compare_op(>=, Vn1, Vnrval1, Vn2, Vnrval2,
true, Vnrval),
VnTables = VnTables0
;
Binop = (<=),
vn_util__simplify_int_compare_op(=<, Vn1, Vnrval1, Vn2, Vnrval2,
true, Vnrval),
VnTables = VnTables0
;
Binop = (>),
vn_util__simplify_int_compare_op(>, Vn1, Vnrval1, Vn2, Vnrval2,
false, Vnrval),
VnTables = VnTables0
;
Binop = (<),
vn_util__simplify_int_compare_op(<, Vn1, Vnrval1, Vn2, Vnrval2,
false, Vnrval),
VnTables = VnTables0
;
Binop = (float_eq),
vn_util__simplify_float_compare_op(float_eq, Vn1, Vnrval1,
Vn2, Vnrval2, true, Vnrval),
VnTables = VnTables0
;
Binop = (float_ge),
vn_util__simplify_float_compare_op(>=, Vn1, Vnrval1,
Vn2, Vnrval2, true, Vnrval),
VnTables = VnTables0
;
Binop = (float_le),
vn_util__simplify_float_compare_op(=<, Vn1, Vnrval1,
Vn2, Vnrval2, true, Vnrval),
VnTables = VnTables0
;
Binop = (float_ne),
vn_util__simplify_float_compare_op(float_ne, Vn1, Vnrval1,
Vn2, Vnrval2, false, Vnrval),
VnTables = VnTables0
;
Binop = (float_gt),
vn_util__simplify_float_compare_op(>=, Vn1, Vnrval1,
Vn2, Vnrval2, false, Vnrval),
VnTables = VnTables0
;
Binop = (float_lt),
vn_util__simplify_float_compare_op(=<, Vn1, Vnrval1,
Vn2, Vnrval2, false, Vnrval),
VnTables = VnTables0
;
Binop = (str_eq),
vn_util__const_if_equal_vns(Vn1, Vn2, true, Vnrval),
VnTables = VnTables0
;
Binop = (str_ge),
vn_util__const_if_equal_vns(Vn1, Vn2, true, Vnrval),
VnTables = VnTables0
;
Binop = (str_le),
vn_util__const_if_equal_vns(Vn1, Vn2, true, Vnrval),
VnTables = VnTables0
;
Binop = (str_ne),
vn_util__const_if_equal_vns(Vn1, Vn2, false, Vnrval),
VnTables = VnTables0
;
Binop = (str_gt),
vn_util__const_if_equal_vns(Vn1, Vn2, false, Vnrval),
VnTables = VnTables0
;
Binop = (str_lt),
vn_util__const_if_equal_vns(Vn1, Vn2, false, Vnrval),
VnTables = VnTables0
;
Binop = (and),
( Vnrval1 = vn_const(true) ->
Vnrval = Vnrval2,
VnTables = VnTables0
; Vnrval2 = vn_const(true) ->
Vnrval = Vnrval1,
VnTables = VnTables0
; Vnrval1 = vn_const(false) ->
Vnrval = Vnrval1,
VnTables = VnTables0
; Vnrval2 = vn_const(false) ->
Vnrval = Vnrval2,
VnTables = VnTables0
;
fail
)
;
Binop = (or),
( Vnrval1 = vn_const(false) ->
Vnrval = Vnrval2,
VnTables = VnTables0
; Vnrval2 = vn_const(false) ->
Vnrval = Vnrval1,
VnTables = VnTables0
; Vnrval1 = vn_const(true) ->
Vnrval = Vnrval1,
VnTables = VnTables0
; Vnrval2 = vn_const(true) ->
Vnrval = Vnrval2,
VnTables = VnTables0
;
fail
)
).
:- pred vn_util__simplify_int_compare_op(pred(int, int),
vn, vnrval, vn, vnrval, rval_const, vnrval).
:- mode vn_util__simplify_int_compare_op(pred(in, in) is semidet,
in, in, in, in, in, out) is semidet.
vn_util__simplify_int_compare_op(ComparePred, Vn1, Vnrval1, Vn2, Vnrval2,
ResultIfEqual, Vnrval) :-
(
Vnrval1 = vn_const(int_const(C1)),
Vnrval2 = vn_const(int_const(C2))
->
(
call(ComparePred, C1, C2)
->
Vnrval = vn_const(true)
;
Vnrval = vn_const(false)
)
;
vn_util__const_if_equal_vns(Vn1, Vn2, ResultIfEqual, Vnrval)
).
:- pred vn_util__simplify_float_compare_op(pred(float, float),
vn, vnrval, vn, vnrval, rval_const, vnrval).
:- mode vn_util__simplify_float_compare_op(pred(in, in) is semidet,
in, in, in, in, in, out) is semidet.
vn_util__simplify_float_compare_op(ComparePred, Vn1, Vnrval1, Vn2, Vnrval2,
ResultIfEqual, Vnrval) :-
(
Vnrval1 = vn_const(float_const(C1)),
Vnrval2 = vn_const(float_const(C2))
->
(
call(ComparePred, C1, C2)
->
Vnrval = vn_const(true)
;
Vnrval = vn_const(false)
)
;
vn_util__const_if_equal_vns(Vn1, Vn2, ResultIfEqual, Vnrval)
).
:- pred float_eq(float::in, float::in) is semidet.
float_eq(X, X).
:- pred float_ne(float::in, float::in) is semidet.
float_ne(X, Y) :- X \= Y.
:- pred vn_util__const_if_equal_vns(vn, vn, rval_const, vnrval).
:- mode vn_util__const_if_equal_vns(in, in, in, out) is semidet.
vn_util__const_if_equal_vns(Vn1, Vn2, Const, Vnrval) :-
( Vn1 = Vn2 ->
Vnrval = vn_const(Const)
;
fail
).
vn_util__lval_to_vn(Lval, Vn, VnTables0, VnTables) :-
vn_util__lval_to_vnlval(Lval, Vnlval, VnTables0, VnTables1),
( vn_table__search_desired_value(Vnlval, Vn_prime, VnTables1) ->
Vn = Vn_prime,
VnTables = VnTables1
;
vn_table__record_first_vnlval(Vnlval, Vn, VnTables1, VnTables)
).
vn_util__lval_to_vnlval(Lval, Vnlval, VnTables0, VnTables) :-
vn_util__no_access_lval_to_vnlval(Lval, MaybeVnlval),
( MaybeVnlval = yes(VnlvalPrime) ->
Vnlval = VnlvalPrime,
VnTables = VnTables0
; Lval = field(Tag, Rval1, Rval2) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables1),
vn_util__rval_to_vn(Rval2, Vn2, VnTables1, VnTables),
Vnlval = vn_field(Tag, Vn1, Vn2)
; Lval = mem_ref(Rval1) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables),
Vnlval = vn_mem_ref(Vn1)
; Lval = prevfr(Rval1) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables),
Vnlval = vn_prevfr(Vn1)
; Lval = redoip(Rval1) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables),
Vnlval = vn_redoip(Vn1)
; Lval = redofr(Rval1) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables),
Vnlval = vn_redofr(Vn1)
; Lval = succip(Rval1) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables),
Vnlval = vn_succip(Vn1)
; Lval = succfr(Rval1) ->
vn_util__rval_to_vn(Rval1, Vn1, VnTables0, VnTables),
Vnlval = vn_succfr(Vn1)
;
error("unexpected lval in vn_util__lval_to_vnlval")
).
% If you to add to this list to fix a determinism error,
% check vn_util__lval_to_vnlval above as well.
% vn_util__lval_to_vnlval should have code to handle every lval
% that is mapped to "no" by vn_util__no_access_lval_to_vnlval.
vn_util__no_access_lval_to_vnlval(reg(T, N), yes(vn_reg(T, N))).
vn_util__no_access_lval_to_vnlval(temp(T, N), yes(vn_temp(T, N))).
vn_util__no_access_lval_to_vnlval(stackvar(N), yes(vn_stackvar(N))).
vn_util__no_access_lval_to_vnlval(framevar(N), yes(vn_framevar(N))).
vn_util__no_access_lval_to_vnlval(succip, yes(vn_succip)).
vn_util__no_access_lval_to_vnlval(maxfr, yes(vn_maxfr)).
vn_util__no_access_lval_to_vnlval(curfr, yes(vn_curfr)).
vn_util__no_access_lval_to_vnlval(prevfr(_), no).
vn_util__no_access_lval_to_vnlval(redoip(_), no).
vn_util__no_access_lval_to_vnlval(redofr(_), no).
vn_util__no_access_lval_to_vnlval(succip(_), no).
vn_util__no_access_lval_to_vnlval(succfr(_), no).
vn_util__no_access_lval_to_vnlval(hp, yes(vn_hp)).
vn_util__no_access_lval_to_vnlval(sp, yes(vn_sp)).
vn_util__no_access_lval_to_vnlval(mem_ref(_), no).
vn_util__no_access_lval_to_vnlval(field(_, _, _), no).
vn_util__no_access_lval_to_vnlval(lvar(_Var), _) :-
error("lvar detected in value_number").
vn_util__no_access_vnlval_to_lval(vn_reg(T, N), yes(reg(T, N))).
vn_util__no_access_vnlval_to_lval(vn_temp(T, N), yes(temp(T, N))).
vn_util__no_access_vnlval_to_lval(vn_stackvar(N), yes(stackvar(N))).
vn_util__no_access_vnlval_to_lval(vn_framevar(N), yes(framevar(N))).
vn_util__no_access_vnlval_to_lval(vn_succip, yes(succip)).
vn_util__no_access_vnlval_to_lval(vn_maxfr, yes(maxfr)).
vn_util__no_access_vnlval_to_lval(vn_curfr, yes(curfr)).
vn_util__no_access_vnlval_to_lval(vn_redofr(_), no).
vn_util__no_access_vnlval_to_lval(vn_redoip(_), no).
vn_util__no_access_vnlval_to_lval(vn_prevfr(_), no).
vn_util__no_access_vnlval_to_lval(vn_succip(_), no).
vn_util__no_access_vnlval_to_lval(vn_succfr(_), no).
vn_util__no_access_vnlval_to_lval(vn_hp, yes(hp)).
vn_util__no_access_vnlval_to_lval(vn_sp, yes(sp)).
vn_util__no_access_vnlval_to_lval(vn_field(_, _, _), no).
vn_util__no_access_vnlval_to_lval(vn_mem_ref(_), no).
/* one of these preds should be eliminated XXX */
vn_util__vnlval_access_vns(vn_reg(_, _), []).
vn_util__vnlval_access_vns(vn_temp(_, _), []).
vn_util__vnlval_access_vns(vn_stackvar(_), []).
vn_util__vnlval_access_vns(vn_framevar(_), []).
vn_util__vnlval_access_vns(vn_succip, []).
vn_util__vnlval_access_vns(vn_maxfr, []).
vn_util__vnlval_access_vns(vn_curfr, []).
vn_util__vnlval_access_vns(vn_prevfr(Vn), [Vn]).
vn_util__vnlval_access_vns(vn_redoip(Vn), [Vn]).
vn_util__vnlval_access_vns(vn_redofr(Vn), [Vn]).
vn_util__vnlval_access_vns(vn_succip(Vn), [Vn]).
vn_util__vnlval_access_vns(vn_succfr(Vn), [Vn]).
vn_util__vnlval_access_vns(vn_hp, []).
vn_util__vnlval_access_vns(vn_sp, []).
vn_util__vnlval_access_vns(vn_field(_, Vn1, Vn2), [Vn1, Vn2]).
vn_util__vnlval_access_vns(vn_mem_ref(Vn), [Vn]).
vn_util__find_sub_vns(vn_origlval(Vnlval), SubVns) :-
vn_util__vnlval_access_vns(Vnlval, SubVns).
vn_util__find_sub_vns(vn_mkword(_, SubVn), [SubVn]).
vn_util__find_sub_vns(vn_const(_), []).
vn_util__find_sub_vns(vn_create(_, _, _, _, _), []).
vn_util__find_sub_vns(vn_unop(_, SubVn), [SubVn]).
vn_util__find_sub_vns(vn_binop(_, SubVn1, SubVn2), [SubVn1, SubVn2]).
vn_util__find_sub_vns(vn_stackvar_addr(_), []).
vn_util__find_sub_vns(vn_framevar_addr(_), []).
vn_util__find_sub_vns(vn_heap_addr(SubVn, _, _), [SubVn]).
vn_util__is_const_expr(Vn, IsConst, VnTables) :-
vn_table__lookup_defn(Vn, Vnrval, "vn_util__is_const_expr", VnTables),
(
Vnrval = vn_origlval(_),
IsConst = no
;
Vnrval = vn_mkword(_, Vn1),
vn_util__is_const_expr(Vn1, IsConst, VnTables)
;
Vnrval = vn_const(_),
IsConst = yes
;
Vnrval = vn_create(_, _, _, _, _),
IsConst = yes
;
Vnrval = vn_unop(_, Vn1),
vn_util__is_const_expr(Vn1, IsConst, VnTables)
;
Vnrval = vn_binop(_, Vn1, Vn2),
vn_util__is_const_expr(Vn1, IsConst1, VnTables),
vn_util__is_const_expr(Vn2, IsConst2, VnTables),
bool__and(IsConst1, IsConst2, IsConst)
;
Vnrval = vn_stackvar_addr(_),
IsConst = no
;
Vnrval = vn_framevar_addr(_),
IsConst = no
;
Vnrval = vn_heap_addr(_, _, _),
IsConst = no
).
vn_util__find_lvals_in_rval(Rval, Lvals) :-
(
Rval = lval(Lval),
opt_util__lval_access_rvals(Lval, Rvals),
vn_util__find_lvals_in_rvals(Rvals, Lvals1),
Lvals = [Lval | Lvals1]
;
Rval = var(_),
error("var found in vn_util__find_lvals_in_rval")
;
Rval = create(_, _, _, _, _),
Lvals = []
;
Rval = mkword(_, Rval1),
vn_util__find_lvals_in_rval(Rval1, Lvals)
;
Rval = const(_),
Lvals = []
;
Rval = unop(_, Rval1),
vn_util__find_lvals_in_rval(Rval1, Lvals)
;
Rval = binop(_, Rval1, Rval2),
vn_util__find_lvals_in_rval(Rval1, Lvals1),
vn_util__find_lvals_in_rval(Rval2, Lvals2),
list__append(Lvals1, Lvals2, Lvals)
;
Rval = mem_addr(MemRef),
vn_util__find_lvals_in_mem_ref(MemRef, Lvals)
).
vn_util__find_lvals_in_rvals([], []).
vn_util__find_lvals_in_rvals([Rval | Rvals], Lvals) :-
vn_util__find_lvals_in_rval(Rval, Lvals1),
vn_util__find_lvals_in_rvals(Rvals, Lvals2),
list__append(Lvals1, Lvals2, Lvals).
:- pred vn_util__find_lvals_in_mem_ref(mem_ref, list(lval)).
:- mode vn_util__find_lvals_in_mem_ref(in, out) is det.
% XXX
vn_util__find_lvals_in_mem_ref(stackvar_ref(_), []).
vn_util__find_lvals_in_mem_ref(framevar_ref(_), []).
vn_util__find_lvals_in_mem_ref(heap_ref(Rval, _, _), Lvals) :-
vn_util__find_lvals_in_rval(Rval, Lvals).
vn_util__is_vn_shared(Vn, Vnrval, Uses0, VnTables) :-
vn_util__is_const_expr(Vn, no, VnTables),
\+ Vnrval = vn_origlval(vn_hp),
vn_util__real_uses(Uses0, Uses1, VnTables),
Uses1 = [_,_|_].
vn_util__real_uses([], [], _VnTables).
vn_util__real_uses([Use0 | Uses0], Uses, VnTables) :-
vn_util__real_uses(Uses0, Uses1, VnTables),
( list__member(Use0, Uses1) ->
Uses = Uses1
; Use0 = src_liveval(Vnlval) ->
(
vn_table__search_desired_value(Vnlval, Vn, VnTables),
vn_table__search_current_value(Vnlval, Vn, VnTables)
->
Uses = Uses1
;
Uses = [Use0 | Uses1]
)
; Use0 = src_access(Vnlval) ->
(
vn_table__search_desired_value(Vnlval, Vn, VnTables),
vn_table__search_current_value(Vnlval, Vn, VnTables),
( vn_table__search_uses(Vn, AccessUses, VnTables) ->
(
vn_util__real_uses(AccessUses, [],
VnTables)
;
vn_table__search_current_locs(Vn, Locs,
VnTables),
vn_util__choose_cheapest_loc(Locs, Loc),
vn_util__classify_loc_cost(Loc, 0)
)
;
true
)
->
Uses = Uses1
;
Uses = [Use0 | Uses1]
)
;
Uses = [Use0 | Uses1]
).
vn_util__choose_cheapest_loc(Locs, BestLoc) :-
vn_util__choose_cheapest_loc_2(Locs, no, no, BestLoc).
:- pred vn_util__choose_cheapest_loc_2(list(vnlval), maybe(vnlval), maybe(vnlval),
vnlval).
:- mode vn_util__choose_cheapest_loc_2(in, in, in, out) is semidet.
vn_util__choose_cheapest_loc_2([Loc | Locs], Stack0, Heap0, BestLoc) :-
vn_util__classify_loc_cost(Loc, Cost),
( Cost = 0 ->
BestLoc = Loc
; Cost = 1 ->
vn_util__choose_cheapest_loc_2(Locs, yes(Loc), Heap0, BestLoc)
;
vn_util__choose_cheapest_loc_2(Locs, Stack0, yes(Loc), BestLoc)
).
vn_util__choose_cheapest_loc_2([], Stack0, Heap0, BestLoc) :-
( Stack0 = yes(Stack) ->
BestLoc = Stack
; Heap0 = yes(Heap) ->
BestLoc = Heap
;
fail
).
vn_util__classify_loc_cost(vn_reg(_, _), 0).
vn_util__classify_loc_cost(vn_temp(_, _), 0).
vn_util__classify_loc_cost(vn_stackvar(_), 1).
vn_util__classify_loc_cost(vn_framevar(_), 1).
vn_util__classify_loc_cost(vn_succip, 0).
vn_util__classify_loc_cost(vn_maxfr, 0).
vn_util__classify_loc_cost(vn_curfr, 0).
vn_util__classify_loc_cost(vn_prevfr(_), 1).
vn_util__classify_loc_cost(vn_redoip(_), 1).
vn_util__classify_loc_cost(vn_redofr(_), 1).
vn_util__classify_loc_cost(vn_succip(_), 1).
vn_util__classify_loc_cost(vn_succfr(_), 1).
vn_util__classify_loc_cost(vn_hp, 0).
vn_util__classify_loc_cost(vn_sp, 0).
vn_util__classify_loc_cost(vn_field(_, _, _), 2).
vn_util__classify_loc_cost(vn_mem_ref(_), 2).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- interface.
% Build up a list of the uses of each vn.
:- pred vn_util__build_uses(vnlvalset, ctrlmap, vn_tables, vn_tables).
% :- mode vn_util__build_uses(in, in, di, uo) is det.
:- mode vn_util__build_uses(in, in, in, out) is det.
:- implementation.
vn_util__build_uses(Livevals, Ctrlmap, VnTables0, VnTables) :-
vn_util__build_uses_from_ctrl(0, Ctrlmap, VnTables0, VnTables1),
set__to_sorted_list(Livevals, Livelist),
vn_util__build_uses_from_livevals(Livelist, VnTables1, VnTables).
:- pred vn_util__build_uses_from_ctrl(int, ctrlmap, vn_tables, vn_tables).
% :- mode vn_util__build_uses_from_ctrl(in, in, di, uo) is det.
:- mode vn_util__build_uses_from_ctrl(in, in, in, out) is det.
vn_util__build_uses_from_ctrl(Ctrl, Ctrlmap, VnTables0, VnTables) :-
( map__search(Ctrlmap, Ctrl, VnInstr) ->
(
VnInstr = vn_livevals(_),
VnTables1 = VnTables0
;
VnInstr = vn_call(_, _, _, _),
VnTables1 = VnTables0
;
VnInstr = vn_mkframe(_, _),
VnTables1 = VnTables0
;
VnInstr = vn_label(_),
VnTables1 = VnTables0
;
VnInstr = vn_goto(_),
VnTables1 = VnTables0
;
VnInstr = vn_computed_goto(Vn, _),
vn_util__record_use(Vn, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_if_val(Vn, _),
vn_util__record_use(Vn, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_mark_hp(Vnlval),
vn_util__vnlval_access_vns(Vnlval, Vns),
vn_util__record_use_list(Vns, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_restore_hp(Vn),
vn_util__record_use(Vn, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_store_ticket(Vnlval),
vn_util__vnlval_access_vns(Vnlval, Vns),
vn_util__record_use_list(Vns, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_reset_ticket(Vn, _Reason),
vn_util__record_use(Vn, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_discard_ticket,
VnTables1 = VnTables0
;
VnInstr = vn_mark_ticket_stack(Vnlval),
vn_util__vnlval_access_vns(Vnlval, Vns),
vn_util__record_use_list(Vns, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_discard_tickets_to(Vn),
vn_util__record_use(Vn, src_ctrl(Ctrl),
VnTables0, VnTables1)
;
VnInstr = vn_incr_sp(_, _),
VnTables1 = VnTables0
;
VnInstr = vn_decr_sp(_),
VnTables1 = VnTables0
),
NextCtrl is Ctrl + 1,
vn_util__build_uses_from_ctrl(NextCtrl, Ctrlmap,
VnTables1, VnTables)
;
VnTables = VnTables0
).
% We have to record two kinds of uses. The first is the use of the
% value number we want to assign to the vnlval. The second is the
% value numbers needed to access the vnlval at all.
:- pred vn_util__build_uses_from_livevals(list(vnlval), vn_tables, vn_tables).
% :- mode vn_util__build_uses_from_livevals(in, di, uo) is det.
:- mode vn_util__build_uses_from_livevals(in, in, out) is det.
vn_util__build_uses_from_livevals([], VnTables, VnTables).
vn_util__build_uses_from_livevals([Live | Liveslist], VnTables0, VnTables) :-
( vn_table__search_desired_value(Live, VnPrime, VnTables0) ->
Vn = VnPrime,
VnTables1 = VnTables0
;
vn_table__record_first_vnlval(Live, Vn, VnTables0, VnTables1)
),
vn_util__record_use(Vn, src_liveval(Live), VnTables1, VnTables2),
vn_util__record_access([Live], VnTables2, VnTables3),
vn_util__build_uses_from_livevals(Liveslist, VnTables3, VnTables).
:- pred vn_util__record_access(list(vnlval), vn_tables, vn_tables).
% :- mode vn_util__record_access(in, di, uo) is det.
:- mode vn_util__record_access(in, in, out) is det.
vn_util__record_access([], VnTables, VnTables).
vn_util__record_access([Vnlval | Vnlvals], VnTables0, VnTables) :-
vn_util__vnlval_access_vns(Vnlval, SubVns),
vn_util__record_use_list(SubVns, src_access(Vnlval),
VnTables0, VnTables1),
vn_util__record_access(Vnlvals, VnTables1, VnTables).
:- pred vn_util__record_use(vn, vn_src, vn_tables, vn_tables).
% :- mode vn_util__record_use(in, in, di, uo) is det.
:- mode vn_util__record_use(in, in, in, out) is det.
vn_util__record_use(Vn, Src, VnTables0, VnTables) :-
vn_table__lookup_uses(Vn, OldUses, "vn_util__record_use", VnTables0),
vn_table__add_new_use(Vn, Src, VnTables0, VnTables1),
( OldUses = [] ->
vn_table__lookup_defn(Vn, Vnrval, "vn_util__record_use",
VnTables1),
(
Vnrval = vn_origlval(Vnlval),
vn_util__record_access([Vnlval], VnTables1, VnTables)
;
Vnrval = vn_mkword(_, SubVn),
vn_util__record_use(SubVn, src_vn(Vn),
VnTables1, VnTables)
;
Vnrval = vn_const(_),
VnTables = VnTables1
;
Vnrval = vn_create(_, _, _, _, _),
VnTables = VnTables1
;
Vnrval = vn_unop(_, SubVn),
vn_util__record_use(SubVn, src_vn(Vn),
VnTables1, VnTables)
;
Vnrval = vn_binop(_, SubVn1, SubVn2),
vn_util__record_use(SubVn1, src_vn(Vn),
VnTables1, VnTables2),
vn_util__record_use(SubVn2, src_vn(Vn),
VnTables2, VnTables)
;
Vnrval = vn_stackvar_addr(_),
VnTables = VnTables1
;
Vnrval = vn_framevar_addr(_),
VnTables = VnTables1
;
Vnrval = vn_heap_addr(SubVn, _, _),
vn_util__record_use(SubVn, src_vn(Vn),
VnTables1, VnTables)
)
;
VnTables = VnTables1
).
:- pred vn_util__record_use_list(list(vn), vn_src, vn_tables, vn_tables).
% :- mode vn_util__record_use_list(in, in, di, uo) is det.
:- mode vn_util__record_use_list(in, in, in, out) is det.
vn_util__record_use_list([], _Src, VnTables, VnTables).
vn_util__record_use_list([Vn | Vns], Src, VnTables0, VnTables) :-
vn_util__record_use(Vn, Src, VnTables0, VnTables1),
vn_util__record_use_list(Vns, Src, VnTables1, VnTables).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink