mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-16 22:35:41 +00:00
d609181cb9
Estimated hours taken: 30
Branches: main
Consider types of the form
:- type x ---> f.
to be dummy types, since they contain no information. Optimize them the same
way we currently optimize io.state and store.store.
runtime/mercury_type_info.h:
Add a new type_ctor_rep for dummy types.
runtime/mercury_tabling.h:
Add a representation for "tabled" dummy types, which don't actually
have a level in the trie, so that the runtime system can handle that
fact.
runtime/mercury_ml_expand_body.h:
When deconstructing a value of a dummy type, ignore the actual value
(since it will contain garbage) and instead return the only possible
value of the type.
runtime/mercury_construct.c:
runtime/mercury_deconstruct.c:
runtime/mercury_deep_copy_body.c:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
library/rtti_implementation.m:
Handle the type_ctor_rep of dummy types.
runtime/mercury_builtin_types.c:
Provide a place to record profiling information about unifications and
comparisons for dummy types.
runtime/mercury_mcpp.h:
java/runtime/TypeCtorRep.java:
library/private_builtin.m:
Add a new type_ctor_rep for dummy types, and fix some previous
discrepancies in type_ctor_reps.
mdbcomp/prim_data.m:
Move a bunch of predicates for manipulating special_pred_ids here from
the browser and compiler directories.
Rename the function symbols of the special_pred_id type to avoid the
need to parenthesize the old `initialise' function symbol.
Convert to four-space indentation.
mdbcomp/rtti_access.m:
Don't hardcode the names of special preds: use the predicates in
prim_data.m.
Convert to four-space indentation.
browser/declarative_execution.m:
Delete some predicates whose functionality is now in
mdbcomp/prim_data.m.
compiler/hlds_data.m:
Replace the part of du type that says whether a type an enum, which
used to be a bool, with something that also says whether the type is a
dummy type.
Convert to four-space indentation.
compiler/make_tags.m:
Compute the value for the new field of du type definitions.
compiler/hlds_out.m:
Write out the new field of du type definitions.
compiler/rtti.m:
Modify the data structures we use to create type_ctor_infos to allow
for dummy types.
Convert to four-space indentation.
compiler/type_ctor_info.m:
Modify the code that generates type_ctor_infos to handle dummy types.
compiler/type_util.m:
Provide predicates for recognizing dummy types.
Convert to four-space indentation.
compiler/unify_proc.m:
Generate the unify and compare predicates of dummy types using a new
code scheme that avoids referencing arguments that contain garbage.
When generating code for unifying or comparing other types, ignore
any arguments of function symbols that are dummy types.
Don't use DCG style access predicates.
compiler/higher_order.m:
Specialize the unification and comparison of values of dummy types.
Break up an excessively large predicate, and factor out common code
from the conditions of a chain of if-then-elses.
compiler/llds.m:
For each input and output of a foreign_proc, include a field saying
whether the value is of a dummy type.
compiler/pragma_c_gen.m:
Fill in the new fields in foreign_proc arguments.
compiler/hlds_goal.m:
Rename some predicates for constructing unifications to avoid
unnecessary ad-hoc overloading. Clarify their documentation.
Rename a predicate to make clear the restriction on its use,
and document the restriction.
Add a predicate for creating simple tests.
Add a utility predicate for setting the context of a goal directly.
compiler/modules.m:
Include dummy types interface files, even if they are private to the
module. This is necessary because with the MLDS backend, the generated
code inside the module and outside the module must agree whether a
function returning a value of the type returns a real value or a void
value, and this requires them to agree on whether the type is dummy
or not.
The impact on interface files is minimal, since very few types are
dummy types, and changing a type from a dummy type to a non-dummy type
or vice versa is an ever rarer change.
compiler/hlds_pred.m:
Provide a representation in the compiler of the trie step for dummy
types.
compiler/layout_out.m:
Print the trie step for dummy types.
compiler/table_gen.m:
Don't table values of dummy types, and record the fact that we don't
by including a dummy trie step in the list of trie steps.
compiler/add_pragma.m:
compiler/add_special_pred.m:
compiler/add_type.m:
compiler/aditi_builtin_ops.m:
compiler/bytecode.m:
compiler/bytecode_gen.m:
compiler/code_gen.m:
compiler/code_info.m:
compiler/continuation_info.m:
compiler/cse_detection.m:
compiler/det_report.m:
compiler/exception_analysis.m:
compiler/inst_match.m:
compiler/livemap.m:
compiler/llds_out.m:
compiler/llds_out.m:
compiler/middle_rec.m:
compiler/ml_call_gen.m:
compiler/ml_closure_gen.m:
compiler/ml_code_gen.m:
compiler/ml_code_util.m:
compiler/ml_type_gen.m:
compiler/ml_unify_gen.m:
compiler/mlds_to_c.m:
compiler/mlds_to_gcc.m:
compiler/mlds_to_il.m:
compiler/mlds_to_il.m:
compiler/modecheck_unify.m:
compiler/modes.m:
compiler/opt_util.m:
compiler/post_term_analysis.m:
compiler/post_typecheck.m:
compiler/qual_info.m:
compiler/rl.m:
compiler/rl_exprn.m:
compiler/rl_key.m:
compiler/rtti_out.m:
compiler/simplify.m:
compiler/size_prof.m:
compiler/term_constr_initial.m:
compiler/term_constr_util.m:
compiler/term_norm.m:
compiler/termination.m:
compiler/trace.m:
compiler/typecheck.m:
compiler/unify_gen.m:
Conform to the changes above.
compiler/export.m:
compiler/exprn_aux.m:
compiler/foreign.m:
compiler/polymorphism.m:
compiler/proc_label.m:
compiler/rtti_to_mlds.m:
compiler/special_pred.m:
compiler/stack_alloc.m:
compiler/stack_layout.m:
compiler/state_var.m:
compiler/switch_util.m:
compiler/trace_params.m:
Conform to the changes above.
Convert to four-space indentation.
compiler/mlds_to_java.m:
compiler/var_locn.m:
Conform to the changes above, which requires threading the module_info
through the module.
Convert to four-space indentation.
compiler/mercury_compile.m:
Pass the module_info to mlds_to_java.m.
compiler/ml_util.m:
compiler/polymorphism.m:
compiler/type_ctor_info.m:
compiler/type_util.m:
Delete some previously missed references to the temporary types used
to bootstrap the change to the type_info type's arity.
compiler/polymorphism.m:
Turn back on an optimization that avoids passing parameters (such as
type_infos) to foreign_procs if they are not actually referred to.
compiler/prog_data.m:
Convert to four-space indentation.
library/svvarset.m:
Add a missing predicate.
trace/mercury_trace.c:
Delete the unused function that used to check for dummy types.
tests/debugger/field_names.{m,inp,exp}:
Add to this test case a test of the handling of dummy types. Check that
their values can be printed out during normal execution, and that the
debugger doesn't consider them live nondummy variables, just as it
doesn't consider I/O states live nondummy variables.
477 lines
17 KiB
Mathematica
477 lines
17 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1995-2005 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.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% File: livemap.m
|
|
%
|
|
% Main author: zs.
|
|
%
|
|
% This module builds up a map that gives the set of live lvals at each label.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module ll_backend__livemap.
|
|
|
|
:- interface.
|
|
|
|
:- import_module ll_backend__llds.
|
|
|
|
:- import_module list.
|
|
:- import_module map.
|
|
:- import_module set.
|
|
:- import_module std_util.
|
|
|
|
:- type livemap == map(label, lvalset).
|
|
:- type lvalset == set(lval).
|
|
|
|
% Given a list of instructions defining a procedure, return a map
|
|
% giving the set of live non-field lvals at each label.
|
|
%
|
|
% We can compute this set only if the procedure contains no C code.
|
|
%
|
|
:- pred livemap__build(list(instruction)::in, maybe(livemap)::out) is det.
|
|
|
|
:- implementation.
|
|
|
|
:- import_module parse_tree__error_util.
|
|
:- import_module ll_backend__opt_util.
|
|
|
|
:- import_module bool.
|
|
:- import_module require.
|
|
:- import_module string.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% The method we follow is a backward scan of the instruction list,
|
|
% keeping track of the set of live lvals as we go. We update this set
|
|
% at each instruction. When we get to a label, we know that this set
|
|
% of lvals is live at that label.
|
|
%
|
|
% At instructions that can branch away, every lval that is live at
|
|
% any possible target is live before that instruction. Since some
|
|
% branches may be backward branches, we may not have seen the branch
|
|
% target when we process the branch. Therefore we have to repeat the
|
|
% scan, this time with more knowledge about more labels, until we
|
|
% get to a fixpoint.
|
|
|
|
livemap__build(Instrs, MaybeLivemap) :-
|
|
map__init(Livemap0),
|
|
list__reverse(Instrs, BackInstrs),
|
|
livemap__build_2(BackInstrs, Livemap0, MaybeLivemap).
|
|
|
|
:- pred livemap__build_2(list(instruction)::in, livemap::in,
|
|
maybe(livemap)::out) is det.
|
|
|
|
livemap__build_2(Backinstrs, Livemap0, MaybeLivemap) :-
|
|
set__init(Livevals0),
|
|
livemap__build_livemap(Backinstrs, Livevals0, no, ContainsUserCode,
|
|
Livemap0, Livemap1),
|
|
( ContainsUserCode = yes ->
|
|
MaybeLivemap = no
|
|
; livemap__equal_livemaps(Livemap0, Livemap1) ->
|
|
MaybeLivemap = yes(Livemap1)
|
|
;
|
|
livemap__build_2(Backinstrs, Livemap1, MaybeLivemap)
|
|
).
|
|
|
|
% Check whether the two livemaps agree on the set of live lvals
|
|
% at every label. They must agree on the set of labels as well.
|
|
% This is important. Livemap1 will be empty in the first call,
|
|
% so agreement only on the set of labels in Livemap1 is useless.
|
|
% The domain of Livemap2 should always be every label in the procedure.
|
|
% as should the domain of Livemap1 in every call after the first.
|
|
%
|
|
:- pred livemap__equal_livemaps(livemap::in, livemap::in) is semidet.
|
|
|
|
livemap__equal_livemaps(Livemap1, Livemap2) :-
|
|
map__keys(Livemap1, Labels),
|
|
map__keys(Livemap2, Labels),
|
|
livemap__equal_livemaps_keys(Labels, Livemap1, Livemap2).
|
|
|
|
:- pred livemap__equal_livemaps_keys(list(label)::in, livemap::in, livemap::in)
|
|
is semidet.
|
|
|
|
livemap__equal_livemaps_keys([], _Livemap1, _Livemap2).
|
|
livemap__equal_livemaps_keys([Label | Labels], Livemap1, Livemap2) :-
|
|
map__lookup(Livemap1, Label, Liveset1),
|
|
map__lookup(Livemap2, Label, Liveset2),
|
|
set__equal(Liveset1, Liveset2),
|
|
livemap__equal_livemaps_keys(Labels, Livemap1, Livemap2).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Build up a map of what lvals are live at each label.
|
|
% The input instruction sequence is reversed.
|
|
%
|
|
:- pred livemap__build_livemap(list(instruction)::in, lvalset::in,
|
|
bool::in, bool::out, livemap::in, livemap::out) is det.
|
|
|
|
livemap__build_livemap([], _, !ContainsUserCode, !Livemap).
|
|
livemap__build_livemap([Instr0 | Instrs0], Livevals0,
|
|
!ContainsUserCode, !Livemap) :-
|
|
livemap__build_livemap_instr(Instr0, Instrs0, Instrs1,
|
|
Livevals0, Livevals1, !ContainsUserCode, !Livemap),
|
|
livemap__build_livemap(Instrs1, Livevals1, !ContainsUserCode, !Livemap).
|
|
|
|
:- pred livemap__build_livemap_instr(instruction::in, list(instruction)::in,
|
|
list(instruction)::out, lvalset::in, lvalset::out,
|
|
bool::in, bool::out, livemap::in, livemap::out) is det.
|
|
|
|
livemap__build_livemap_instr(Instr0, !Instrs, !Livevals, !ContainsUserCode,
|
|
!Livemap) :-
|
|
Instr0 = Uinstr0 - _,
|
|
(
|
|
Uinstr0 = comment(_)
|
|
;
|
|
Uinstr0 = livevals(_),
|
|
unexpected(this_file,
|
|
"livevals found in backward scan in build_livemap")
|
|
;
|
|
Uinstr0 = block(_, _, _),
|
|
unexpected(this_file, "block found in backward scan in build_livemap")
|
|
;
|
|
Uinstr0 = assign(Lval, Rval),
|
|
|
|
% Make dead the variable assigned, but make any variables
|
|
% needed to access it live. Make the variables in the assigned
|
|
% expression live as well.
|
|
% The deletion has to be done first. If the assigned-to lval
|
|
% appears on the right hand side as well as the left, then we
|
|
% want make_live to put it back into the liveval set.
|
|
|
|
set__delete(!.Livevals, Lval, !:Livevals),
|
|
opt_util__lval_access_rvals(Lval, Rvals),
|
|
livemap__make_live_in_rvals([Rval | Rvals], !Livevals)
|
|
;
|
|
Uinstr0 = call(_, _, _, _, _, _),
|
|
livemap__look_for_livevals(!Instrs, !Livevals, "call", yes, _)
|
|
;
|
|
Uinstr0 = mkframe(_, _)
|
|
;
|
|
Uinstr0 = label(Label),
|
|
map__set(!.Livemap, Label, !.Livevals, !:Livemap)
|
|
;
|
|
Uinstr0 = goto(CodeAddr),
|
|
opt_util__livevals_addr(CodeAddr, LivevalsNeeded),
|
|
livemap__look_for_livevals(!Instrs, !Livevals, "goto",
|
|
LivevalsNeeded, Found),
|
|
( Found = yes ->
|
|
true
|
|
; CodeAddr = label(Label) ->
|
|
livemap__insert_label_livevals(!.Livemap, Label,
|
|
set__init, !:Livevals)
|
|
;
|
|
( CodeAddr = do_redo
|
|
; CodeAddr = do_fail
|
|
; CodeAddr = do_not_reached
|
|
)
|
|
->
|
|
true
|
|
;
|
|
unexpected(this_file, "unknown label type in build_livemap")
|
|
),
|
|
livemap__special_code_addr(CodeAddr, MaybeSpecial),
|
|
(
|
|
MaybeSpecial = yes(Special),
|
|
set__insert(!.Livevals, Special, !:Livevals)
|
|
;
|
|
MaybeSpecial = no
|
|
)
|
|
;
|
|
Uinstr0 = computed_goto(Rval, Labels),
|
|
livemap__make_live_in_rvals([Rval], set__init, !:Livevals),
|
|
list__foldl(livemap__insert_label_livevals(!.Livemap), Labels,
|
|
!Livevals)
|
|
;
|
|
Uinstr0 = if_val(Rval, CodeAddr),
|
|
Livevals0 = !.Livevals,
|
|
livemap__look_for_livevals(!Instrs, !Livevals, "if_val", no, Found),
|
|
(
|
|
Found = yes,
|
|
% This if_val was put here by middle_rec.
|
|
% We must make sure that the locations mentioned
|
|
% in the livevals annotation become live,
|
|
% since they will be needed at CodeAddr.
|
|
% The locations in Livevals0 may be needed
|
|
% in the fall-through continuation.
|
|
set__union(Livevals0, !Livevals)
|
|
;
|
|
Found = no,
|
|
livemap__make_live_in_rvals([Rval], !Livevals),
|
|
( CodeAddr = label(Label) ->
|
|
livemap__insert_label_livevals(!.Livemap, Label, !Livevals)
|
|
;
|
|
true
|
|
)
|
|
),
|
|
livemap__special_code_addr(CodeAddr, MaybeSpecial),
|
|
(
|
|
MaybeSpecial = yes(Special),
|
|
set__insert(!.Livevals, Special, !:Livevals)
|
|
;
|
|
MaybeSpecial = no
|
|
)
|
|
;
|
|
Uinstr0 = save_maxfr(Lval),
|
|
set__delete(!.Livevals, Lval, !:Livevals),
|
|
opt_util__lval_access_rvals(Lval, Rvals),
|
|
livemap__make_live_in_rvals(Rvals, !Livevals)
|
|
;
|
|
Uinstr0 = restore_maxfr(Lval),
|
|
livemap__make_live_in_rval(lval(Lval), !Livevals)
|
|
;
|
|
Uinstr0 = incr_hp(Lval, _, _, Rval, _),
|
|
|
|
% Make dead the variable assigned, but make any variables
|
|
% needed to access it live. Make the variables in the size
|
|
% expression live as well.
|
|
% The use of the size rval occurs after the assignment
|
|
% to lval, but the two should never have any variables in
|
|
% common. This is why doing the deletion first works.
|
|
|
|
set__delete(!.Livevals, Lval, !:Livevals),
|
|
opt_util__lval_access_rvals(Lval, Rvals),
|
|
livemap__make_live_in_rvals([Rval | Rvals], !Livevals)
|
|
;
|
|
Uinstr0 = mark_hp(Lval),
|
|
set__delete(!.Livevals, Lval, !:Livevals),
|
|
opt_util__lval_access_rvals(Lval, Rvals),
|
|
livemap__make_live_in_rvals(Rvals, !Livevals)
|
|
;
|
|
Uinstr0 = restore_hp(Rval),
|
|
livemap__make_live_in_rvals([Rval], !Livevals)
|
|
;
|
|
Uinstr0 = free_heap(Rval),
|
|
livemap__make_live_in_rvals([Rval], !Livevals)
|
|
;
|
|
Uinstr0 = store_ticket(Lval),
|
|
set__delete(!.Livevals, Lval, !:Livevals),
|
|
opt_util__lval_access_rvals(Lval, Rvals),
|
|
livemap__make_live_in_rvals(Rvals, !Livevals)
|
|
;
|
|
Uinstr0 = reset_ticket(Rval, _Reason),
|
|
livemap__make_live_in_rval(Rval, !Livevals)
|
|
;
|
|
Uinstr0 = discard_ticket
|
|
;
|
|
Uinstr0 = prune_ticket
|
|
;
|
|
Uinstr0 = mark_ticket_stack(Lval),
|
|
set__delete(!.Livevals, Lval, !:Livevals),
|
|
opt_util__lval_access_rvals(Lval, Rvals),
|
|
livemap__make_live_in_rvals(Rvals, !Livevals)
|
|
;
|
|
Uinstr0 = prune_tickets_to(Rval),
|
|
livemap__make_live_in_rval(Rval, !Livevals)
|
|
;
|
|
Uinstr0 = incr_sp(_, _)
|
|
;
|
|
Uinstr0 = decr_sp(_)
|
|
;
|
|
Uinstr0 = decr_sp_and_return(_),
|
|
% These instructions should be generated only *after* any optimizations
|
|
% that need livemaps have been run for the last time.
|
|
unexpected(this_file, "build_livemap_instr: decr_sp_and_return")
|
|
;
|
|
Uinstr0 = init_sync_term(_, _)
|
|
;
|
|
Uinstr0 = fork(_, _, _)
|
|
;
|
|
Uinstr0 = join_and_terminate(_)
|
|
;
|
|
Uinstr0 = join_and_continue(_, _)
|
|
;
|
|
Uinstr0 = c_code(_, LiveLvalInfo),
|
|
livemap__build_live_lval_info(LiveLvalInfo,
|
|
!Livevals, !ContainsUserCode)
|
|
;
|
|
Uinstr0 = pragma_c(_, Components, _, _, _, _, _, _, _),
|
|
livemap__build_livemap_pragma_components(Components,
|
|
!Livevals, !ContainsUserCode)
|
|
).
|
|
|
|
:- pred livemap__build_livemap_pragma_components(list(pragma_c_component)::in,
|
|
lvalset::in, lvalset::out, bool::in, bool::out) is det.
|
|
|
|
livemap__build_livemap_pragma_components([], !Livevals, !ContainsUserCode).
|
|
livemap__build_livemap_pragma_components([Component | Components],
|
|
!Livevals, !ContainsUserCode) :-
|
|
(
|
|
Component = pragma_c_inputs(Inputs),
|
|
livemap__build_livemap_pragma_inputs(Inputs,
|
|
!Livevals)
|
|
;
|
|
Component = pragma_c_outputs(_)
|
|
;
|
|
Component = pragma_c_user_code(_, _),
|
|
!:ContainsUserCode = yes
|
|
;
|
|
Component = pragma_c_raw_code(_, _, LiveLvalInfo),
|
|
livemap__build_live_lval_info(LiveLvalInfo,
|
|
!Livevals, !ContainsUserCode)
|
|
;
|
|
Component = pragma_c_fail_to(_)
|
|
;
|
|
Component = pragma_c_noop
|
|
),
|
|
livemap__build_livemap_pragma_components(Components,
|
|
!Livevals, !ContainsUserCode).
|
|
|
|
:- pred livemap__build_live_lval_info(c_code_live_lvals::in,
|
|
lvalset::in, lvalset::out, bool::in, bool::out) is det.
|
|
|
|
livemap__build_live_lval_info(no_live_lvals_info, !Livevals, _, yes).
|
|
livemap__build_live_lval_info(live_lvals_info(LiveLvalSet), !Livevals,
|
|
!DontValueNumber) :-
|
|
set__to_sorted_list(LiveLvalSet, LiveLvals),
|
|
livemap__insert_proper_livevals(LiveLvals, !Livevals).
|
|
|
|
:- pred livemap__build_livemap_pragma_inputs(list(pragma_c_input)::in,
|
|
lvalset::in, lvalset::out) is det.
|
|
|
|
livemap__build_livemap_pragma_inputs([], !Livevals).
|
|
livemap__build_livemap_pragma_inputs([Input | Inputs], !Livevals) :-
|
|
Input = pragma_c_input(_, _, _, _, Rval, _),
|
|
( Rval = lval(Lval) ->
|
|
livemap__insert_proper_liveval(Lval, !Livevals)
|
|
;
|
|
true
|
|
),
|
|
livemap__build_livemap_pragma_inputs(Inputs, !Livevals).
|
|
|
|
:- pred livemap__look_for_livevals(list(instruction)::in,
|
|
list(instruction)::out, lvalset::in, lvalset::out, string::in,
|
|
bool::in, bool::out) is det.
|
|
|
|
livemap__look_for_livevals(Instrs0, Instrs, !Livevals,
|
|
Site, Compulsory, Found) :-
|
|
opt_util__skip_comments(Instrs0, Instrs1),
|
|
( Instrs1 = [livevals(Livevals1) - _ | Instrs2] ->
|
|
livemap__filter_livevals(Livevals1, !:Livevals),
|
|
Instrs = Instrs2,
|
|
Found = yes
|
|
; Compulsory = yes ->
|
|
unexpected(this_file, Site ++ " not preceded by livevals")
|
|
;
|
|
Instrs = Instrs1,
|
|
Found = no
|
|
).
|
|
|
|
% What lval (if any) is consulted when we branch to a code address?
|
|
%
|
|
:- pred livemap__special_code_addr(code_addr::in, maybe(lval)::out) is det.
|
|
|
|
livemap__special_code_addr(label(_), no).
|
|
livemap__special_code_addr(imported(_), no).
|
|
livemap__special_code_addr(succip, yes(succip)).
|
|
livemap__special_code_addr(do_succeed(_), yes(succip(lval(curfr)))).
|
|
livemap__special_code_addr(do_redo, yes(redoip(lval(maxfr)))).
|
|
livemap__special_code_addr(do_trace_redo_fail_shallow, no).
|
|
livemap__special_code_addr(do_trace_redo_fail_deep, no).
|
|
livemap__special_code_addr(do_fail, no).
|
|
livemap__special_code_addr(do_call_closure(_), no).
|
|
livemap__special_code_addr(do_call_class_method(_), no).
|
|
livemap__special_code_addr(do_not_reached, no).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred livemap__make_live_in_rvals(list(rval)::in, lvalset::in, lvalset::out)
|
|
is det.
|
|
|
|
livemap__make_live_in_rvals([], !Live).
|
|
livemap__make_live_in_rvals([Rval | Rvals], !Live) :-
|
|
livemap__make_live_in_rval(Rval, !Live),
|
|
livemap__make_live_in_rvals(Rvals, !Live).
|
|
|
|
% Set all lvals found in this rval to live, with the exception of fields,
|
|
% since they are treated specially (the later stages consider them
|
|
% to be live even if they are not explicitly in the live set).
|
|
%
|
|
:- pred livemap__make_live_in_rval(rval::in, lvalset::in, lvalset::out) is det.
|
|
|
|
livemap__make_live_in_rval(lval(Lval), !Live) :-
|
|
% XXX maybe we should treat mem_refs the same way as field refs
|
|
( Lval = field(_, _, _) ->
|
|
true
|
|
;
|
|
set__insert(!.Live, Lval, !:Live)
|
|
),
|
|
opt_util__lval_access_rvals(Lval, AccessRvals),
|
|
livemap__make_live_in_rvals(AccessRvals, !Live).
|
|
livemap__make_live_in_rval(mkword(_, Rval), !Live) :-
|
|
livemap__make_live_in_rval(Rval, !Live).
|
|
livemap__make_live_in_rval(const(_), !Live).
|
|
livemap__make_live_in_rval(unop(_, Rval), !Live) :-
|
|
livemap__make_live_in_rval(Rval, !Live).
|
|
livemap__make_live_in_rval(binop(_, Rval1, Rval2), !Live) :-
|
|
livemap__make_live_in_rval(Rval1, !Live),
|
|
livemap__make_live_in_rval(Rval2, !Live).
|
|
livemap__make_live_in_rval(var(_), _, _) :-
|
|
unexpected(this_file, "var rval should not propagate to the optimizer").
|
|
livemap__make_live_in_rval(mem_addr(MemRef), !Live) :-
|
|
livemap__make_live_in_mem_ref(MemRef, !Live).
|
|
|
|
:- pred livemap__make_live_in_mem_ref(mem_ref::in, lvalset::in, lvalset::out)
|
|
is det.
|
|
|
|
livemap__make_live_in_mem_ref(stackvar_ref(_), !Live).
|
|
livemap__make_live_in_mem_ref(framevar_ref(_), !Live).
|
|
livemap__make_live_in_mem_ref(heap_ref(Rval, _, _), !Live) :-
|
|
livemap__make_live_in_rval(Rval, !Live).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred livemap__filter_livevals(lvalset::in, lvalset::out) is det.
|
|
|
|
livemap__filter_livevals(Livevals0, Livevals) :-
|
|
set__to_sorted_list(Livevals0, Livelist),
|
|
set__init(Livevals1),
|
|
livemap__insert_proper_livevals(Livelist, Livevals1, Livevals).
|
|
|
|
:- pred livemap__insert_label_livevals(livemap::in, label::in,
|
|
lvalset::in, lvalset::out) is det.
|
|
|
|
livemap__insert_label_livevals(Livemap, Label, !Livevals) :-
|
|
( map__search(Livemap, Label, LabelLivevals) ->
|
|
set__to_sorted_list(LabelLivevals, Livelist),
|
|
livemap__insert_proper_livevals(Livelist, !Livevals)
|
|
;
|
|
true
|
|
).
|
|
|
|
:- pred livemap__insert_proper_livevals(list(lval)::in, lvalset::in,
|
|
lvalset::out) is det.
|
|
|
|
livemap__insert_proper_livevals([], !Livevals).
|
|
livemap__insert_proper_livevals([Live | Livelist], !Livevals) :-
|
|
livemap__insert_proper_liveval(Live, !Livevals),
|
|
livemap__insert_proper_livevals(Livelist, !Livevals).
|
|
|
|
% Don't insert references to locations on the heap.
|
|
%
|
|
:- pred livemap__insert_proper_liveval(lval::in, lvalset::in, lvalset::out)
|
|
is det.
|
|
|
|
livemap__insert_proper_liveval(Live, !Livevals) :-
|
|
( Live = field(_, _, _) ->
|
|
true
|
|
;
|
|
set__insert(!.Livevals, Live, !:Livevals)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- func this_file = string.
|
|
|
|
this_file = "livemap.m".
|
|
|
|
%-----------------------------------------------------------------------------%
|