mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-13 04:44:39 +00:00
Code Issues Projects Releases Wiki Activity
Files
bcf7dbf9f89f616e2a184642d0e510c24b1762bb
mercury/compiler/livemap.m
Fergus Henderson 11d8161692 Add support for nested modules. 
Estimated hours taken: 50

Add support for nested modules.

- module names may themselves be module-qualified
- modules may contain `:- include_module' declarations
  which name sub-modules
- a sub-module has access to all the declarations in the
  parent module (including its implementation section).

This support is not yet complete; see the BUGS and LIMITATIONS below.

LIMITATIONS
- source file names must match module names
	(just as they did previously)
- mmc doesn't allow path names on the command line any more
	(e.g. `mmc --make-int ../library/foo.m').
- import_module declarations must use the fully-qualified module name
- module qualifiers must use the fully-qualified module name
- no support for root-qualified module names
	(e.g. `:parent:child' instead of `parent:child').
- modules may not be physically nested (only logical nesting, via
  `include_module').

BUGS
- doesn't check that the parent module is imported/used before allowing
	import/use of its sub-modules.
- doesn't check that there is an include_module declaration in the
	parent for each module claiming to be a child of that parent
- privacy of private modules is not enforced

-------------------

NEWS:
	Mention that we support nested modules.

library/ops.m:
library/nc_builtin.nl:
library/sp_builtin.nl:
compiler/mercury_to_mercury.m:
	Add `include_module' as a new prefix operator.
	Change the associativity of `:' from xfy to yfx
	(since this made parsing module qualifiers slightly easier).

compiler/prog_data.m:
	Add new `include_module' declaration.
	Change the `module_name' and `module_specifier' types
	from strings to sym_names, so that module names can
	themselves be module qualified.

compiler/modules.m:
	Add predicates module_name_to_file_name/2 and
	file_name_to_module_name/2.
	Lots of changes to handle parent module dependencies,
	to create parent interface (`.int0') files, to read them in,
	to output correct dependencies information for them to the
	`.d' and `.dep' files, etc.
	Rewrite a lot of the code to improve the readability
	(add comments, use subroutines, better variable names).
	Also fix a couple of bugs:
	- generate_dependencies was using the transitive implementation
	  dependencies rather than the transitive interface dependencies
	  to compute the `.int3' dependencies when writing `.d' files
	  (this bug was introduced during crs's changes to support
	  `.trans_opt' files)
	- when creating the `.int' file, it was reading in the
	  interfaces for modules imported in the implementation section,
	  not just those in the interface section.
	  This meant that the compiler missed a lot of errors.

library/graph.m:
library/lexer.m:
library/term.m:
library/term_io.m:
library/varset.m:
compiler/*.m:
	Add `:- import_module' declarations to the interface needed
	by declarations in the interface.  (The previous version
	of the compiler did not detect these missing interface imports,
	due to the above-mentioned bug in modules.m.)

compiler/mercury_compile.m:
compiler/intermod.m:
	Change mercury_compile__maybe_grab_optfiles and
	intermod__grab_optfiles so that they grab the opt files for
	parent modules as well as the ones for imported modules.

compiler/mercury_compile.m:
	Minor changes to handle parent module dependencies.
	(Also improve the wording of the warning about trans-opt
	dependencies.)

compiler/make_hlds.m:
compiler/module_qual.m:
	Ignore `:- include_module' declarations.

compiler/module_qual.m:
	A couple of small changes to handle nested module names.

compiler/prog_out.m:
compiler/prog_util.m:
	Add new predicates string_to_sym_name/3 (prog_util.m) and
	sym_name_to_string/{2,3} (prog_out.m).

compiler/*.m:
	Replace many occurrences of `string' with `module_name'.
	Change code that prints out module names or converts
	them to strings or filenames to handle the fact that
	module names are now sym_names intead of strings.
	Also change a few places (e.g. in intermod.m, hlds_module.m)
	where the code assumed that any qualified symbol was
	fully-qualified.

compiler/prog_io.m:
compiler/prog_io_goal.m:
	Move sym_name_and_args/3, parse_qualified_term/4 and
	parse_qualified_term/5 preds from prog_io_goal.m to prog_io.m,
	since they are very similar to the parse_symbol_name/2 predicate
	already in prog_io.m.  Rewrite these predicates, both
	to improve maintainability, and to handle the newly
	allowed syntax (module-qualified module names).
	Rename parse_qualified_term/5 as `parse_implicit_qualified_term'.

compiler/prog_io.m:
	Rewrite the handling of `:- module' and `:- end_module'
	declarations, so that it can handle nested modules.
	Add code to parse `include_module' declarations.

compiler/prog_util.m:
compiler/*.m:
	Add new predicates mercury_public_builtin_module/1 and
	mercury_private_builtin_module/1 in prog_util.m.
	Change most of the hard-coded occurrences of "mercury_builtin"
	to call mercury_private_builtin_module/1 or
	mercury_public_builtin_module/1 or both.

compiler/llds_out.m:
	Add llds_out__sym_name_mangle/2, for mangling module names.

compiler/special_pred.m:
compiler/mode_util.m:
compiler/clause_to_proc.m:
compiler/prog_io_goal.m:
compiler/lambda.m:
compiler/polymorphism.m:
	Move the predicates in_mode/1, out_mode/1, and uo_mode/1
	from special_pred.m to mode_util.m, and change various
	hard-coded definitions to instead call these predicates.

compiler/polymorphism.m:
	Ensure that the type names `type_info' and `typeclass_info' are
	module-qualified in the generated code.  This avoids a problem
	where the code generated by polymorphism.m was not considered
	type-correct, due to the type `type_info' not matching
	`mercury_builtin:type_info'.

compiler/check_typeclass.m:
	Simplify the code for check_instance_pred and
	get_matching_instance_pred_ids.

compiler/mercury_compile.m:
compiler/modules.m:
	Disallow directory names in command-line arguments.

compiler/options.m:
compiler/handle_options.m:
compiler/mercury_compile.m:
compiler/modules.m:
	Add a `--make-private-interface' option.
	The private interface file `<module>.int0' contains
	all the declarations in the module; it is used for
	compiling sub-modules.

scripts/Mmake.rules:
scripts/Mmake.vars.in:
	Add support for creating `.int0' and `.date0' files
	by invoking mmc with `--make-private-interface'.

doc/user_guide.texi:
	Document `--make-private-interface' and the `.int0'
	and `.date0' file extensions.

doc/reference_manual.texi:
	Document nested modules.

util/mdemangle.c:
profiler/demangle.m:
	Demangle names with multiple module qualifiers.

tests/general/Mmakefile:
tests/general/string_format_test.m:
tests/general/string_format_test.exp:
tests/general/string__format_test.m:
tests/general/string__format_test.exp:
tests/general/.cvsignore:
	Change the `:- module string__format_test' declaration in
	`string__format_test.m' to `:- module string_format_test',
	because with the original declaration the `__' was taken
	as a module qualifier, which lead to an error message.
	Hence rename the file accordingly, to avoid the warning
	about file name not matching module name.

tests/invalid/Mmakefile:
tests/invalid/missing_interface_import.m:
tests/invalid/missing_interface_import.err_exp:
	Regression test to check that the compiler reports
	errors for missing `import_module' in the interface section.

tests/invalid/*.err_exp:
tests/warnings/unused_args_test.exp:
tests/warnings/unused_import.exp:
	Update the expected diagnostics output for the test cases to
	reflect a few minor changes to the warning messages.

tests/hard_coded/Mmakefile:
tests/hard_coded/parent.m:
tests/hard_coded/parent.child.m:
tests/hard_coded/parent.exp:
tests/hard_coded/parent2.m:
tests/hard_coded/parent2.child.m:
tests/hard_coded/parent2.exp:
	Two simple tests case for the use of nested modules with
	separate compilation.
1998-03-03 17:48:14 +00:00

475 lines
16 KiB
Mathematica
Raw Blame History

%-----------------------------------------------------------------------------%
% Copyright (C) 1995-1998 The University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%-----------------------------------------------------------------------------%
%
% File: livemap.m
%
% Main author: zs.
%
% This module builds up a map that gives the set of live lvals at each label.
%-----------------------------------------------------------------------------%
:- module livemap.
:- interface.
:- import_module list, set, map, std_util.
:- import_module llds.
:- 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), maybe(livemap)).
:- mode livemap__build(in, out) is det.
:- implementation.
:- import_module opt_util.
:- import_module require, string, bool.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
% 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), livemap, maybe(livemap)).
:- mode livemap__build_2(in, in, out) is det.
livemap__build_2(Backinstrs, Livemap0, MaybeLivemap) :-
set__init(Livevals0),
livemap__build_livemap(Backinstrs, Livevals0, no, Ccode1,
Livemap0, Livemap1),
( Ccode1 = 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, livemap).
:- mode livemap__equal_livemaps(in, 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), livemap, livemap).
:- mode livemap__equal_livemaps_keys(in, in, 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), lvalset, bool, bool,
livemap, livemap).
:- mode livemap__build_livemap(in, in, in, out, in, out) is det.
livemap__build_livemap([], _, Ccode, Ccode, Livemap, Livemap).
livemap__build_livemap([Instr0 | Instrs0], Livevals0, Ccode0, Ccode,
Livemap0, Livemap) :-
livemap__build_livemap_instr(Instr0, Instrs0, Instrs1,
Livevals0, Livevals1, Ccode0, Ccode1, Livemap0, Livemap1),
livemap__build_livemap(Instrs1, Livevals1,
Ccode1, Ccode, Livemap1, Livemap).
:- pred livemap__build_livemap_instr(instruction, list(instruction),
list(instruction), lvalset, lvalset, bool, bool, livemap, livemap).
:- mode livemap__build_livemap_instr(in, in, out, in, out, in, out, in, out)
is det.
livemap__build_livemap_instr(Instr0, Instrs0, Instrs,
Livevals0, Livevals, Ccode0, Ccode, Livemap0, Livemap) :-
Instr0 = Uinstr0 - _,
(
Uinstr0 = comment(_),
Livemap = Livemap0,
Livevals = Livevals0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = livevals(_),
error("livevals found in backward scan in build_livemap")
;
Uinstr0 = block(_, _, _),
error("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(Livevals0, Lval, Livevals1),
opt_util__lval_access_rvals(Lval, Rvals),
livemap__make_live_in_rvals([Rval | Rvals], Livevals1,
Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = call(_, _, _, _),
livemap__look_for_livevals(Instrs0, Instrs,
Livevals0, Livevals, "call", yes, _),
Livemap = Livemap0,
Ccode = Ccode0
;
Uinstr0 = mkframe(_, _, _, _),
Livemap = Livemap0,
Livevals = Livevals0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = modframe(_),
Livemap = Livemap0,
Livevals = Livevals0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = label(Label),
map__set(Livemap0, Label, Livevals0, Livemap),
Livevals = Livevals0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = goto(CodeAddr),
opt_util__livevals_addr(CodeAddr, LivevalsNeeded),
livemap__look_for_livevals(Instrs0, Instrs,
Livevals0, Livevals1, "goto", LivevalsNeeded, Found),
( Found = yes ->
Livevals3 = Livevals1
; CodeAddr = label(Label) ->
set__init(Livevals2),
livemap__insert_label_livevals([Label],
Livemap0, Livevals2, Livevals3)
;
( CodeAddr = do_redo
; CodeAddr = do_fail
; CodeAddr = do_not_reached
)
->
Livevals3 = Livevals1
;
error("unknown label type in build_livemap")
),
livemap__special_code_addr(CodeAddr, MaybeSpecial),
( MaybeSpecial = yes(Special) ->
set__insert(Livevals3, Special, Livevals)
;
Livevals = Livevals3
),
Livemap = Livemap0,
Ccode = Ccode0
;
Uinstr0 = computed_goto(Rval, Labels),
set__init(Livevals1),
livemap__make_live_in_rvals([Rval], Livevals1, Livevals2),
livemap__insert_label_livevals(Labels, Livemap0,
Livevals2, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = c_code(_),
Livemap = Livemap0,
Livevals = Livevals0,
Instrs = Instrs0,
Ccode = yes
;
Uinstr0 = if_val(Rval, CodeAddr),
livemap__look_for_livevals(Instrs0, Instrs,
Livevals0, Livevals1, "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, Livevals1, Livevals3)
;
Found = no,
livemap__make_live_in_rvals([Rval],
Livevals1, Livevals2),
( CodeAddr = label(Label) ->
livemap__insert_label_livevals([Label],
Livemap0, Livevals2, Livevals3)
;
Livevals3 = Livevals2
)
),
livemap__special_code_addr(CodeAddr, MaybeSpecial),
( MaybeSpecial = yes(Special) ->
set__insert(Livevals3, Special, Livevals)
;
Livevals = Livevals3
),
Livemap = Livemap0,
Ccode = Ccode0
;
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(Livevals0, Lval, Livevals1),
opt_util__lval_access_rvals(Lval, Rvals),
livemap__make_live_in_rvals([Rval | Rvals],
Livevals1, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = mark_hp(Lval),
set__delete(Livevals0, Lval, Livevals1),
opt_util__lval_access_rvals(Lval, Rvals),
livemap__make_live_in_rvals(Rvals, Livevals1, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = restore_hp(Rval),
livemap__make_live_in_rvals([Rval], Livevals0, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = store_ticket(Lval),
set__delete(Livevals0, Lval, Livevals1),
opt_util__lval_access_rvals(Lval, Rvals),
livemap__make_live_in_rvals(Rvals, Livevals1, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = reset_ticket(Rval, _Reason),
livemap__make_live_in_rval(Rval, Livevals0, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = discard_ticket,
Livevals = Livevals0,
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = mark_ticket_stack(Lval),
set__delete(Livevals0, Lval, Livevals1),
opt_util__lval_access_rvals(Lval, Rvals),
livemap__make_live_in_rvals(Rvals, Livevals1, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = discard_tickets_to(Rval),
livemap__make_live_in_rval(Rval, Livevals0, Livevals),
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = incr_sp(_, _),
Livevals = Livevals0,
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
Uinstr0 = decr_sp(_),
Livevals = Livevals0,
Livemap = Livemap0,
Instrs = Instrs0,
Ccode = Ccode0
;
% XXX we shouldn't just give up here
Uinstr0 = pragma_c(_, _, _, _),
Livemap = Livemap0,
Livevals = Livevals0,
Instrs = Instrs0,
Ccode = yes
).
:- pred livemap__look_for_livevals(list(instruction), list(instruction),
lvalset, lvalset, string, bool, bool).
:- mode livemap__look_for_livevals(in, out, in, out, in, in, out) is det.
livemap__look_for_livevals(Instrs0, Instrs, Livevals0, 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 ->
string__append(Site, " not preceded by livevals", Msg),
error(Msg)
;
Instrs = Instrs1,
Livevals = Livevals0,
Found = no
).
% What lval (if any) is consulted when we branch to a code address?
:- pred livemap__special_code_addr(code_addr, maybe(lval)).
:- mode livemap__special_code_addr(in, 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_fail, no).
livemap__special_code_addr(do_det_closure, no).
livemap__special_code_addr(do_semidet_closure, no).
livemap__special_code_addr(do_nondet_closure, no).
livemap__special_code_addr(do_det_class_method, no).
livemap__special_code_addr(do_semidet_class_method, no).
livemap__special_code_addr(do_nondet_class_method, no).
livemap__special_code_addr(do_not_reached, no).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- pred livemap__make_live_in_rvals(list(rval), lvalset, lvalset).
:- mode livemap__make_live_in_rvals(in, in, out) is det.
livemap__make_live_in_rvals([], Live, Live).
livemap__make_live_in_rvals([Rval | Rvals], Live0, Live) :-
livemap__make_live_in_rval(Rval, Live0, Live1),
livemap__make_live_in_rvals(Rvals, Live1, 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, lvalset, lvalset).
:- mode livemap__make_live_in_rval(in, in, out) is det.
livemap__make_live_in_rval(lval(Lval), Live0, Live) :-
% XXX maybe we should treat mem_refs the same way as field refs
( Lval = field(_, _, _) ->
Live1 = Live0
;
set__insert(Live0, Lval, Live1)
),
opt_util__lval_access_rvals(Lval, AccessRvals),
livemap__make_live_in_rvals(AccessRvals, Live1, Live).
livemap__make_live_in_rval(create(_, _, _, _, _), Live, Live).
% All terms inside creates in the optimizer must be static.
livemap__make_live_in_rval(mkword(_, Rval), Live0, Live) :-
livemap__make_live_in_rval(Rval, Live0, Live).
livemap__make_live_in_rval(const(_), Live, Live).
livemap__make_live_in_rval(unop(_, Rval), Live0, Live) :-
livemap__make_live_in_rval(Rval, Live0, Live).
livemap__make_live_in_rval(binop(_, Rval1, Rval2), Live0, Live) :-
livemap__make_live_in_rval(Rval1, Live0, Live1),
livemap__make_live_in_rval(Rval2, Live1, Live).
livemap__make_live_in_rval(var(_), _, _) :-
error("var rval should not propagate to the optimizer").
livemap__make_live_in_rval(mem_addr(MemRef), Live0, Live) :-
livemap__make_live_in_mem_ref(MemRef, Live0, Live).
:- pred livemap__make_live_in_mem_ref(mem_ref, lvalset, lvalset).
:- mode livemap__make_live_in_mem_ref(in, in, out) is det.
livemap__make_live_in_mem_ref(stackvar_ref(_), Live, Live).
livemap__make_live_in_mem_ref(framevar_ref(_), Live, Live).
livemap__make_live_in_mem_ref(heap_ref(Rval, _, _), Live0, Live) :-
livemap__make_live_in_rval(Rval, Live0, Live).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- pred livemap__filter_livevals(lvalset, lvalset).
:- mode livemap__filter_livevals(in, 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(list(label), livemap, lvalset, lvalset).
:- mode livemap__insert_label_livevals(in, in, in, out) is det.
livemap__insert_label_livevals([], _, Livevals, Livevals).
livemap__insert_label_livevals([Label | Labels], Livemap, Livevals0, Livevals)
:-
( map__search(Livemap, Label, LabelLivevals) ->
set__to_sorted_list(LabelLivevals, Livelist),
livemap__insert_proper_livevals(Livelist, Livevals0, Livevals1)
;
Livevals1 = Livevals0
),
livemap__insert_label_livevals(Labels, Livemap, Livevals1, Livevals).
:- pred livemap__insert_proper_livevals(list(lval), lvalset, lvalset).
:- mode livemap__insert_proper_livevals(in, in, out) is det.
livemap__insert_proper_livevals([], Livevals, Livevals).
livemap__insert_proper_livevals([Live | Livelist], Livevals0, Livevals) :-
livemap__insert_proper_liveval(Live, Livevals0, Livevals1),
livemap__insert_proper_livevals(Livelist, Livevals1, Livevals).
% Don't insert references to locations on the heap.
:- pred livemap__insert_proper_liveval(lval, lvalset, lvalset).
:- mode livemap__insert_proper_liveval(in, in, out) is det.
livemap__insert_proper_liveval(Live, Livevals0, Livevals) :-
( Live = field(_, _, _) ->
Livevals = Livevals0
;
set__insert(Livevals0, Live, Livevals)
).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink