mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-13 12:53:53 +00:00
Code Issues Projects Releases Wiki Activity
Files
4ee7e744b715b7adf665a267de3814131839a617
mercury/compiler/livemap.m
Zoltan Somogyi 24b98fdafe Pack sub-word-sized ints and dummies in terms. 
Previously, the only situation in which we could pack two or more arguments
of a term into a single word was when all those arguments are enums. This diff
changes that, so that the arguments can also be sub-word-sized integers
(signed or unsigned), or values of dummy types (which occupy zero bits).

This diff also records, for each argument of a function symbol, not just
whether, and if yes, how it is packed into a word, but also at *what offset*
that word is in the term's heap cell. It is more economical to compute this
once, when the representation of the type is being decided, than to compute
it over and over again when terms with that function symbol are being
constructed or deconstructed. However, for a transition period, we compute
these offsets at *both* times, to check the consistency of the new algorithm
for computing offsets that is run at "decide representation time" with
the old algorithms run at "generate code for a unification time".

compiler/du_type_layout.m:
    Make the changes described above: pack sub-word-sized integers and
    dummy values into argument words, if possible, and if the relevant
    new option allows it. These options are temporary. If we find no problems
    with the new packing algorithm in a few weeks, we should be able to
    delete them.

    Allow 64 bit ints and uints to be stored in unboxed in two words
    on 32 bit platforms, if the relevant new option allows it. Support
    for this is not yet complete, but it makes sense to implement the
    RTTI changes for both this change and one described in the above
    paragraph together.

    For each packed argument, record not just its width, its shift and
    the mask, but also the number of bits the argument takes. Previously,
    we computed this on demand from the mask, but there is no real need
    for that when simply storing this info is so cheap.

    For all arguments, packed or not, record its offset, relative to both
    the start of the arguments, and the start of the memory cell. (The two
    are different if the arguments are preceded by either a remote secondary
    tag, the typeinfos and/or typeclass_infos describing some existentially
    typed arguments, or both.) The reason for this is given at the top.

    Centralize the decision of the parameters of packing in one predicate.

    If the option --inform-suboptimal-packing is given, print an informational
    message whenever the code deciding type representations finds that
    reordering the arguments of a function symbol would allow it to pack
    the arguments of that function symbol into less space.

compiler/options.m:
    Add the option --allow-packing-ints which controls whether
    du_type_layout.m will attempt to pack {int,uint}{8,16,32} arguments
    alongside enum arguments.

    Add the option --allow-packing-dummies which controls whether
    du_type_layout.m will optimize away (in other words, represent in 0 bits)
    arguments of dummy types.

    Add the option --allow-double-word-ints which controls whether
    du_type_layout.m will store arguments of the types int64 and uint64
    unboxed in two words on 32 bit platforms, the way it currently stores
    double precision floats.

    All three those options are off by default, which preserves binary
    compatibility with existing code. However, the first two are ready
    to be switched on (the third is not).

    All three options are intended to be present in the compiler
    only until these changes are tested. Once we deem them sufficiently
    tested, I will modify the compiler to always do the packing they control,
    at which point we can delete these options. This is why they are not
    documented.

    Add the option --inform-suboptimal-packing, whose meaning is described
    above.

doc/user_guide.texi:
    Document --inform-suboptimal-packing.

compiler/prog_data.m:
    For each argument of a function symbol in a type definition, use
    a new type called arg_pos_width to record the extra information
    mentioned above in (offsets for all arguments, and number of bits
    for packed arguments).

    For each function symbol that has some existential type constraints,
    record the extra information mentioned for parse_type_defn.m below.

compiler/hlds_data.m:
    Include the position, as well as the width, in the representation
    of the arguments of function symbols.

    Previously, we used the integer 0 as a tag for dummies. Add a tag to
    represent dummy values, since this gives more information to any code
    that sees that tag.

compiler/ml_unify_gen.m:
compiler/unify_gen.m:
    Handle the packing of dummy values, and of sub-word-sized ints and uints.

    Compare the cell offset of each argument computed using existing
    algorithms here with the cell offset recorded in the argument's
    representation, and abort if they are different.

    In some cases, restructure code a bit to make it possible.
    For example, for tuples and closures, this means that instead of
    simply recording that each tuple argument or closure element
    is a full word, we must record its correct offset as well.

    Handle the new dummy_tag.

    Add prelim (not yet finished) support for double-word int64s/uint64s
    on 32 bit platforms.

    When packing the values of two or more variables (or constants) into a
    single word in a memory cell, optimize away operations that are no-ops,
    such as shifting anything by zero bits, shifting the constant zero
    by any number of bits, and ORing anything with zero. This makes the
    generated code easier to read. It is probably also faster for us
    to do it here than to write out a bigger expression, have the C compiler
    read in the bigger expression, and then later make the same optimization.

    In ml_unify_gen.m, avoid the unnecessary use of a list of the argument
    variables' types separate from the list of the argument variables
    themselves; just look up the type of each argument variable when it is
    processed.

