mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-21 00:39:37 +00:00
fa80b9a01a
Branches: main Make the parallel conjunction execution mechanism more efficient. 1. Don't allocate sync terms on the heap. Sync terms are now allocated in the stack frame of the procedure call which originates a parallel conjunction. 2. Don't allocate individual sparks on the heap. Sparks are now stored in preallocated, growing arrays using an algorithm that doesn't use locks. 3. Don't have one mutex per sync term. Just use one mutex to protect concurrent accesses to all sync terms (it's is rarely needed anyway). This makes sync terms smaller and saves initialising a mutex for each parallel conjunction encountered. 4. We don't bother to acquire the global sync term lock if we know a parallel conjunction couldn't be executing in parallel. In a highly parallel program, the majority of parallel conjunctions will be executed sequentially so protecting the sync terms from concurrent accesses is unnecessary. par_fib(39) is ~8.4 times faster (user time) on my laptop (Linux 2.6, x86_64), which is ~3.5 as slow as sequential execution. configure.in: Update the configuration for a changed MR_SyncTerm structure. compiler/llds.m: Make the fork instruction take a second argument, which is the base stack slot of the sync term. Rename it to fork_new_child to match the macro name in the runtime. compiler/par_conj_gen.m: Change the generated code for parallel conjunctions to allocate sync terms on the stack and to pass the sync term to fork_new_child. compiler/dupelim.m: compiler/dupproc.m: compiler/exprn_aux.m: compiler/global_data.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/llds_to_x86_64.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/reassign.m: compiler/use_local_vars.m: Conform to the change in the fork instruction. compiler/liveness.m: compiler/proc_gen.m: Disable use of the parallel conjunction operator in the compiler as older versions of the compiler will generate code incompatible with the new runtime. runtime/mercury_context.c: runtime/mercury_context.h: Remove the next pointer field from MR_Spark as it's no longer needed. Remove the mutex from MR_SyncTerm. Add a field to record if a spark belonging to the sync term was scheduled globally, i.e. if the parallel conjunction might be executed in parallel. Define MR_SparkDeque and MR_SparkArray. Use MR_SparkDeques to hold per-context sparks and global sparks. Change the abstract machine instructions MR_init_sync_term, MR_fork_new_child, MR_join_and_continue as per the main change log. Use a preprocessor macro MR_LL_PARALLEL_CONJ as a shorthand for !MR_HIGHLEVEL_CODE && MR_THREAD_SAFE. Take the opportunity to clean things up a bit. runtime/mercury_wsdeque.c: runtime/mercury_wsdeque.h: New files containing an implementation of work-stealing deques. We don't do work stealing yet but we use the underlying data structure. runtime/mercury_atomic.c: runtime/mercury_atomic.h: New files to contain atomic operations. Currently it just contains compare-and-swap for gcc/x86_64, gcc/x86 and gcc-4.1. runtime/Mmakefile: Add the new files. runtime/mercury_engine.h: runtime/mercury_mm_own_stacks.c: runtime/mercury_wrapper.c: Conform to runtime changes. runtime/mercury_conf_param.h: Update an outdated comment.
546 lines
20 KiB
Mathematica
546 lines
20 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1995-2007 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 maybe.
|
|
:- import_module set.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- 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 build_livemap(list(instruction)::in, maybe(livemap)::out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module libs.compiler_util.
|
|
:- import_module ll_backend.opt_util.
|
|
:- import_module parse_tree.prog_data.
|
|
|
|
:- import_module bool.
|
|
:- import_module pair.
|
|
:- import_module string.
|
|
:- import_module svset.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% 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.
|
|
|
|
build_livemap(Instrs, MaybeLivemap) :-
|
|
map.init(Livemap0),
|
|
list.reverse(Instrs, BackInstrs),
|
|
build_livemap_fixpoint(BackInstrs, Livemap0, MaybeLivemap).
|
|
|
|
:- pred build_livemap_fixpoint(list(instruction)::in, livemap::in,
|
|
maybe(livemap)::out) is det.
|
|
|
|
build_livemap_fixpoint(Backinstrs, Livemap0, MaybeLivemap) :-
|
|
set.init(Livevals0),
|
|
livemap_do_build(Backinstrs, Livevals0, no, ContainsBadUserCode,
|
|
Livemap0, Livemap1),
|
|
( ContainsBadUserCode = yes ->
|
|
MaybeLivemap = no
|
|
; livemap.equal_livemaps(Livemap0, Livemap1) ->
|
|
MaybeLivemap = yes(Livemap1)
|
|
;
|
|
build_livemap_fixpoint(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 equal_livemaps(livemap::in, livemap::in) is semidet.
|
|
|
|
equal_livemaps(Livemap1, Livemap2) :-
|
|
map.keys(Livemap1, Labels),
|
|
map.keys(Livemap2, Labels),
|
|
livemap.equal_livemaps_keys(Labels, Livemap1, Livemap2).
|
|
|
|
:- pred equal_livemaps_keys(list(label)::in, livemap::in, livemap::in)
|
|
is semidet.
|
|
|
|
equal_livemaps_keys([], _Livemap1, _Livemap2).
|
|
equal_livemaps_keys([Label | Labels], Livemap1, Livemap2) :-
|
|
map.lookup(Livemap1, Label, Liveset1),
|
|
map.lookup(Livemap2, Label, Liveset2),
|
|
set.equal(Liveset1, Liveset2),
|
|
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_do_build(list(instruction)::in, lvalset::in,
|
|
bool::in, bool::out, livemap::in, livemap::out) is det.
|
|
|
|
livemap_do_build([], _, !ContainsBadUserCode, !Livemap).
|
|
livemap_do_build([Instr0 | Instrs0], Livevals0,
|
|
!ContainsBadUserCode, !Livemap) :-
|
|
livemap_do_build_instr(Instr0, Instrs0, Instrs1,
|
|
Livevals0, Livevals1, !ContainsBadUserCode, !Livemap),
|
|
livemap_do_build(Instrs1, Livevals1, !ContainsBadUserCode, !Livemap).
|
|
|
|
:- pred livemap_do_build_instr(instruction::in, list(instruction)::in,
|
|
list(instruction)::out, lvalset::in, lvalset::out,
|
|
bool::in, bool::out, livemap::in, livemap::out) is det.
|
|
|
|
livemap_do_build_instr(Instr0, !Instrs, !Livevals, !ContainsBadUserCode,
|
|
!Livemap) :-
|
|
Instr0 = llds_instr(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)
|
|
; Uinstr0 = keep_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.
|
|
|
|
svset.delete(Lval, !Livevals),
|
|
opt_util.lval_access_rvals(Lval, Rvals),
|
|
livemap.make_live_in_rvals([Rval | Rvals], !Livevals)
|
|
;
|
|
Uinstr0 = llcall(_, _, _, _, _, _),
|
|
livemap.look_for_livevals(!Instrs, !Livevals, "call", yes, _)
|
|
;
|
|
Uinstr0 = mkframe(_, _)
|
|
;
|
|
Uinstr0 = label(Label),
|
|
map.set(!.Livemap, Label, !.Livevals, !:Livemap)
|
|
;
|
|
Uinstr0 = goto(CodeAddr),
|
|
LivevalsNeeded = opt_util.livevals_addr(CodeAddr),
|
|
livemap.look_for_livevals(!Instrs, !Livevals, "goto",
|
|
LivevalsNeeded, Found),
|
|
( Found = yes ->
|
|
true
|
|
; CodeAddr = code_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 = code_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),
|
|
svset.delete(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, _, _, MaybeRegionRval),
|
|
|
|
% 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.
|
|
|
|
svset.delete(Lval, !Livevals),
|
|
opt_util.lval_access_rvals(Lval, Rvals0),
|
|
(
|
|
MaybeRegionRval = no,
|
|
Rvals = [Rval | Rvals0]
|
|
;
|
|
MaybeRegionRval = yes(RegionRval),
|
|
Rvals = [Rval, RegionRval | Rvals0]
|
|
),
|
|
livemap.make_live_in_rvals(Rvals, !Livevals)
|
|
;
|
|
Uinstr0 = mark_hp(Lval),
|
|
svset.delete(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 = push_region_frame(_RegionStackId, _EmbeddedStackFrame)
|
|
;
|
|
Uinstr0 = region_fill_frame(_FillOp, _EmbeddedStackFrame, IdRval,
|
|
NumLval, AddrLval),
|
|
livemap.make_live_in_rval(IdRval, !Livevals),
|
|
% The instruction takes the current values in NumLval and AddrLval
|
|
% as inputs, and then updates those values. This means that they are
|
|
% live on entry to the instruction, and will stay that way afterward.
|
|
livemap.make_live_in_rval(lval(NumLval), !Livevals),
|
|
livemap.make_live_in_rval(lval(AddrLval), !Livevals)
|
|
;
|
|
Uinstr0 = region_set_fixed_slot(_SetOp, _EmbeddedStackFrame,
|
|
ValueRval),
|
|
livemap.make_live_in_rval(ValueRval, !Livevals)
|
|
;
|
|
Uinstr0 = use_and_maybe_pop_region_frame(_UseOp, _EmbeddedStackFrame)
|
|
% XXX We should make all stackvars or framevars in _EmbeddedStackFrame
|
|
% live, to prevent the compiler from optimizing away assignments to
|
|
% them. However, at the moment all such assignments are done via
|
|
% region_fill_frame and region_set_fixed_slot instructions, which
|
|
% we currently do not ever optimize away, so recording the stack slots
|
|
% as live would be redundant.
|
|
;
|
|
Uinstr0 = store_ticket(Lval),
|
|
svset.delete(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),
|
|
svset.delete(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_new_child(_, _)
|
|
;
|
|
Uinstr0 = join_and_continue(_, _)
|
|
;
|
|
Uinstr0 = arbitrary_c_code(AffectsLiveness, LiveLvalInfo, Code),
|
|
build_live_lval_info(AffectsLiveness, LiveLvalInfo, Code,
|
|
!Livevals, !ContainsBadUserCode)
|
|
;
|
|
Uinstr0 = foreign_proc_code(_, Components, _, _, _, _, _, _, _),
|
|
build_livemap_foreign_proc_components(Components,
|
|
!Livevals, !ContainsBadUserCode)
|
|
).
|
|
|
|
:- pred build_livemap_foreign_proc_components(list(foreign_proc_component)::in,
|
|
lvalset::in, lvalset::out, bool::in, bool::out) is det.
|
|
|
|
build_livemap_foreign_proc_components([], !Livevals, !ContainsBadUserCode).
|
|
build_livemap_foreign_proc_components([Component | Components],
|
|
!Livevals, !ContainsBadUserCode) :-
|
|
(
|
|
Component = foreign_proc_inputs(Inputs),
|
|
build_livemap_foreign_proc_inputs(Inputs, !Livevals)
|
|
;
|
|
Component = foreign_proc_outputs(_)
|
|
;
|
|
Component = foreign_proc_user_code(_, AffectsLiveness, Code),
|
|
(
|
|
AffectsLiveness = proc_affects_liveness,
|
|
!:ContainsBadUserCode = yes
|
|
;
|
|
AffectsLiveness = proc_default_affects_liveness,
|
|
( Code = "" ->
|
|
true
|
|
;
|
|
% We should take the contents of the Code into account here.
|
|
% For now, we just assume the worst.
|
|
!:ContainsBadUserCode = yes
|
|
)
|
|
;
|
|
AffectsLiveness = proc_does_not_affect_liveness
|
|
)
|
|
;
|
|
Component = foreign_proc_raw_code(_Context, AffectsLiveness,
|
|
LiveLvalInfo, Code),
|
|
build_live_lval_info(AffectsLiveness, LiveLvalInfo, Code,
|
|
!Livevals, !ContainsBadUserCode)
|
|
;
|
|
Component = foreign_proc_fail_to(_)
|
|
;
|
|
Component = foreign_proc_noop
|
|
),
|
|
build_livemap_foreign_proc_components(Components,
|
|
!Livevals, !ContainsBadUserCode).
|
|
|
|
:- pred build_live_lval_info(proc_affects_liveness::in, c_code_live_lvals::in,
|
|
string::in, lvalset::in, lvalset::out, bool::in, bool::out) is det.
|
|
|
|
build_live_lval_info(AffectsLiveness, LiveLvalInfo, Code,
|
|
!Livevals, !ContainsBadUserCode) :-
|
|
(
|
|
AffectsLiveness = proc_affects_liveness,
|
|
!:ContainsBadUserCode = yes
|
|
;
|
|
AffectsLiveness = proc_default_affects_liveness,
|
|
( Code = "" ->
|
|
true
|
|
;
|
|
% We should take the contents of the Code into account here.
|
|
% For now, we just assume the worst.
|
|
!:ContainsBadUserCode = yes
|
|
)
|
|
;
|
|
AffectsLiveness = proc_does_not_affect_liveness,
|
|
(
|
|
LiveLvalInfo = no_live_lvals_info,
|
|
!:ContainsBadUserCode = yes
|
|
;
|
|
LiveLvalInfo = live_lvals_info(LiveLvalSet),
|
|
set.to_sorted_list(LiveLvalSet, LiveLvals),
|
|
livemap_insert_proper_livevals(LiveLvals, !Livevals)
|
|
)
|
|
).
|
|
|
|
:- pred build_livemap_foreign_proc_inputs(list(foreign_proc_input)::in,
|
|
lvalset::in, lvalset::out) is det.
|
|
|
|
build_livemap_foreign_proc_inputs([], !Livevals).
|
|
build_livemap_foreign_proc_inputs([Input | Inputs], !Livevals) :-
|
|
Input = foreign_proc_input(_, _, _, _, Rval, _, _),
|
|
( Rval = lval(Lval) ->
|
|
livemap_insert_proper_liveval(Lval, !Livevals)
|
|
;
|
|
true
|
|
),
|
|
build_livemap_foreign_proc_inputs(Inputs, !Livevals).
|
|
|
|
:- pred look_for_livevals(list(instruction)::in,
|
|
list(instruction)::out, lvalset::in, lvalset::out, string::in,
|
|
bool::in, bool::out) is det.
|
|
|
|
look_for_livevals(Instrs0, Instrs, !Livevals, Site, Compulsory, Found) :-
|
|
opt_util.skip_comments(Instrs0, Instrs1),
|
|
( Instrs1 = [llds_instr(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(code_label(_), no).
|
|
livemap_special_code_addr(code_imported_proc(_), no).
|
|
livemap_special_code_addr(code_succip, yes(succip)).
|
|
livemap_special_code_addr(do_succeed(_), yes(succip_slot(lval(curfr)))).
|
|
livemap_special_code_addr(do_redo, yes(redoip_slot(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 make_live_in_rvals(list(rval)::in, lvalset::in, lvalset::out) is det.
|
|
|
|
make_live_in_rvals([], !Live).
|
|
make_live_in_rvals([Rval | Rvals], !Live) :-
|
|
make_live_in_rval(Rval, !Live),
|
|
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 make_live_in_rval(rval::in, lvalset::in, lvalset::out) is det.
|
|
|
|
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),
|
|
make_live_in_rvals(AccessRvals, !Live).
|
|
make_live_in_rval(mkword(_, Rval), !Live) :-
|
|
make_live_in_rval(Rval, !Live).
|
|
make_live_in_rval(const(_), !Live).
|
|
make_live_in_rval(unop(_, Rval), !Live) :-
|
|
make_live_in_rval(Rval, !Live).
|
|
make_live_in_rval(binop(_, Rval1, Rval2), !Live) :-
|
|
make_live_in_rval(Rval1, !Live),
|
|
make_live_in_rval(Rval2, !Live).
|
|
make_live_in_rval(var(_), _, _) :-
|
|
unexpected(this_file, "var rval should not propagate to the optimizer").
|
|
make_live_in_rval(mem_addr(MemRef), !Live) :-
|
|
make_live_in_mem_ref(MemRef, !Live).
|
|
|
|
:- pred make_live_in_mem_ref(mem_ref::in, lvalset::in, lvalset::out) is det.
|
|
|
|
make_live_in_mem_ref(stackvar_ref(Rval), !Live) :-
|
|
make_live_in_rval(Rval, !Live).
|
|
make_live_in_mem_ref(framevar_ref(Rval), !Live) :-
|
|
make_live_in_rval(Rval, !Live).
|
|
make_live_in_mem_ref(heap_ref(Rval1, _, Rval2), !Live) :-
|
|
make_live_in_rval(Rval1, !Live),
|
|
make_live_in_rval(Rval2, !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".
|
|
|
|
%-----------------------------------------------------------------------------%
|