mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-17 06:47:17 +00:00
c70dbe9e2b
Estimated hours taken: 2 code_exprn: When we are processing the flushing of create expressions, make sure the Lval we are creating into isn't a field reference. This avoids deep field of field of field of ... nesting. It does introduce references to high register numbers, but this is a lesser evil, and Tom and I plan to fix this anyway. arg_info, globals, options: Change --args old to --args simple. options: Make some help messages more specific. code_aux, code_exprn, code_info, det_report, make_hlds, mercury_to_goedel, prog_io, typecheck: Changes to accommodate the move from varset__lookup_name to varset__search_name.
1310 lines
41 KiB
Mathematica
1310 lines
41 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1995 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.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% file: code_exprn.m
|
|
% main author: conway.
|
|
%
|
|
% This module defines a series of predicates that operate on the
|
|
% abstract 'exprn_info' structure which maintains information about
|
|
% the contents of registers, and manages the cached expressions for
|
|
% variables. These predicates are:
|
|
%
|
|
% code_exprn__init_state(Arguments, Varset, Opts, ExprnInfo)
|
|
% which produces an initial state of the ExprnInfo given
|
|
% an association list of variables and lvalues. The initial
|
|
% state places the given variables at their corresponding
|
|
% locations. The Varset parameter contains a mapping from
|
|
% variables to names, which is used when code is generated
|
|
% to provide meaningful comments. Opts gives the table of
|
|
% options; this is used to decide what expressions are
|
|
% considered constants.
|
|
%
|
|
% code_exprn__clobber_regs(CriticalVars, ExprnInfo0, ExprnInfo)
|
|
% which modifies the state ExprnInfo0 to produce ExprnInfo
|
|
% in which all variables stored in registers are clobbered.
|
|
% If any variables in CriticalVars are stored only in
|
|
% registers, and are not stored on the stack, then this
|
|
% predicate will abort.
|
|
%
|
|
% code_exprn__set_var_location(Var, Lval, ExprnInfo0, ExprnInfo)
|
|
% which modifies ExprnInfo0 to produce ExprnInfo in which
|
|
% Var is *magically* stored in Lval.
|
|
%
|
|
% code_exprn__var_becomes_dead(Var, ExprnInfo0, ExprnInfo)
|
|
% which frees any code generator resources used by Var
|
|
% in ExprnInfo0 to produce ExprnInfo (in the implementation,
|
|
% any cached expressions which still need those resources
|
|
% will inherit them appropriately).
|
|
%
|
|
% code_exprn__cache_exprn(Var, Rval, ExprnInfo0, ExprnInfo)
|
|
% which produces a modified ExprnInfo0, ExprnInfo
|
|
% which indicates that when a value of Var is needed,
|
|
% code to evaluate Rval should be produced.
|
|
%
|
|
% code_exprn__place_var(Var, Lval, Code, ExprnInfo0, ExprnInfo)
|
|
% which produces Code and a modified version of ExprnInfo0,
|
|
% ExprnInfo which places the value of Var in Lval.
|
|
%
|
|
% code_exprn__produce_var(Var, Rval, Code, ExprnInfo0, ExprnInfo)
|
|
% which produces a code fragment Code to evaluate Var and
|
|
% provide it as Rval (which may be a const, etc, or an lval).
|
|
%
|
|
% code_exprn__acquire_reg(Reg, ExprnInfo0, ExprnInfo)
|
|
% which finds an unused register and marks it as 'in use'.
|
|
%
|
|
% code_exprn__release_reg(Reg, ExprnInfo, ExprnInfo)
|
|
% which marks a previously acquired reg and releases it so
|
|
% that it can be reused.
|
|
%
|
|
% code_exprn__lock_reg(Reg, ExprnInfo, ExprnInfo)
|
|
% which prevents a register from being reused, even if
|
|
% there are no variables refering to it.
|
|
%
|
|
% code_exprn__unlock_reg(Reg, ExprnInfo0, ExprnInfo)
|
|
% which undoes the previous operation.
|
|
%
|
|
%------------------------------------------------------------------------------%
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- module code_exprn.
|
|
|
|
:- interface.
|
|
|
|
:- import_module llds, list, varset, std_util, assoc_list, tree, options.
|
|
|
|
:- type exprn_info.
|
|
|
|
:- pred code_exprn__init_state(assoc_list(var, rval), varset, option_table,
|
|
exprn_info).
|
|
:- mode code_exprn__init_state(in, in, in, out) is det.
|
|
|
|
:- pred code_exprn__clobber_regs(list(var), exprn_info, exprn_info).
|
|
:- mode code_exprn__clobber_regs(in, in, out) is det.
|
|
|
|
:- pred code_exprn__set_var_location(var, lval, exprn_info, exprn_info).
|
|
:- mode code_exprn__set_var_location(in, in, in, out) is det.
|
|
|
|
:- pred code_exprn__maybe_set_var_location(var, lval, exprn_info, exprn_info).
|
|
:- mode code_exprn__maybe_set_var_location(in, in, in, out) is det.
|
|
|
|
:- pred code_exprn__var_becomes_dead(var, exprn_info, exprn_info).
|
|
:- mode code_exprn__var_becomes_dead(in, in, out) is det.
|
|
|
|
:- pred code_exprn__cache_exprn(var, rval, exprn_info, exprn_info).
|
|
:- mode code_exprn__cache_exprn(in, in, in, out) is det.
|
|
|
|
:- pred code_exprn__place_var(var, lval, code_tree, exprn_info, exprn_info).
|
|
:- mode code_exprn__place_var(in, in, out, in, out) is det.
|
|
|
|
:- pred code_exprn__produce_var(var, rval, code_tree, exprn_info, exprn_info).
|
|
:- mode code_exprn__produce_var(in, out, out, in, out) is det.
|
|
|
|
:- pred code_exprn__produce_var_in_reg(var, rval, code_tree,
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__produce_var_in_reg(in, out, out, in, out) is det.
|
|
|
|
:- pred code_exprn__acquire_reg(reg, exprn_info, exprn_info).
|
|
:- mode code_exprn__acquire_reg(out, in, out) is det.
|
|
|
|
:- pred code_exprn__release_reg(reg, exprn_info, exprn_info).
|
|
:- mode code_exprn__release_reg(in, in, out) is det.
|
|
|
|
:- pred code_exprn__lock_reg(reg, exprn_info, exprn_info).
|
|
:- mode code_exprn__lock_reg(in, in, out) is det.
|
|
|
|
:- pred code_exprn__unlock_reg(reg, exprn_info, exprn_info).
|
|
:- mode code_exprn__unlock_reg(in, in, out) is det.
|
|
|
|
:- pred code_exprn__get_varlocs(map(var, set(rval)), exprn_info, exprn_info).
|
|
:- mode code_exprn__get_varlocs(out, in, out) is det.
|
|
|
|
%------------------------------------------------------------------------------%
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module exprn_aux.
|
|
:- import_module bool, map, bag, set, require, int, term, string.
|
|
|
|
:- type var_stat --->
|
|
evaled(set(rval))
|
|
; cached(rval).
|
|
|
|
:- type var_map == map(var, var_stat).
|
|
|
|
:- type exprn_info --->
|
|
exprn_info(
|
|
varset, % all the variables and their names
|
|
var_map, % what each variable stands for
|
|
bag(reg), % the 'in use' markers for regs
|
|
set(reg), % extra markers for acquired regs
|
|
exprn_opts % options needed for constant checks
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__init_state(Initializations, Varset, Options, ExprnInfo) :-
|
|
map__init(Vars0),
|
|
bag__init(Regs0),
|
|
code_exprn__init_state_2(Initializations, Vars0, Vars, Regs0, Regs),
|
|
set__init(Acqu),
|
|
exprn_aux__init_exprn_opts(Options, ExprnOpts),
|
|
ExprnInfo = exprn_info(Varset, Vars, Regs, Acqu, ExprnOpts).
|
|
|
|
:- pred code_exprn__init_state_2(assoc_list(var, rval), var_map, var_map,
|
|
bag(reg), bag(reg)).
|
|
:- mode code_exprn__init_state_2(in, in, out, in, out) is det.
|
|
|
|
code_exprn__init_state_2([], Vars, Vars, Regs, Regs).
|
|
code_exprn__init_state_2([V - L|Rest], Vars0, Vars, Regs0, Regs) :-
|
|
(
|
|
map__search(Vars0, V, evaled(Vals0))
|
|
->
|
|
set__insert(Vals0, L, Vals)
|
|
;
|
|
set__singleton_set(Vals, L)
|
|
),
|
|
map__set(Vars0, V, evaled(Vals), Vars1),
|
|
(
|
|
L = lval(reg(R))
|
|
->
|
|
bag__insert(Regs0, R, Regs1)
|
|
;
|
|
Regs1 = Regs0
|
|
),
|
|
code_exprn__init_state_2(Rest, Vars1, Vars, Regs1, Regs).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__get_varlocs(Locations) -->
|
|
code_exprn__get_vars(Vars),
|
|
{ map__to_assoc_list(Vars, VarList) },
|
|
{ map__init(Locations0) },
|
|
{ code_exprn__repackage_locations(VarList, Locations0, Locations) }.
|
|
|
|
:- pred code_exprn__repackage_locations(assoc_list(var, var_stat),
|
|
map(var, set(rval)), map(var, set(rval))).
|
|
:- mode code_exprn__repackage_locations(in, in, out) is det.
|
|
|
|
code_exprn__repackage_locations([], Loc, Loc).
|
|
code_exprn__repackage_locations([V - Locs|Rest], Loc0, Loc) :-
|
|
(
|
|
Locs = cached(Rval),
|
|
set__singleton_set(Rvals, Rval)
|
|
;
|
|
Locs = evaled(Rvals)
|
|
),
|
|
map__set(Loc0, V, Rvals, Loc1),
|
|
code_exprn__repackage_locations(Rest, Loc1, Loc).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__clobber_regs(CriticalVars) -->
|
|
code_exprn__get_vars(Vars0),
|
|
{ map__to_assoc_list(Vars0, VarsList) },
|
|
{ map__init(Vars1) },
|
|
{ code_exprn__clobber_regs_2(VarsList, CriticalVars, Vars0,
|
|
Vars1, Vars) },
|
|
code_exprn__set_vars(Vars),
|
|
{ bag__init(Regs) },
|
|
code_exprn__set_regs(Regs),
|
|
{ set__init(Acqu) },
|
|
code_exprn__set_acquired(Acqu).
|
|
|
|
:- pred code_exprn__clobber_regs_2(assoc_list(var, var_stat), list(var),
|
|
var_map, var_map, var_map).
|
|
:- mode code_exprn__clobber_regs_2(in, in, in, in, out) is det.
|
|
|
|
code_exprn__clobber_regs_2([], _Critical, _OldVars, Vars, Vars).
|
|
code_exprn__clobber_regs_2([V - Stat|Rest], Critical, OldVars, Vars0, Vars) :-
|
|
(
|
|
Stat = cached(Exprn),
|
|
(
|
|
code_exprn__rval_depends_on_reg(Exprn, OldVars)
|
|
->
|
|
(
|
|
list__member(V, Critical)
|
|
->
|
|
error("code_exprn__clobber_regs: attempt to clobber critical register")
|
|
;
|
|
true
|
|
),
|
|
Vars1 = Vars0
|
|
;
|
|
map__set(Vars0, V, Stat, Vars1)
|
|
)
|
|
;
|
|
Stat = evaled(Rvals0),
|
|
code_exprn__filter_out_reg_depending(Rvals0, OldVars, Rvals),
|
|
(
|
|
set__empty(Rvals)
|
|
->
|
|
(
|
|
list__member(V, Critical)
|
|
->
|
|
error("code_exprn__clobber_regs: attempt to clobber critical register")
|
|
;
|
|
true
|
|
),
|
|
Vars1 = Vars0
|
|
;
|
|
map__set(Vars0, V, evaled(Rvals), Vars1)
|
|
)
|
|
),
|
|
code_exprn__clobber_regs_2(Rest, Critical, OldVars, Vars1, Vars).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__rval_depends_on_reg(rval, var_map).
|
|
:- mode code_exprn__rval_depends_on_reg(in, in) is semidet.
|
|
|
|
code_exprn__rval_depends_on_reg(lval(Lval), Vars) :-
|
|
code_exprn__lval_depends_on_reg(Lval, Vars).
|
|
code_exprn__rval_depends_on_reg(var(Var), Vars) :-
|
|
map__lookup(Vars, Var, Stat),
|
|
(
|
|
Stat = cached(Rval),
|
|
code_exprn__rval_depends_on_reg(Rval, Vars)
|
|
;
|
|
Stat = evaled(Rvals0),
|
|
code_exprn__filter_out_reg_depending(Rvals0, Vars, Rvals),
|
|
set__empty(Rvals)
|
|
).
|
|
code_exprn__rval_depends_on_reg(create(_Tag, Rvals, _LabNum), Vars) :-
|
|
code_exprn__args_depend_on_reg(Rvals, Vars).
|
|
code_exprn__rval_depends_on_reg(mkword(_Tag, Rval), Vars) :-
|
|
code_exprn__rval_depends_on_reg(Rval, Vars).
|
|
code_exprn__rval_depends_on_reg(const(_Const), _Vars) :-
|
|
fail.
|
|
code_exprn__rval_depends_on_reg(unop(_Op, Rval), Vars) :-
|
|
code_exprn__rval_depends_on_reg(Rval, Vars).
|
|
code_exprn__rval_depends_on_reg(binop(_Op, Rval0, Rval1), Vars) :-
|
|
(
|
|
code_exprn__rval_depends_on_reg(Rval0, Vars)
|
|
;
|
|
code_exprn__rval_depends_on_reg(Rval1, Vars)
|
|
).
|
|
|
|
:- pred code_exprn__lval_depends_on_reg(lval, var_map).
|
|
:- mode code_exprn__lval_depends_on_reg(in, in) is semidet.
|
|
|
|
code_exprn__lval_depends_on_reg(reg(_), _Vars) :-
|
|
true.
|
|
code_exprn__lval_depends_on_reg(lvar(Var), Vars) :-
|
|
map__lookup(Vars, Var, Stat),
|
|
(
|
|
Stat = cached(Rval),
|
|
code_exprn__rval_depends_on_reg(Rval, Vars)
|
|
;
|
|
Stat = evaled(Rvals0),
|
|
code_exprn__filter_out_reg_depending(Rvals0, Vars, Rvals),
|
|
set__empty(Rvals)
|
|
).
|
|
code_exprn__lval_depends_on_reg(field(_Tag, Rval0, Rval1), Vars) :-
|
|
(
|
|
code_exprn__rval_depends_on_reg(Rval0, Vars)
|
|
;
|
|
code_exprn__rval_depends_on_reg(Rval1, Vars)
|
|
).
|
|
|
|
:- pred code_exprn__args_depend_on_reg(list(maybe(rval)), var_map).
|
|
:- mode code_exprn__args_depend_on_reg(in, in) is semidet.
|
|
|
|
code_exprn__args_depend_on_reg([], _Vars) :-
|
|
fail.
|
|
code_exprn__args_depend_on_reg([Arg|Args], Vars) :-
|
|
(
|
|
Arg = yes(Rval),
|
|
code_exprn__rval_depends_on_reg(Rval, Vars)
|
|
->
|
|
true
|
|
;
|
|
code_exprn__args_depend_on_reg(Args, Vars)
|
|
).
|
|
|
|
:- pred code_exprn__filter_out_reg_depending(set(rval), var_map, set(rval)).
|
|
:- mode code_exprn__filter_out_reg_depending(in, in, out) is det.
|
|
|
|
code_exprn__filter_out_reg_depending(Rvals0, Vars, Rvals) :-
|
|
set__to_sorted_list(Rvals0, RvalList0),
|
|
code_exprn__filter_out_reg_depending_2(RvalList0, Vars, RvalList),
|
|
set__sorted_list_to_set(RvalList, Rvals).
|
|
|
|
:- pred code_exprn__filter_out_reg_depending_2(list(rval), var_map, list(rval)).
|
|
:- mode code_exprn__filter_out_reg_depending_2(in, in, out) is det.
|
|
|
|
code_exprn__filter_out_reg_depending_2([], _Vars, []).
|
|
code_exprn__filter_out_reg_depending_2([Rval0|Rvals0], Vars, Rvals) :-
|
|
code_exprn__filter_out_reg_depending_2(Rvals0, Vars, Rvals1),
|
|
(
|
|
code_exprn__rval_depends_on_reg(Rval0, Vars)
|
|
->
|
|
Rvals = Rvals1
|
|
;
|
|
Rvals = [Rval0|Rvals1]
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__set_var_location(Var, Lval) -->
|
|
code_exprn__get_vars(Vars0),
|
|
(
|
|
{ code_exprn__lval_in_use(Lval, Vars0) }
|
|
->
|
|
{ error("code_exprn__set_var_location: location already in use") }
|
|
;
|
|
{ set__singleton_set(Locs, lval(Lval)) },
|
|
{ map__set(Vars0, Var, evaled(Locs), Vars) },
|
|
code_exprn__set_vars(Vars),
|
|
code_exprn__add_lval_reg_dependencies(Lval)
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__maybe_set_var_location(Var, Lval) -->
|
|
code_exprn__get_vars(Vars0),
|
|
{ set__singleton_set(Locs, lval(Lval)) },
|
|
{ map__set(Vars0, Var, evaled(Locs), Vars) },
|
|
code_exprn__set_vars(Vars),
|
|
code_exprn__add_lval_reg_dependencies(Lval).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__lval_in_use(lval, var_map).
|
|
:- mode code_exprn__lval_in_use(in, in) is semidet.
|
|
|
|
code_exprn__lval_in_use(Lval, Vars) :-
|
|
map__values(Vars, StatList),
|
|
list__member(Stat, StatList),
|
|
(
|
|
Stat = cached(Rval0),
|
|
exprn_aux__rval_contains_lval(Rval0, Lval)
|
|
;
|
|
Stat = evaled(Rvals),
|
|
set__member(Rval1, Rvals),
|
|
exprn_aux__rval_contains_lval(Rval1, Lval)
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__add_lval_reg_dependencies(lval, exprn_info, exprn_info).
|
|
:- mode code_exprn__add_lval_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__add_lval_reg_dependencies(Lval) -->
|
|
(
|
|
{ Lval = reg(Reg) }
|
|
->
|
|
code_exprn__get_regs(Regs0),
|
|
{ bag__insert(Regs0, Reg, Regs) },
|
|
code_exprn__set_regs(Regs)
|
|
;
|
|
{ Lval = field(_Tag, Rval0, Rval1) }
|
|
->
|
|
code_exprn__add_rval_reg_dependencies(Rval0),
|
|
code_exprn__add_rval_reg_dependencies(Rval1)
|
|
;
|
|
[]
|
|
).
|
|
|
|
:- pred code_exprn__add_rval_list_reg_dependencies(list(rval),
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__add_rval_list_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__add_rval_list_reg_dependencies([]) --> [].
|
|
code_exprn__add_rval_list_reg_dependencies([R|Rs]) -->
|
|
code_exprn__add_rval_reg_dependencies(R),
|
|
code_exprn__add_rval_list_reg_dependencies(Rs).
|
|
|
|
:- pred code_exprn__add_rval_reg_dependencies(rval, exprn_info, exprn_info).
|
|
:- mode code_exprn__add_rval_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__add_rval_reg_dependencies(lval(Lval)) -->
|
|
code_exprn__add_lval_reg_dependencies(Lval).
|
|
code_exprn__add_rval_reg_dependencies(var(_Var)) --> [].
|
|
code_exprn__add_rval_reg_dependencies(create(_, Rvals, _)) -->
|
|
code_exprn__add_arg_reg_dependencies(Rvals).
|
|
code_exprn__add_rval_reg_dependencies(mkword(_Tag, Rval)) -->
|
|
code_exprn__add_rval_reg_dependencies(Rval).
|
|
code_exprn__add_rval_reg_dependencies(const(_Const)) --> [].
|
|
code_exprn__add_rval_reg_dependencies(unop(_Op, Rval)) -->
|
|
code_exprn__add_rval_reg_dependencies(Rval).
|
|
code_exprn__add_rval_reg_dependencies(binop(_Op, Rval0, Rval1)) -->
|
|
code_exprn__add_rval_reg_dependencies(Rval0),
|
|
code_exprn__add_rval_reg_dependencies(Rval1).
|
|
|
|
:- pred code_exprn__add_arg_reg_dependencies(list(maybe(rval)),
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__add_arg_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__add_arg_reg_dependencies([]) --> [].
|
|
code_exprn__add_arg_reg_dependencies([M|Ms]) -->
|
|
(
|
|
{ M = yes(Rval) }
|
|
->
|
|
code_exprn__add_rval_reg_dependencies(Rval)
|
|
;
|
|
[]
|
|
),
|
|
code_exprn__add_arg_reg_dependencies(Ms).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__rem_lval_reg_dependencies(lval, exprn_info, exprn_info).
|
|
:- mode code_exprn__rem_lval_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__rem_lval_reg_dependencies(Lval) -->
|
|
(
|
|
{ Lval = reg(Reg) }
|
|
->
|
|
code_exprn__get_regs(Regs0),
|
|
{ bag__remove(Regs0, Reg, Regs) },
|
|
code_exprn__set_regs(Regs)
|
|
;
|
|
{ Lval = field(_Tag, Rval0, Rval1) }
|
|
->
|
|
code_exprn__rem_rval_reg_dependencies(Rval0),
|
|
code_exprn__rem_rval_reg_dependencies(Rval1)
|
|
;
|
|
[]
|
|
).
|
|
|
|
:- pred code_exprn__rem_rval_list_reg_dependencies(list(rval),
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__rem_rval_list_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__rem_rval_list_reg_dependencies([]) --> [].
|
|
code_exprn__rem_rval_list_reg_dependencies([R|Rs]) -->
|
|
code_exprn__rem_rval_reg_dependencies(R),
|
|
code_exprn__rem_rval_list_reg_dependencies(Rs).
|
|
|
|
:- pred code_exprn__rem_rval_reg_dependencies(rval, exprn_info, exprn_info).
|
|
:- mode code_exprn__rem_rval_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__rem_rval_reg_dependencies(lval(Lval)) -->
|
|
code_exprn__rem_lval_reg_dependencies(Lval).
|
|
code_exprn__rem_rval_reg_dependencies(var(_Var)) --> [].
|
|
code_exprn__rem_rval_reg_dependencies(create(_, Rvals, _)) -->
|
|
code_exprn__rem_arg_reg_dependencies(Rvals).
|
|
code_exprn__rem_rval_reg_dependencies(mkword(_Tag, Rval)) -->
|
|
code_exprn__rem_rval_reg_dependencies(Rval).
|
|
code_exprn__rem_rval_reg_dependencies(const(_Const)) --> [].
|
|
code_exprn__rem_rval_reg_dependencies(unop(_Op, Rval)) -->
|
|
code_exprn__rem_rval_reg_dependencies(Rval).
|
|
code_exprn__rem_rval_reg_dependencies(binop(_Op, Rval0, Rval1)) -->
|
|
code_exprn__rem_rval_reg_dependencies(Rval0),
|
|
code_exprn__rem_rval_reg_dependencies(Rval1).
|
|
|
|
:- pred code_exprn__rem_arg_reg_dependencies(list(maybe(rval)),
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__rem_arg_reg_dependencies(in, in, out) is det.
|
|
|
|
code_exprn__rem_arg_reg_dependencies([]) --> [].
|
|
code_exprn__rem_arg_reg_dependencies([M|Ms]) -->
|
|
(
|
|
{ M = yes(Rval) }
|
|
->
|
|
code_exprn__rem_rval_reg_dependencies(Rval)
|
|
;
|
|
[]
|
|
),
|
|
code_exprn__rem_arg_reg_dependencies(Ms).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__var_becomes_dead(Var) -->
|
|
code_exprn__get_vars(Vars0),
|
|
(
|
|
{ map__search(Vars0, Var, Stat) }
|
|
->
|
|
(
|
|
{ Stat = cached(Rval0) },
|
|
code_exprn__rem_rval_reg_dependencies(Rval0)
|
|
;
|
|
{ Stat = evaled(Rvals0) },
|
|
{ set__to_sorted_list(Rvals0, RvalList0) },
|
|
code_exprn__rem_rval_list_reg_dependencies(RvalList0),
|
|
code_exprn__get_options(ExprnOpts),
|
|
(
|
|
{ code_exprn__member_expr_is_constant(RvalList0,
|
|
Vars0, ExprnOpts, Rval7) }
|
|
->
|
|
{ Rval0 = Rval7 }
|
|
;
|
|
{ code_exprn__select_rval(RvalList0, Rval0) }
|
|
)
|
|
),
|
|
{ map__delete(Vars0, Var, Vars1) },
|
|
code_exprn__set_vars(Vars1),
|
|
code_exprn__update_dependent_vars(Var, Rval0)
|
|
;
|
|
% XXX When we make the code generator tighter,
|
|
% we can reinstate this sanity check. In particular,
|
|
% code_info needs to know which args (etc) have
|
|
% been explicitly killed off during the generation
|
|
% of the goal.
|
|
% code_exprn__get_var_name(Var, Name),
|
|
% { string__append_list(["code_exprn__var_becomes_dead: var ",
|
|
% Name, " not found!"], Msg) },
|
|
% { error(Msg) }
|
|
[]
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__update_dependent_vars(var, rval, exprn_info, exprn_info).
|
|
:- mode code_exprn__update_dependent_vars(in, in, in, out) is det.
|
|
|
|
code_exprn__update_dependent_vars(Var, Rval) -->
|
|
code_exprn__get_vars(Vars0),
|
|
{ map__to_assoc_list(Vars0, VarList0) },
|
|
code_exprn__update_dependent_vars_2(VarList0, Var, Rval, VarList),
|
|
{ map__from_assoc_list(VarList, Vars) },
|
|
code_exprn__set_vars(Vars).
|
|
|
|
:- pred code_exprn__update_dependent_vars_2(assoc_list(var, var_stat),
|
|
var, rval, assoc_list(var, var_stat), exprn_info, exprn_info).
|
|
:- mode code_exprn__update_dependent_vars_2(in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__update_dependent_vars_2([], _Var, _Rval, []) --> [].
|
|
code_exprn__update_dependent_vars_2([V - Stat0|Rest0], Var, Rval,
|
|
[V - Stat|Rest]) -->
|
|
(
|
|
{ Stat0 = cached(Exprn0) },
|
|
{ exprn_aux__rval_contains_rval(Exprn0, var(Var)) }
|
|
->
|
|
code_exprn__add_rval_reg_dependencies(Rval),
|
|
{ exprn_aux__substitute_rval_in_rval(var(Var), Rval,
|
|
Exprn0, Exprn1) },
|
|
{ exprn_aux__simplify_rval(Exprn1, Exprn) },
|
|
(
|
|
{ exprn_aux__vars_in_rval(Exprn, []) }
|
|
->
|
|
{ set__singleton_set(Rvals, Exprn) },
|
|
{ Stat = evaled(Rvals) }
|
|
;
|
|
{ Stat = cached(Exprn) }
|
|
)
|
|
;
|
|
{ Stat0 = evaled(Rvals0) }
|
|
->
|
|
{ set__to_sorted_list(Rvals0, RvalList0) },
|
|
code_exprn__update_dependent_vars_3(RvalList0, Var, Rval,
|
|
RvalList),
|
|
{ set__sorted_list_to_set(RvalList, Rvals) },
|
|
{ Stat = evaled(Rvals) }
|
|
;
|
|
% Stat0 = cached(Exprn), \+ contains
|
|
{ Stat = Stat0 }
|
|
),
|
|
code_exprn__update_dependent_vars_2(Rest0, Var, Rval, Rest).
|
|
|
|
:- pred code_exprn__update_dependent_vars_3(list(rval), var, rval, list(rval),
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__update_dependent_vars_3(in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__update_dependent_vars_3([], _Var, _Rval, []) --> [].
|
|
code_exprn__update_dependent_vars_3([R0|Rs0], Var, Rval, [R|Rs]) -->
|
|
(
|
|
{ exprn_aux__rval_contains_rval(R0, var(Var)) }
|
|
->
|
|
{ exprn_aux__substitute_rval_in_rval(var(Var), Rval, R0, R1) },
|
|
{ exprn_aux__simplify_rval(R1, R) },
|
|
code_exprn__rem_rval_reg_dependencies(R0),
|
|
code_exprn__add_rval_reg_dependencies(R)
|
|
;
|
|
{ R = R0 }
|
|
),
|
|
code_exprn__update_dependent_vars_3(Rs0, Var, Rval, Rs).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__select_rval(list(rval), rval).
|
|
:- mode code_exprn__select_rval(in, out) is det.
|
|
|
|
code_exprn__select_rval(Rs, Rval) :-
|
|
(
|
|
Rs = []
|
|
->
|
|
error("code_exprn__select_rval: no rvals")
|
|
;
|
|
code_exprn__select_reg(Rs, Rval0)
|
|
->
|
|
Rval = Rval0
|
|
;
|
|
code_exprn__select_simple_const(Rs, Rval1)
|
|
->
|
|
Rval = Rval1
|
|
;
|
|
code_exprn__select_stackvar(Rs, Rval2)
|
|
->
|
|
Rval = Rval2
|
|
;
|
|
Rs = [Rval3|_]
|
|
->
|
|
Rval = Rval3
|
|
;
|
|
error("code_exprn__select_rval: cosmic rays strike again")
|
|
).
|
|
|
|
:- pred code_exprn__select_reg(list(rval), rval).
|
|
:- mode code_exprn__select_reg(in, out) is semidet.
|
|
|
|
code_exprn__select_reg([R|Rs], Rval) :-
|
|
(
|
|
R = lval(reg(_))
|
|
->
|
|
Rval = R
|
|
;
|
|
code_exprn__select_reg(Rs, Rval)
|
|
).
|
|
|
|
:- pred code_exprn__select_simple_const(list(rval), rval).
|
|
:- mode code_exprn__select_simple_const(in, out) is semidet.
|
|
|
|
code_exprn__select_simple_const([R|Rs], Rval) :-
|
|
(
|
|
R = const(_)
|
|
->
|
|
Rval = R
|
|
;
|
|
code_exprn__select_simple_const(Rs, Rval)
|
|
).
|
|
|
|
:- pred code_exprn__select_stackvar(list(rval), rval).
|
|
:- mode code_exprn__select_stackvar(in, out) is semidet.
|
|
|
|
code_exprn__select_stackvar([R|Rs], Rval) :-
|
|
(
|
|
R = lval(C),
|
|
(
|
|
C = stackvar(_)
|
|
;
|
|
C = framevar(_)
|
|
)
|
|
->
|
|
Rval = R
|
|
;
|
|
code_exprn__select_stackvar(Rs, Rval)
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__expr_is_constant(rval, var_map, exprn_opts, rval).
|
|
:- mode code_exprn__expr_is_constant(in, in, in, out) is semidet.
|
|
|
|
code_exprn__expr_is_constant(const(Const), _Vars, ExprnOpts, const(Const)) :-
|
|
exprn_aux__const_is_constant(Const, ExprnOpts, yes).
|
|
|
|
code_exprn__expr_is_constant(unop(Op, Expr0), Vars, ExprnOpts,
|
|
unop(Op, Expr)) :-
|
|
code_exprn__expr_is_constant(Expr0, Vars, ExprnOpts, Expr).
|
|
|
|
code_exprn__expr_is_constant(binop(Op, Expr1, Expr2), Vars, ExprnOpts,
|
|
binop(Op, Expr3, Expr4)) :-
|
|
code_exprn__expr_is_constant(Expr1, Vars, ExprnOpts, Expr3),
|
|
code_exprn__expr_is_constant(Expr2, Vars, ExprnOpts, Expr4).
|
|
|
|
code_exprn__expr_is_constant(mkword(Tag, Expr0), Vars, ExprnOpts,
|
|
mkword(Tag, Expr)) :-
|
|
code_exprn__expr_is_constant(Expr0, Vars, ExprnOpts, Expr).
|
|
|
|
code_exprn__expr_is_constant(create(Tag, Args0, Label), Vars, ExprnOpts,
|
|
create(Tag, Args, Label)) :-
|
|
ExprnOpts = nlg_asm_sgt(_, _, yes),
|
|
code_exprn__args_are_constant(Args0, Vars, ExprnOpts, Args).
|
|
|
|
code_exprn__expr_is_constant(var(Var), Vars, ExprnOpts, Rval) :-
|
|
map__search(Vars, Var, Stat),
|
|
(
|
|
Stat = cached(Rval0),
|
|
code_exprn__expr_is_constant(Rval0, Vars, ExprnOpts, Rval)
|
|
;
|
|
Stat = evaled(Rvals),
|
|
set__to_sorted_list(Rvals, RvalList),
|
|
code_exprn__member_expr_is_constant(RvalList, Vars, ExprnOpts,
|
|
Rval)
|
|
).
|
|
|
|
:- pred code_exprn__args_are_constant(list(maybe(rval)), var_map,
|
|
exprn_opts, list(maybe(rval))).
|
|
:- mode code_exprn__args_are_constant(in, in, in, out) is semidet.
|
|
|
|
code_exprn__args_are_constant([], _Vars, _ExprnOpts, []).
|
|
code_exprn__args_are_constant([Arg0 | Args0], Vars, ExprnOpts, [Arg | Args]) :-
|
|
% if any of the fields are 'no' then we cannot treat the
|
|
% term as a constant.
|
|
Arg0 = yes(Rval0),
|
|
code_exprn__expr_is_constant(Rval0, Vars, ExprnOpts, Rval),
|
|
Arg = yes(Rval),
|
|
code_exprn__args_are_constant(Args0, Vars, ExprnOpts, Args).
|
|
|
|
:- pred code_exprn__member_expr_is_constant(list(rval), var_map,
|
|
exprn_opts, rval).
|
|
:- mode code_exprn__member_expr_is_constant(in, in, in, out) is semidet.
|
|
|
|
code_exprn__member_expr_is_constant([Rval0|Rvals0], Vars, ExprnOpts, Rval) :-
|
|
(
|
|
code_exprn__expr_is_constant(Rval0, Vars, ExprnOpts, Rval1)
|
|
->
|
|
Rval = Rval1
|
|
;
|
|
code_exprn__member_expr_is_constant(Rvals0, Vars, ExprnOpts,
|
|
Rval)
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__cache_exprn(Var, Rval) -->
|
|
code_exprn__get_vars(Vars0),
|
|
(
|
|
{ map__search(Vars0, Var, _) }
|
|
->
|
|
{ error("code_exprn__cache_exprn: existing definition of var") }
|
|
;
|
|
[]
|
|
),
|
|
code_exprn__add_rval_reg_dependencies(Rval),
|
|
(
|
|
{ exprn_aux__vars_in_rval(Rval, []) }
|
|
->
|
|
{ set__singleton_set(Rvals, Rval) },
|
|
{ map__set(Vars0, Var, evaled(Rvals), Vars) }
|
|
;
|
|
{ map__set(Vars0, Var, cached(Rval), Vars) }
|
|
),
|
|
code_exprn__set_vars(Vars).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__place_var(Var, Lval, Code) -->
|
|
code_exprn__get_vars(Vars0),
|
|
(
|
|
{ map__search(Vars0, Var, Stat0) }
|
|
->
|
|
{ Stat = Stat0 }
|
|
;
|
|
code_exprn__get_var_name(Var, Name),
|
|
{ string__append_list(["variable ", Name, " not found"], Msg) },
|
|
{ error(Msg) }
|
|
),
|
|
code_exprn__place_var_2(Stat, Var, Lval, Code).
|
|
|
|
:- pred code_exprn__place_var_2(var_stat, var, lval, code_tree,
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__place_var_2(in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__place_var_2(cached(Exprn0), Var, Lval, Code) -->
|
|
code_exprn__get_vars(Vars0),
|
|
(
|
|
{ exprn_aux__vars_in_rval(Exprn0, []) }
|
|
->
|
|
{ error("code_exprn__place_var: cached exprn with no vars!") }
|
|
;
|
|
code_exprn__get_options(ExprnOpts),
|
|
{ code_exprn__expr_is_constant(Exprn0, Vars0,
|
|
ExprnOpts, Exprn) }
|
|
->
|
|
% move stuff out of the way
|
|
% Since Exprn is a constant, it can't refer
|
|
% to the variable(s) being moved out of Lval.
|
|
code_exprn__clear_lval(Lval, Exprn, _Exprn, ClearCode),
|
|
% reserve the register
|
|
code_exprn__add_lval_reg_dependencies(Lval),
|
|
{ set__list_to_set([Exprn, lval(Lval)], Rvals) },
|
|
{ Stat = evaled(Rvals) },
|
|
code_exprn__get_var_name(Var, VarName),
|
|
{ string__append("Assigning from ", VarName, Comment) },
|
|
{ ExprnCode = node([
|
|
assign(Lval, Exprn) - Comment
|
|
]) }
|
|
;
|
|
% if the variable already has its value stored in the
|
|
% right place, we don't need to generate any code
|
|
{ Exprn0 = var(Var1) },
|
|
code_exprn__get_vars(Vars0),
|
|
{ map__search(Vars0, Var1, Stat0) },
|
|
{ Stat0 = evaled(VarRvals) },
|
|
{ set__member(lval(Lval), VarRvals) }
|
|
->
|
|
{ ClearCode = empty },
|
|
{ ExprnCode = empty },
|
|
code_exprn__add_lval_reg_dependencies(Lval),
|
|
{ set__singleton_set(LvalSet, lval(Lval)) },
|
|
{ Stat = evaled(LvalSet) }
|
|
;
|
|
% move stuff out of the way
|
|
code_exprn__clear_lval(Lval, Exprn0, Exprn1, ClearCode),
|
|
% reserve the register
|
|
code_exprn__add_lval_reg_dependencies(Lval),
|
|
{ exprn_aux__vars_in_rval(Exprn1, VarList) },
|
|
code_exprn__produce_vars(VarList, VarLocList, Code0),
|
|
code_exprn__rem_rval_reg_dependencies(Exprn1),
|
|
{ exprn_aux__substitute_vars_in_rval(VarLocList,
|
|
Exprn1, Exprn) },
|
|
code_exprn__add_rval_reg_dependencies(Exprn),
|
|
{ set__list_to_set([Exprn, lval(Lval)], Rvals) },
|
|
{ Stat = evaled(Rvals) },
|
|
code_exprn__get_var_name(Var, VarName),
|
|
code_exprn__construct_code(Lval, VarName, Exprn, Code1),
|
|
{ ExprnCode = tree(Code0, Code1) }
|
|
),
|
|
code_exprn__get_vars(Vars1),
|
|
{ map__set(Vars1, Var, Stat, Vars) },
|
|
code_exprn__set_vars(Vars),
|
|
{ Code = tree(ClearCode, ExprnCode) }.
|
|
|
|
code_exprn__place_var_2(evaled(Rvals0), Var, Lval, Code) -->
|
|
code_exprn__get_vars(Vars0),
|
|
(
|
|
{ set__member(lval(Lval), Rvals0) }
|
|
->
|
|
{ ClearCode = empty },
|
|
{ ExprnCode = empty },
|
|
{ Stat = evaled(Rvals0) }
|
|
;
|
|
{ set__to_sorted_list(Rvals0, RvalList) },
|
|
{ code_exprn__select_rval(RvalList, Rval0) },
|
|
{
|
|
Rval0 = lval(reg(_))
|
|
;
|
|
Rval0 = lval(stackvar(_))
|
|
;
|
|
Rval0 = lval(framevar(_))
|
|
}
|
|
->
|
|
% move stuff out of the way
|
|
code_exprn__clear_lval(Lval, Rval0, Rval, ClearCode),
|
|
% reserve the register
|
|
code_exprn__add_lval_reg_dependencies(Lval),
|
|
code_exprn__get_var_rvals(Var, Rvals1),
|
|
{ set__insert(Rvals1, lval(Lval), Rvals) },
|
|
{ Stat = evaled(Rvals) },
|
|
code_exprn__get_var_name(Var, VarName),
|
|
code_exprn__construct_code(Lval, VarName, Rval, ExprnCode)
|
|
;
|
|
{set__to_sorted_list(Rvals0, RvalList0) },
|
|
code_exprn__get_options(ExprnOpts),
|
|
{ code_exprn__member_expr_is_constant(RvalList0,
|
|
Vars0, ExprnOpts, Rval0) }
|
|
->
|
|
% move stuff out of the way
|
|
code_exprn__clear_lval(Lval, Rval0, Rval1, ClearCode),
|
|
% reserve the register
|
|
code_exprn__add_lval_reg_dependencies(Lval),
|
|
code_exprn__get_var_rvals(Var, Rvals1),
|
|
{ set__insert(Rvals1, lval(Lval), Rvals) },
|
|
{ Stat = evaled(Rvals) },
|
|
code_exprn__get_var_name(Var, VarName),
|
|
{ string__append("Assigning from ", VarName, Comment) },
|
|
{ ExprnCode = node([
|
|
assign(Lval, Rval1) - Comment
|
|
]) }
|
|
;
|
|
% choose one of the rvals from
|
|
% the old set, to avoid the
|
|
% potential issue-slot conflict
|
|
% unless the rval is a create,
|
|
% which is non-atomic so we must
|
|
% choose from the new set.
|
|
{ set__to_sorted_list(Rvals0, RvalList) },
|
|
{ code_exprn__select_rval(RvalList, Rval0) },
|
|
% move stuff out of the way
|
|
code_exprn__clear_lval(Lval, Rval0, Rval1, ClearCode),
|
|
% reserve the register
|
|
code_exprn__add_lval_reg_dependencies(Lval),
|
|
(
|
|
{ Rval1 = create(_, _, _) }
|
|
->
|
|
code_exprn__get_var_rvals(Var, Rvals7),
|
|
{ set__to_sorted_list(Rvals7, RvalList7) },
|
|
{ code_exprn__select_rval(RvalList7, Rval) }
|
|
;
|
|
{ Rval = Rval1 }
|
|
),
|
|
% Insert the destination into the
|
|
% rvals for the variable
|
|
code_exprn__get_var_rvals(Var, Rvals1),
|
|
{ set__insert(Rvals1, lval(Lval), Rvals) },
|
|
{ Stat = evaled(Rvals) },
|
|
code_exprn__get_var_name(Var, VarName),
|
|
code_exprn__construct_code(Lval, VarName, Rval, ExprnCode)
|
|
),
|
|
code_exprn__get_vars(Vars1),
|
|
{ map__set(Vars1, Var, Stat, Vars) },
|
|
code_exprn__set_vars(Vars),
|
|
{ Code = tree(ClearCode, ExprnCode) }.
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
% Move whatever is in Lval out of the way.
|
|
% It is possible that the value we want to put into Lval
|
|
% may need to refer to the value being moved out of Lval,
|
|
% e.g. as the base register of a field reference.
|
|
% To handle these correctly, we allow the caller to tell us
|
|
% the Rval0 that will go into Lval, and we adjust it as necessary
|
|
% before returning it as Rval.
|
|
|
|
:- pred code_exprn__clear_lval(lval, rval, rval,
|
|
code_tree, exprn_info, exprn_info).
|
|
:- mode code_exprn__clear_lval(in, in, out, out, in, out) is det.
|
|
|
|
code_exprn__clear_lval(Lval, Rval0, Rval, Code) -->
|
|
(
|
|
code_exprn__get_vars(Vars0),
|
|
{ code_exprn__lval_in_use(Lval, Vars0) }
|
|
->
|
|
code_exprn__get_spare_reg(Reg),
|
|
{ map__to_assoc_list(Vars0, VarsList0) },
|
|
code_exprn__relocate_lval(VarsList0, Lval, reg(Reg), VarsList),
|
|
{ map__from_assoc_list(VarsList, Vars) },
|
|
code_exprn__set_vars(Vars),
|
|
{ exprn_aux__substitute_lval_in_rval(Lval, reg(Reg),
|
|
Rval0, Rval) },
|
|
{ Code = node([
|
|
assign(reg(Reg), lval(Lval)) -
|
|
"shuffle lval"
|
|
]) }
|
|
;
|
|
{ Rval = Rval0 },
|
|
{ Code = empty }
|
|
).
|
|
|
|
:- pred code_exprn__relocate_lval(assoc_list(var, var_stat), lval, lval,
|
|
assoc_list(var, var_stat), exprn_info, exprn_info).
|
|
:- mode code_exprn__relocate_lval(in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__relocate_lval([], _OldVal, _NewVal, []) --> [].
|
|
code_exprn__relocate_lval([V - Stat0|Rest0], OldVal,
|
|
NewVal, [V - Stat|Rest]) -->
|
|
(
|
|
{ Stat0 = cached(Exprn0) },
|
|
(
|
|
{ exprn_aux__rval_contains_lval(Exprn0, OldVal) }
|
|
->
|
|
code_exprn__rem_rval_reg_dependencies(Exprn0),
|
|
{ exprn_aux__substitute_lval_in_rval(OldVal, NewVal,
|
|
Exprn0, Exprn) },
|
|
code_exprn__add_rval_reg_dependencies(Exprn),
|
|
{ Stat = cached(Exprn) }
|
|
;
|
|
{ Stat = Stat0 }
|
|
)
|
|
;
|
|
{ Stat0 = evaled(Rvals0) },
|
|
{ set__to_sorted_list(Rvals0, RvalsList0) },
|
|
code_exprn__relocate_lval_2(RvalsList0, OldVal,
|
|
NewVal, RvalsList),
|
|
{ set__sorted_list_to_set(RvalsList, Rvals) },
|
|
{ Stat = evaled(Rvals) }
|
|
),
|
|
code_exprn__relocate_lval(Rest0, OldVal, NewVal, Rest).
|
|
|
|
:- pred code_exprn__relocate_lval_2(list(rval), lval, lval, list(rval),
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__relocate_lval_2(in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__relocate_lval_2([], _OldVal, _NewVal, []) --> [].
|
|
code_exprn__relocate_lval_2([R0|Rs0], OldVal, NewVal, [R|Rs]) -->
|
|
(
|
|
{ exprn_aux__rval_contains_lval(R0, OldVal) }
|
|
->
|
|
code_exprn__rem_rval_reg_dependencies(R0),
|
|
{ exprn_aux__substitute_lval_in_rval(OldVal, NewVal, R0, R) },
|
|
code_exprn__add_rval_reg_dependencies(R)
|
|
;
|
|
{ R = R0 }
|
|
),
|
|
code_exprn__relocate_lval_2(Rs0, OldVal, NewVal, Rs).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__construct_code(lval, string, rval, code_tree,
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__construct_code(in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__construct_code(Lval, VarName, Rval0, Code) -->
|
|
{ exprn_aux__simplify_rval(Rval0, Rval) },
|
|
(
|
|
{ Rval = create(Tag, Rvals, _Label) }
|
|
->
|
|
{ list__length(Rvals, Arity) },
|
|
(
|
|
{ Arity = 0 }
|
|
->
|
|
{ Code = node([
|
|
assign(Lval, mkword(Tag, const(int_const(0)))) -
|
|
"Construct constant"
|
|
]) }
|
|
;
|
|
( { Lval = field(_, _, _) } ->
|
|
code_exprn__acquire_reg(Reg),
|
|
code_exprn__construct_cell(reg(Reg),
|
|
VarName, Tag, Arity, Rvals, Code0),
|
|
{ string__append(VarName, " placement",
|
|
Comment) },
|
|
{ Code1 = node([
|
|
assign(Lval, lval(reg(Reg))) - Comment
|
|
]) },
|
|
{ Code = tree(Code0, Code1) },
|
|
code_exprn__release_reg(Reg)
|
|
;
|
|
code_exprn__construct_cell(Lval,
|
|
VarName, Tag, Arity, Rvals, Code)
|
|
)
|
|
)
|
|
;
|
|
{ string__append("Assigning from ", VarName, Comment) },
|
|
{ Code = node([
|
|
assign(Lval, Rval) - Comment
|
|
]) }
|
|
).
|
|
|
|
:- pred code_exprn__construct_cell(lval, string, tag, int, list(maybe(rval)),
|
|
code_tree, exprn_info, exprn_info).
|
|
:- mode code_exprn__construct_cell(in, in, in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__construct_cell(Lval, VarName, Tag, Arity, Rvals, Code) -->
|
|
{ string__append("Allocating heap for ", VarName, Comment) },
|
|
{ Code0 = node([
|
|
incr_hp(Lval, yes(Tag), const(int_const(Arity))) - Comment
|
|
]) },
|
|
code_exprn__construct_args(Rvals, Tag, Lval, 0, Code1),
|
|
{ Code = tree(Code0, Code1) }.
|
|
|
|
:- pred code_exprn__construct_args(list(maybe(rval)), int, lval, int,
|
|
code_tree, exprn_info, exprn_info).
|
|
:- mode code_exprn__construct_args(in, in, in, in, out, in, out) is det.
|
|
|
|
code_exprn__construct_args([], _, _, _, empty) --> [].
|
|
code_exprn__construct_args([R|Rs], Tag, Lval, N0, Code) -->
|
|
(
|
|
{ R = yes(Rval) }
|
|
->
|
|
% XXX the "" is a bug
|
|
code_exprn__construct_code(
|
|
field(Tag, lval(Lval), const(int_const(N0))),
|
|
"", Rval, Code0)
|
|
;
|
|
{ Code0 = empty }
|
|
),
|
|
{ N1 is N0 + 1 },
|
|
{ Code = tree(Code0, Code1) },
|
|
code_exprn__construct_args(Rs, Tag, Lval, N1, Code1).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__get_var_rvals(var, set(rval), exprn_info, exprn_info).
|
|
:- mode code_exprn__get_var_rvals(in, out, in, out) is det.
|
|
|
|
code_exprn__get_var_rvals(Var, Rvals) -->
|
|
code_exprn__get_vars(Vars),
|
|
{ map__lookup(Vars, Var, Stat) },
|
|
(
|
|
{ Stat = evaled(Rvals0) },
|
|
{ Rvals = Rvals0 }
|
|
;
|
|
{ Stat = cached(Rval0) },
|
|
{ set__singleton_set(Rvals, Rval0) }
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__produce_var(Var, Rval, Code) -->
|
|
code_exprn__get_vars(Vars0),
|
|
{ map__lookup(Vars0, Var, Stat0) },
|
|
(
|
|
{ Stat0 = evaled(Rvals) },
|
|
\+ (
|
|
{ set__member(RvalX, Rvals) },
|
|
{ RvalX = binop(_, _, _) ;
|
|
RvalX = unop(_, _) ;
|
|
RvalX = create(_, _, _) ;
|
|
RvalX = mkword(_, _)
|
|
}
|
|
)
|
|
->
|
|
{ set__to_sorted_list(Rvals, RvalList) },
|
|
{ code_exprn__select_rval(RvalList, Rval) },
|
|
{ Code = empty }
|
|
;
|
|
code_exprn__get_spare_reg(Reg),
|
|
{ Lval = reg(Reg) },
|
|
{ Rval = lval(Lval) },
|
|
code_exprn__place_var(Var, Lval, Code)
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__produce_var_in_reg(Var, Rval, Code) -->
|
|
code_exprn__produce_var(Var, Rval0, Code0),
|
|
(
|
|
{ Rval0 = lval(reg(_)) }
|
|
->
|
|
{ Code = Code0 },
|
|
{ Rval = Rval0 }
|
|
;
|
|
code_exprn__get_spare_reg(Reg),
|
|
{ Lval = reg(Reg) },
|
|
{ Rval = lval(Lval) },
|
|
code_exprn__place_var(Var, Lval, Code1),
|
|
{ Code = tree(Code0, Code1) }
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__produce_vars(list(var), assoc_list(var, rval), code_tree,
|
|
exprn_info, exprn_info).
|
|
:- mode code_exprn__produce_vars(in, out, out, in, out) is det.
|
|
|
|
code_exprn__produce_vars([], [], empty) --> [].
|
|
code_exprn__produce_vars([V|Vs], [V - R|Rest], Code) -->
|
|
code_exprn__produce_var(V, R, Code0),
|
|
code_exprn__produce_vars(Vs, Rest, Code1),
|
|
{ Code = tree(Code0, Code1) }.
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__acquire_reg(Reg) -->
|
|
code_exprn__get_spare_reg(Reg),
|
|
code_exprn__get_regs(Regs0),
|
|
{ bag__insert(Regs0, Reg, Regs) },
|
|
code_exprn__set_regs(Regs),
|
|
code_exprn__get_acquired(Acqu0),
|
|
{ set__insert(Acqu0, Reg, Acqu) },
|
|
code_exprn__set_acquired(Acqu).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
% Warning: if you get a reg, you must mark it as in use yourself.
|
|
|
|
:- pred code_exprn__get_spare_reg(reg, exprn_info, exprn_info).
|
|
:- mode code_exprn__get_spare_reg(out, in, out) is det.
|
|
|
|
code_exprn__get_spare_reg(Reg) -->
|
|
code_exprn__get_regs(Regs),
|
|
{ code_exprn__get_spare_reg_2(1, Regs, Reg) }.
|
|
|
|
:- pred code_exprn__get_spare_reg_2(int, bag(reg), reg).
|
|
:- mode code_exprn__get_spare_reg_2(in, in, out) is det.
|
|
|
|
code_exprn__get_spare_reg_2(N0, Regs, Reg) :-
|
|
Reg0 = r(N0),
|
|
(
|
|
bag__contains(Reg0, Regs)
|
|
->
|
|
N1 is N0 + 1,
|
|
code_exprn__get_spare_reg_2(N1, Regs, Reg)
|
|
;
|
|
Reg = Reg0
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__release_reg(Reg) -->
|
|
code_exprn__get_acquired(Acqu0),
|
|
(
|
|
{ set__member(Reg, Acqu0) }
|
|
->
|
|
{ set__delete(Acqu0, Reg, Acqu) },
|
|
code_exprn__set_acquired(Acqu),
|
|
code_exprn__get_regs(Regs0),
|
|
{ bag__remove(Regs0, Reg, Regs) },
|
|
(
|
|
{ bag__contains(Reg, Regs) }
|
|
->
|
|
{ error("code_exprn__release_reg: reg still has references") }
|
|
;
|
|
[]
|
|
),
|
|
code_exprn__set_regs(Regs)
|
|
;
|
|
{ error("code_exprn__release_reg: attempt to release an unacquired reg") }
|
|
).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
code_exprn__lock_reg(Reg) -->
|
|
code_exprn__get_regs(Regs0),
|
|
{ bag__insert(Regs0, Reg, Regs) },
|
|
code_exprn__set_regs(Regs).
|
|
|
|
code_exprn__unlock_reg(Reg) -->
|
|
code_exprn__get_regs(Regs0),
|
|
{ bag__remove(Regs0, Reg, Regs) },
|
|
code_exprn__set_regs(Regs).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__get_var_name(var, string, exprn_info, exprn_info).
|
|
:- mode code_exprn__get_var_name(in, out, in, out) is det.
|
|
|
|
code_exprn__get_var_name(Var, Name) -->
|
|
code_exprn__get_varset(Varset),
|
|
{ varset__lookup_name(Varset, Var, Name) }.
|
|
|
|
%------------------------------------------------------------------------------%
|
|
|
|
:- pred code_exprn__get_varset(varset, exprn_info, exprn_info).
|
|
:- mode code_exprn__get_varset(out, in, out) is det.
|
|
|
|
:- pred code_exprn__set_varset(varset, exprn_info, exprn_info).
|
|
:- mode code_exprn__set_varset(in, in, out) is det.
|
|
|
|
:- pred code_exprn__get_vars(var_map, exprn_info, exprn_info).
|
|
:- mode code_exprn__get_vars(out, in, out) is det.
|
|
|
|
:- pred code_exprn__set_vars(var_map, exprn_info, exprn_info).
|
|
:- mode code_exprn__set_vars(in, in, out) is det.
|
|
|
|
:- pred code_exprn__get_regs(bag(reg), exprn_info, exprn_info).
|
|
:- mode code_exprn__get_regs(out, in, out) is det.
|
|
|
|
:- pred code_exprn__set_regs(bag(reg), exprn_info, exprn_info).
|
|
:- mode code_exprn__set_regs(in, in, out) is det.
|
|
|
|
:- pred code_exprn__get_acquired(set(reg), exprn_info, exprn_info).
|
|
:- mode code_exprn__get_acquired(out, in, out) is det.
|
|
|
|
:- pred code_exprn__set_acquired(set(reg), exprn_info, exprn_info).
|
|
:- mode code_exprn__set_acquired(in, in, out) is det.
|
|
|
|
:- pred code_exprn__get_options(exprn_opts, exprn_info, exprn_info).
|
|
:- mode code_exprn__get_options(out, in, out) is det.
|
|
|
|
code_exprn__get_varset(Varset, ExprnInfo, ExprnInfo) :-
|
|
ExprnInfo = exprn_info(Varset, _Vars, _Regs, _Acqu, _Opt).
|
|
|
|
code_exprn__set_varset(Varset, ExprnInfo0, ExprnInfo) :-
|
|
ExprnInfo0 = exprn_info(_Varset, Vars, Regs, Acqu, Opt),
|
|
ExprnInfo = exprn_info(Varset, Vars, Regs, Acqu, Opt).
|
|
|
|
code_exprn__get_vars(Vars, ExprnInfo, ExprnInfo) :-
|
|
ExprnInfo = exprn_info(_Varset, Vars, _Regs, _Acqu, _Opt).
|
|
|
|
code_exprn__set_vars(Vars, ExprnInfo0, ExprnInfo) :-
|
|
ExprnInfo0 = exprn_info(Varset, _Vars, Regs, Acqu, Opt),
|
|
ExprnInfo = exprn_info(Varset, Vars, Regs, Acqu, Opt).
|
|
|
|
code_exprn__get_regs(Regs, ExprnInfo, ExprnInfo) :-
|
|
ExprnInfo = exprn_info(_Varset, _Vars, Regs, _Acqu, _Opt).
|
|
|
|
code_exprn__set_regs(Regs, ExprnInfo0, ExprnInfo) :-
|
|
ExprnInfo0 = exprn_info(Varset, Vars, _Regs, Acqu, Opt),
|
|
ExprnInfo = exprn_info(Varset, Vars, Regs, Acqu, Opt).
|
|
|
|
code_exprn__get_acquired(Acqu, ExprnInfo, ExprnInfo) :-
|
|
ExprnInfo = exprn_info(_Varset, _Vars, _Regs, Acqu, _Opt).
|
|
|
|
code_exprn__set_acquired(Acqu, ExprnInfo0, ExprnInfo) :-
|
|
ExprnInfo0 = exprn_info(Varset, Vars, Regs, _Acqu, Opt),
|
|
ExprnInfo = exprn_info(Varset, Vars, Regs, Acqu, Opt).
|
|
|
|
code_exprn__get_options(Opt, ExprnInfo, ExprnInfo) :-
|
|
ExprnInfo = exprn_info(_Varset, _Vars, _Regs, _Acqu, Opt).
|
|
|
|
%------------------------------------------------------------------------------%
|
|
%------------------------------------------------------------------------------%
|