compiler/add_special_pred.m:
    When creating special (unify and compare) predicates for tuples,
    include the offsets in the representation of their arguments.

    Delete an unused predicate.

compiler/llds.m:
    Add a new way to create an rval: a cast. We use it to implement
    the extraction of signed sub-word-sized integers from packed argument
    words in terms. Masking the right N bits out of the packed word
    leaves the other 32-N or 64-N bits as zeroes; a cast to int8_t,
    int16_t or int32_t will copy the sign bit to these bits.
    Likewise, when we pack signed int{8,16,32} values into words,
    we cast them to their unsigned versions to throw away any sign-extension
    bits in their original word-sized representations.

    No similar change is needed for the MLDS, since that already had
    a mechanism for casts.

compiler/mlds.m:
    Note a potential simplification in the MLDS.

compiler/builtin_lib_types.m:
    Add functions to return the Mercury representation of the int64
    and uint64 types.

compiler/foreign.m:
    Export a specialized version of an existing predicate, to allow
    ml_unify_gen.m to avoid the costs of the more general version.

compiler/hlds_out_module.m:
    Always print the representations of all arguments, since the
    inclusion of position information in those representation means that
    the representations of even all-full-word-argument terms are of potential
    interest when debugging term representations.

compiler/lco.m:
    Do not try to apply LCO to arguments of dummy types. (We could optimize
    them differently, by filling them in before they are "computed", but
    that is a separate optimization, which is of *very* low priority.)

compiler/liveness.m:
    Do not include variables of dummy types in resume points.

    The reason for this is that the code that establishes a resume point
    returns, for each such variable, a list of *lvals* where that variable
    can be found. The new code in unify_gen.m will optimize away assignments
    to values of dummy types, so there is *no* lval where they can be found.
    We could allocate one, but doing so would be a pessimization. Instead,
    we simply don't save and restore such values. When their value (which is
    always 0) is needed, we can create them out of thin air.

compiler/ml_global_data.m:
    Include the target language in the ml_global_data structure, to prevent
    some of its users having to look it up in the module_info.

    Add notes about the specializing the implementation of arrays of
    int64s/uint64s on 32 bit platforms.

compiler/check_typeclass.m:
compiler/ml_type_gen.m:
    Add sanity checks of the new precomputed fields of exist_constraints.

    Conform to the changes above.

compiler/mlds_to_c.m:
    Add prelim (not yet finished) support for double-word int64s/uint64s
    on 32 bit platforms.

    Add notes about possible optimizations.

compiler/parse_type_defn.m:
    When a function symbol in a type definition contains existential
    arguments, precompute and store the set of constrained and unconstrained
    type variables. The code in du_type_layout.m needs this information
    to compute the number of slots occupied by typeinfos and typeclass_infos
    in memory cells for this function symbol, and several other places
    in the compiler do too. It is easier and faster to compute this
    information just once, and this is the earliest time what that can be done.

compiler/type_ctor_info.m:
    Use the prerecorded information about existential types to simplify
    the code here

compiler/polymorphism.m:
    Add an XXX about possibly using the extra info we now record in
    exist_constraints to simplify the job of polymorphism.m.

compiler/pragma_c_gen.m:
compiler/var_locn.m:
    Create the values of dummy variables from scratch, if needed.

compiler/rtti.m:
    Replace a bool with a bespoke type.

compiler/rtti_out.m:
compiler/rtti_to_mlds.m:
    When generating RTTI information for the LLDS and MLDS backends
    respectively, record new kinds of arguments as needing special
    treatment. These are int64s and uint64s stored unboxed in two words
    on 32 bit platforms, {int,uint}{8,16,32} values packed into words,
    and dummy arguments. Each of these has a special code: its own negative
    negative value in the num_bits field of the argument.

    Generate slightly better formatted output.

compiler/type_util.m:
    Delete a predicate that isn't needed anymore.

compiler/opt_util.m:
    Delete a function that hasn't been needed for a while.

    Conform to the changes above.

compiler/arg_pack.m:
compiler/bytecode_gen.m:
compiler/call_gen.m:
compiler/code_util.m:
compiler/ctgc.selector.m:
compiler/dupelim.m:
compiler/dupproc.m:
compiler/equiv_type.m:
compiler/equiv_type_hlds.m:
compiler/erl_code_gen.m:
compiler/erl_rtti.m:
compiler/export.m:
compiler/exprn_aux.m:
compiler/global_data.m:
compiler/jumpopt.m:
compiler/livemap.m:
compiler/llds_out_data.m:
compiler/middle_rec.m:
compiler/ml_closure_gen.m:
compiler/ml_switch_gen.m:
compiler/ml_top_gen.m:
compiler/module_qual.qualify_items.m:
compiler/opt_debug.m:
compiler/parse_tree_out.m:
compiler/peephole.m:
compiler/recompilation.usage.m:
compiler/resolve_unify_functor.m:
compiler/stack_layout.m:
compiler/structure_reuse.direct.choose_reuse.m:
compiler/switch_util.m:
compiler/typecheck.m:
compiler/unify_proc.m:
compiler/unused_imports.m:
compiler/xml_documentation.m:
    Conform to the changes above.

compiler/llds_out_util.m:
    Add a comment.

compiler/ml_code_util.m:
    Factor out some common code.

runtime/mercury_type_info.h:
    Allocate special values of the MR_arg_bits field of the MR_DuArgLocn type
    to designate arguments as two word int64/uint64s, as sub-word-sized
    arguments of types {int,uint}{8,16,32}, or as arguments of dummy types.
    (We already had a special value for two word float arguments.)

    Document the list of places that know about this code, so that they
    can be updated if and when it changes.

library/construct.m:
    Handle the construction of terms with two-word int64/uint64 arguments,
    with packed {int,uint}{8,16,32} arguments, and with dummy arguments.

    Factor out the code common to the sectag-present and sectag-absent cases,
    to make it possible to do the above in just *one* place.

library/store.m:
    Add an XXX to a place that I don't think handles two word arguments
    correctly. (I think this is an old bug.)

runtime/mercury_deconstruct.c:
    Handle the deconstruction of terms with two-word int64/uint64 arguments,
    with packed {int,uint}{8,16,32} arguments, and with dummy arguments.

runtime/mercury_deep_copy_body.h:
    Handle the copying of terms with two-word int64/uint64 arguments,
    with packed {int,uint}{8,16,32} arguments, and with dummy arguments.

    Give a macro a more descriptive name.

runtime/mercury_type_info.c:
    Handle taking the size of terms with two-word int64/uint64 arguments,
    with packed {int,uint}{8,16,32} arguments, and with dummy arguments.

runtime/mercury.h:
    Put related definitions next to each other.

runtime/mercury_deconstruct.h:
runtime/mercury_ml_expand_body.h:
    Fix indentation.

tests/hard_coded/construct_test.{m,exp}:
    Add to this test case a test of the construction, via the library's
    construct.m module, of terms containing packed sub-word-sized integers,
    and packed dummies.

tests/hard_coded/deconstruct_arg.{m,exp}:
    Convert the source code of this test case to state variable notation,
    and update the line number references (in the names of predicates created
    from lambda expressions) accordingly.

tests/hard_coded/uint64_ground_term.{m,exp}:
    A new test case to check that uint64 values too large to be int64 values
    can be stored in static structures.

tests/hard_coded/Mmakefile:
    Enable the new test case.
2018-05-05 13:22:19 +02:00

642 lines
23 KiB
Mathematica
Raw Blame History

%-----------------------------------------------------------------------------%
% vim: ft=mercury ts=4 sw=4 et
%-----------------------------------------------------------------------------%
% Copyright (C) 1995-2007, 2009-2011 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 ll_backend.opt_util.
:- import_module parse_tree.prog_data_foreign.
:- import_module bool.
:- import_module int.
:- import_module require.
:- import_module string.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
build_livemap(Instrs, MaybeLivemap) :-
% 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.
map.init(Livemap0),
list.reverse(Instrs, BackInstrs),
build_livemap_fixpoint(BackInstrs, Livemap0, 0, MaybeLivemap).
:- pred build_livemap_fixpoint(list(instruction)::in, livemap::in, int::in,
maybe(livemap)::out) is det.
build_livemap_fixpoint(BackInstrs, Livemap0, CurIteration, MaybeLivemap) :-
set.init(Livevals0),
livemap_do_build(BackInstrs, Livevals0, no, ContainsBadUserCode,
Livemap0, Livemap1),
(
ContainsBadUserCode = yes,
MaybeLivemap = no
;
ContainsBadUserCode = no,
( if livemap.equal_livemaps(Livemap0, Livemap1) then
MaybeLivemap = yes(Livemap1)
else
( if CurIteration < livemap_iteration_limit then
build_livemap_fixpoint(BackInstrs, Livemap1, CurIteration + 1,
MaybeLivemap)
else
MaybeLivemap = no
)
)
).
% 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).
% Don't iterate the map building process more than this many times.
%
:- func livemap_iteration_limit = int.
livemap_iteration_limit = 5.
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
% 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($pred, "livevals found in backward scan in build_livemap")
;
Uinstr0 = block(_, _, _),
unexpected($pred, "block found in backward scan")
;
( 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.
set.delete(Lval, !Livevals),
opt_util.lval_access_rvals(Lval, Rvals),
livemap.make_live_in_rvals([Rval | Rvals], !Livevals)
;
Uinstr0 = lc_create_loop_control(_NumSlots, Lval),
set.delete(Lval, !Livevals)
;
Uinstr0 = lc_wait_free_slot(LCRval, LCSLval, _InternalLabel),
set.delete(LCSLval, !Livevals),
opt_util.lval_access_rvals(LCSLval, LCSAccessRvals),
livemap.make_live_in_rvals([LCRval | LCSAccessRvals], !Livevals)
;
Uinstr0 = lc_spawn_off(LCRval, LCSRval, Child),
livemap.make_live_in_rvals([LCRval, LCSRval], !Livevals),
% Everything that is live at Child is live before this instruction.
livemap_insert_label_livevals(!.Livemap, Child, !Livevals)
;
Uinstr0 = lc_join_and_terminate(LCRval, LCSRval),
% Since this instruction terminates its context, nothing is live
% before it except its arguments and their components.
livemap.make_live_in_rvals([LCRval, LCSRval], set.init, !:Livevals)
;
Uinstr0 = llcall(_, _, _, _, _, _),
livemap.look_for_livevals(!Instrs, !Livevals, "call", yes, _)
;
Uinstr0 = mkframe(_, _)
;
Uinstr0 = label(Label),
map.set(Label, !.Livevals, !Livemap)
;
Uinstr0 = goto(CodeAddr),
LivevalsNeeded = opt_util.livevals_addr(CodeAddr),
livemap.look_for_livevals(!Instrs, !Livevals, "goto",
LivevalsNeeded, Found),
(
Found = yes
;
Found = no,
(
CodeAddr = code_label(Label),
livemap_insert_label_livevals(!.Livemap, Label,
set.init, !:Livevals)
;
( CodeAddr = do_redo
; CodeAddr = do_fail
; CodeAddr = do_not_reached
)
;
( CodeAddr = code_imported_proc(_)
; CodeAddr = code_succip
; CodeAddr = do_succeed(_)
; CodeAddr = do_trace_redo_fail_shallow
; CodeAddr = do_trace_redo_fail_deep
; CodeAddr = do_call_closure(_)
; CodeAddr = do_call_class_method(_)
),
unexpected($pred, "unknown code_addr type")
)
),
livemap_special_code_addr(CodeAddr, MaybeSpecial),
(
MaybeSpecial = yes(Special),
set.insert(Special, !Livevals)
;
MaybeSpecial = no
)
;
Uinstr0 = computed_goto(Rval, MaybeLabels),
livemap.make_live_in_rvals([Rval], set.init, !:Livevals),
list.foldl(livemap_insert_maybe_label_livevals(!.Livemap), MaybeLabels,
!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),
( if CodeAddr = code_label(Label) then
livemap_insert_label_livevals(!.Livemap, Label, !Livevals)
else
true
)
),
livemap_special_code_addr(CodeAddr, MaybeSpecial),
(
MaybeSpecial = yes(Special),
set.insert(Special, !Livevals)
;
MaybeSpecial = no
)
;
Uinstr0 = save_maxfr(Lval),
set.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, _, _, SizeRval, _, _, MaybeRegionRval,
MaybeReuse),
% 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(Lval, !Livevals),
opt_util.lval_access_rvals(Lval, Rvals),
livemap.make_live_in_rvals(Rvals, !Livevals),
livemap.make_live_in_rval(SizeRval, !Livevals),
(
MaybeRegionRval = no
;
MaybeRegionRval = yes(RegionRval),
livemap.make_live_in_rval(RegionRval, !Livevals)
),
(
MaybeReuse = no_llds_reuse
;
MaybeReuse = llds_reuse(ReuseRval, MaybeFlagLval),
livemap.make_live_in_rval(ReuseRval, !Livevals),
(
MaybeFlagLval = no
;
MaybeFlagLval = yes(FlagLval),
set.delete(FlagLval, !Livevals),
opt_util.lval_access_rvals(FlagLval, FlagRvals),
livemap.make_live_in_rvals(FlagRvals, !Livevals)
)
)
;
Uinstr0 = mark_hp(Lval),
set.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),
set.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),
set.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($pred, "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,
( if Code = "" then
true
else
% 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_alloc_id(_)
;
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,
( if Code = "" then
true
else
% 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, _, _),
( if Rval = lval(Lval) then
livemap_insert_proper_liveval(Lval, !Livevals)
else
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),
( if Instrs1 = [llds_instr(livevals(Livevals1), _) | Instrs2] then
livemap_filter_livevals(Livevals1, !:Livevals),
Instrs = Instrs2,
Found = yes
else
(
Compulsory = yes,
unexpected($pred, Site ++ " not preceded by livevals")
;
Compulsory = no,
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(CodeAddr, MaybeSpecial) :-
(
( CodeAddr = code_label(_)
; CodeAddr = code_imported_proc(_)
; CodeAddr = do_trace_redo_fail_shallow
; CodeAddr = do_trace_redo_fail_deep
; CodeAddr = do_fail
; CodeAddr = do_call_closure(_)
; CodeAddr = do_call_class_method(_)
; CodeAddr = do_not_reached
),
MaybeSpecial = no
;
CodeAddr = code_succip,
MaybeSpecial = yes(succip)
;
CodeAddr = do_succeed(_),
MaybeSpecial = yes(succip_slot(lval(curfr)))
;
CodeAddr = do_redo,
MaybeSpecial = yes(redoip_slot(lval(maxfr)))
).
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
:- 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(Rval, !Live) :-
(
Rval = lval(Lval),
% XXX Maybe we should treat mem_refs the same way as field refs.
( if Lval = field(_, _, _) then
true
else
set.insert(Lval, !Live)
),
opt_util.lval_access_rvals(Lval, AccessRvals),
make_live_in_rvals(AccessRvals, !Live)
;
( Rval = mkword_hole(_)
; Rval = const(_)
)
;
( Rval = mkword(_, SubRval)
; Rval = cast(_, SubRval)
; Rval = unop(_, SubRval)
),
make_live_in_rval(SubRval, !Live)
;
Rval = binop(_, SubRvalA, SubRvalB),
make_live_in_rval(SubRvalA, !Live),
make_live_in_rval(SubRvalB, !Live)
;
Rval = var(_),
unexpected($pred, "var rval should not propagate to the optimizer")
;
Rval = mem_addr(MemRef),
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(MemRef, !Live) :-
(
MemRef = stackvar_ref(Rval),
make_live_in_rval(Rval, !Live)
;
MemRef = framevar_ref(Rval),
make_live_in_rval(Rval, !Live)
;
MemRef = heap_ref(CellPtrRval, _MaybeTag, FieldNumRval),
make_live_in_rval(CellPtrRval, !Live),
make_live_in_rval(FieldNumRval, !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_maybe_label_livevals(livemap::in, maybe(label)::in,
lvalset::in, lvalset::out) is det.
livemap_insert_maybe_label_livevals(Livemap, MaybeLabel, !Livevals) :-
(
MaybeLabel = yes(Label),
livemap_insert_label_livevals(Livemap, Label, !Livevals)
;
MaybeLabel = no
).
:- pred livemap_insert_label_livevals(livemap::in, label::in,
lvalset::in, lvalset::out) is det.
livemap_insert_label_livevals(Livemap, Label, !Livevals) :-
( if map.search(Livemap, Label, LabelLivevals) then
set.to_sorted_list(LabelLivevals, Livelist),
livemap_insert_proper_livevals(Livelist, !Livevals)
else
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) :-
( if Live = field(_, _, _) then
true
else
set.insert(Live, !Livevals)
).
%-----------------------------------------------------------------------------%
:- end_module ll_backend.livemap.
%-----------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink