[m-rev.] for review: disable value numbering
Zoltan Somogyi
zs at cs.mu.OZ.AU
Fri May 11 15:14:41 AEST 2001
Disable value numbering, now that it is no longer needed. The value numbering
source files are not deleted from the CVS repository, since that would make
their restoration (in the unlikely event that this is needed) inconvenient,
but they will no longer be compiled or included in compiler executables.
doc/user_guide.texi:
compiler/options.m:
Delete the options dealing with value numbering.
compiler/optimize.m:
Do not invoke value numbering.
compiler/handle_options.m:
Delete code that handles implications involving value numbering.
compiler/opt_debug.m:
Delete code for debugging value numbering, since leaving it in
would require importing value numbering modules and would thus drag
them into the compiler executable.
Zoltan.
cvs diff: Diffing .
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/doc
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/handle_options.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/handle_options.m,v
retrieving revision 1.108
diff -u -b -r1.108 handle_options.m
--- compiler/handle_options.m 2001/05/08 03:04:57 1.108
+++ compiler/handle_options.m 2001/05/11 04:07:07
@@ -484,17 +484,6 @@
% The following option selects a special-case
% code generator that cannot (yet) implement tracing.
globals__io_set_option(middle_rec, bool(no)),
- % Tracing inserts C code into the generated LLDS.
- % Value numbering cannot optimize such LLDS code.
- % (If it tried, it would get it wrong due to the
- % absence of liveness annotations on the introduced
- % labels.) We turn value numbering off now so that
- % we don't have to discover this fact anew
- % for each procedure.
- globals__io_set_option(optimize_value_number, bool(no)),
- % Without value numbering, the eager code generator
- % generates better code than the lazy code generator.
- globals__io_set_option(lazy_code, bool(no)),
% The following options cause the info required
% by tracing to be generated.
globals__io_set_option(trace_stack_layout, bool(yes)),
@@ -540,11 +529,6 @@
% XXX deforestation does not perform folding on polymorphic
% predicates correctly with --body-typeinfo-liveness.
option_implies(body_typeinfo_liveness, deforestation, bool(no)),
-
- % XXX value numbering implements the wrong semantics for LLDS
- % operations involving tickets, which are generated only with
- % --use-trail.
- option_implies(use_trail, optimize_value_number, bool(no)),
% XXX if trailing is enabled, middle recursion optimization
% can generate code which does not allocate a stack frame
Index: compiler/opt_debug.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/opt_debug.m,v
retrieving revision 1.114
diff -u -b -r1.114 opt_debug.m
--- compiler/opt_debug.m 2001/04/24 03:59:00 1.114
+++ compiler/opt_debug.m 2001/05/11 04:13:53
@@ -14,9 +14,8 @@
:- interface.
-:- import_module llds, vn_type, vn_table, livemap.
+:- import_module llds, livemap.
:- import_module code_model, rtti, layout, builtin_ops.
-:- import_module atsort.
:- import_module io, bool, list, assoc_list, std_util.
@@ -26,21 +25,6 @@
:- pred opt_debug__dump_instrs(bool, list(instruction), io__state, io__state).
:- mode opt_debug__dump_instrs(in, in, di, uo) is det.
-:- pred opt_debug__dump_node_relmap(relmap(vn_node), string).
-:- mode opt_debug__dump_node_relmap(in, out) is det.
-
-:- pred opt_debug__dump_nodemap(assoc_list(vn_node, list(vn_node)), string).
-:- mode opt_debug__dump_nodemap(in, out) is det.
-
-:- pred opt_debug__dump_nodelist(list(vn_node), string).
-:- mode opt_debug__dump_nodelist(in, out) is det.
-
-:- pred opt_debug__dump_longnodelist(list(vn_node), string).
-:- mode opt_debug__dump_longnodelist(in, out) is det.
-
-:- pred opt_debug__dump_node(vn_node, string).
-:- mode opt_debug__dump_node(in, out) is det.
-
:- pred opt_debug__dump_intlist(list(int), string).
:- mode opt_debug__dump_intlist(in, out) is det.
@@ -56,72 +40,9 @@
:- pred opt_debug__dump_livelist(list(lval), string).
:- mode opt_debug__dump_livelist(in, out) is det.
-:- pred opt_debug__dump_ctrlmap(ctrlmap, string).
-:- mode opt_debug__dump_ctrlmap(in, out) is det.
-
-:- pred opt_debug__dump_ctrl_list(assoc_list(int, vn_instr), string).
-:- mode opt_debug__dump_ctrl_list(in, out) is det.
-
-:- pred opt_debug__dump_vninstr(vn_instr, string).
-:- mode opt_debug__dump_vninstr(in, out) is det.
-
-:- pred opt_debug__dump_flushmap(flushmap, string).
-:- mode opt_debug__dump_flushmap(in, out) is det.
-
-:- pred opt_debug__dump_flush_list(assoc_list(int, flushmapentry), string).
-:- mode opt_debug__dump_flush_list(in, out) is det.
-
-:- pred opt_debug__dump_flush_entry(assoc_list(vnlval, int), string).
-:- mode opt_debug__dump_flush_entry(in, out) is det.
-
-:- pred opt_debug__dump_useful_vns(vn_tables, string).
-:- mode opt_debug__dump_useful_vns(in, out) is det.
-
-:- pred opt_debug__dump_useful_locs(vn_tables, string).
-:- mode opt_debug__dump_useful_locs(in, out) is det.
-
-:- pred opt_debug__dump_vn_locs(vn_tables, string).
-:- mode opt_debug__dump_vn_locs(in, out) is det.
-
-:- pred opt_debug__dump_tables(vn_tables, string).
-:- mode opt_debug__dump_tables(in, out) is det.
-
-:- pred opt_debug__dump_lval_to_vn(assoc_list(vnlval, vn), string).
-:- mode opt_debug__dump_lval_to_vn(in, out) is det.
-
-:- pred opt_debug__dump_rval_to_vn(assoc_list(vnrval, vn), string).
-:- mode opt_debug__dump_rval_to_vn(in, out) is det.
-
-:- pred opt_debug__dump_vn_to_rval(assoc_list(vn, vnrval), string).
-:- mode opt_debug__dump_vn_to_rval(in, out) is det.
-
-:- pred opt_debug__dump_vn_to_uses(assoc_list(vn, list(vn_src)), bool, string).
-:- mode opt_debug__dump_vn_to_uses(in, in, out) is det.
-
-:- pred opt_debug__dump_vn_to_locs(assoc_list(vn, list(vnlval)), string).
-:- mode opt_debug__dump_vn_to_locs(in, out) is det.
-
-:- pred opt_debug__dump_uses_list(list(vn_src), string).
-:- mode opt_debug__dump_uses_list(in, out) is det.
-
-:- pred opt_debug__dump_use(vn_src, string).
-:- mode opt_debug__dump_use(in, out) is det.
-
-:- pred opt_debug__dump_vn(vn, string).
-:- mode opt_debug__dump_vn(in, out) is det.
-
-:- pred opt_debug__dump_vnlvals(list(vnlval), string).
-:- mode opt_debug__dump_vnlvals(in, out) is det.
-
:- pred opt_debug__dump_reg(reg_type, int, string).
:- mode opt_debug__dump_reg(in, in, out) is det.
-:- pred opt_debug__dump_vnlval(vnlval, string).
-:- mode opt_debug__dump_vnlval(in, out) is det.
-
-:- pred opt_debug__dump_vnrval(vnrval, string).
-:- mode opt_debug__dump_vnrval(in, out) is det.
-
:- pred opt_debug__dump_lval(lval, string).
:- mode opt_debug__dump_lval(in, out) is det.
@@ -200,7 +121,7 @@
:- import_module prog_out.
:- import_module hlds_pred.
-:- import_module llds_out, opt_util, vn_util.
+:- import_module llds_out, opt_util.
:- import_module globals, options.
:- import_module int, set, map, string.
@@ -238,42 +159,6 @@
output_instruction_and_comment(Uinstr, Comment, PrintComments),
opt_debug__dump_instrs_2(Instrs, PrintComments).
-opt_debug__dump_node_relmap(Relmap, Str) :-
- map__to_assoc_list(Relmap, Nodemap),
- opt_debug__dump_nodemap(Nodemap, Str).
-
-opt_debug__dump_nodemap([], "").
-opt_debug__dump_nodemap([Node - Nodelist | Nodemap], Str) :-
- opt_debug__dump_node(Node, N_str),
- opt_debug__dump_nodelist(Nodelist, Nl_str),
- opt_debug__dump_nodemap(Nodemap, S2_str),
- string__append_list([N_str, " -> ", Nl_str, "\n", S2_str], Str).
-
-opt_debug__dump_nodelist([], "").
-opt_debug__dump_nodelist([H | T], Str) :-
- opt_debug__dump_node(H, H_str),
- opt_debug__dump_nodelist(T, T_str),
- string__append_list([H_str, " ", T_str], Str).
-
-opt_debug__dump_longnodelist([], "").
-opt_debug__dump_longnodelist([H | T], Str) :-
- opt_debug__dump_node(H, H_str),
- opt_debug__dump_longnodelist(T, T_str),
- string__append_list([H_str, "\n", T_str], Str).
-
-opt_debug__dump_node(node_shared(Vn), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["shared vn ", Vn_str], Str).
-opt_debug__dump_node(node_lval(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, V_str),
- string__append_list(["vnlval ", V_str], Str).
-opt_debug__dump_node(node_origlval(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, V_str),
- string__append_list(["orig vnlval ", V_str], Str).
-opt_debug__dump_node(node_ctrl(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["ctrl ", N_str], Str).
-
opt_debug__dump_intlist([], "").
opt_debug__dump_intlist([H | T], Str) :-
string__int_to_string(H, H_str),
@@ -301,298 +186,12 @@
opt_debug__dump_livelist(Lvallist, L2_str),
string__append_list([" ", L_str, L2_str], Str).
-opt_debug__dump_ctrlmap(Ctrlmap, Str) :-
- map__to_assoc_list(Ctrlmap, Ctrllist),
- opt_debug__dump_ctrl_list(Ctrllist, C_str),
- string__append("\nCtrl map\n", C_str, Str).
-
-opt_debug__dump_ctrl_list([], "").
-opt_debug__dump_ctrl_list([N - VnInstr | Ctrllist], Str) :-
- string__int_to_string(N, N_str),
- opt_debug__dump_vninstr(VnInstr, Vni_str),
- opt_debug__dump_ctrl_list(Ctrllist, Str2),
- string__append_list([N_str, " -> ", Vni_str, "\n", Str2], Str).
-
-opt_debug__dump_vninstr(vn_livevals(_), Str) :-
- string__append_list(["livevals(...)"], Str).
-opt_debug__dump_vninstr(vn_call(Proc, Ret, _, _, _, _), Str) :-
- opt_debug__dump_code_addr(Proc, P_str),
- opt_debug__dump_code_addr(Ret, R_str),
- string__append_list(["call(", P_str, ", ", R_str, ")"], Str).
-opt_debug__dump_vninstr(vn_mkframe(_, _), "mkframe").
-opt_debug__dump_vninstr(vn_label(Label), Str) :-
- opt_debug__dump_label(Label, L_str),
- string__append_list(["label(", L_str, ")"], Str).
-opt_debug__dump_vninstr(vn_goto(CodeAddr), Str) :-
- opt_debug__dump_code_addr(CodeAddr, C_str),
- string__append_list(["goto(", C_str, ")"], Str).
-opt_debug__dump_vninstr(vn_computed_goto(Vn, _), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["computed_goto(", Vn_str, ")"], Str).
-opt_debug__dump_vninstr(vn_if_val(Vn, CodeAddr), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- opt_debug__dump_code_addr(CodeAddr, L_str),
- string__append_list(["if_val(", Vn_str, ", ", L_str, ")"], Str).
-opt_debug__dump_vninstr(vn_mark_hp(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, V_str),
- string__append_list(["mark_hp(", V_str, ")"], Str).
-opt_debug__dump_vninstr(vn_restore_hp(Vn), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["restore_hp(", Vn_str, ")"], Str).
-opt_debug__dump_vninstr(vn_free_heap(Vn), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["free_heap(", Vn_str, ")"], Str).
-opt_debug__dump_vninstr(vn_store_ticket(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, V_str),
- string__append_list(["store_ticket(", V_str, ")"], Str).
-opt_debug__dump_vninstr(vn_reset_ticket(Vn, _Reason), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["reset_ticket(", Vn_str, ", _)"], Str).
-opt_debug__dump_vninstr(vn_discard_ticket, "discard_ticket").
-opt_debug__dump_vninstr(vn_prune_ticket, "prune_ticket").
-opt_debug__dump_vninstr(vn_mark_ticket_stack(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, V_str),
- string__append_list(["mark_ticket_stack(", V_str, ")"], Str).
-opt_debug__dump_vninstr(vn_prune_tickets_to(Vn), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["prune_tickets_to(", Vn_str, ", _)"], Str).
-opt_debug__dump_vninstr(vn_incr_sp(N, _), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["incr_sp(", N_str, ")"], Str).
-opt_debug__dump_vninstr(vn_decr_sp(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["decr_sp(", N_str, ")"], Str).
-
-opt_debug__dump_flushmap(Flushmap, Str) :-
- map__to_assoc_list(Flushmap, Flushlist),
- opt_debug__dump_flush_list(Flushlist, F_str),
- string__append("\nFlush map\n", F_str, Str).
-
-opt_debug__dump_flush_list([], "").
-opt_debug__dump_flush_list([N - FlushEntry | FlushList], Str) :-
- string__int_to_string(N, N_str),
- map__to_assoc_list(FlushEntry, FlushEntryList),
- opt_debug__dump_flush_entry(FlushEntryList, Str1),
- opt_debug__dump_flush_list(FlushList, Str2),
- string__append_list([N_str, " -> ", Str1, "\n", Str2], Str).
-
-opt_debug__dump_flush_entry([], "").
-opt_debug__dump_flush_entry([Vnlval - Vn | FlushEntry], Str) :-
- opt_debug__dump_vnlval(Vnlval, L_str),
- opt_debug__dump_vn(Vn, Vn_str),
- opt_debug__dump_flush_entry(FlushEntry, F_str),
- string__append_list([" ", L_str, "/", Vn_str, F_str], Str).
-
-opt_debug__dump_useful_vns(VnTables, Str) :-
- vn_table__get_vn_to_uses_table(VnTables, Vn_to_uses_table),
- map__to_assoc_list(Vn_to_uses_table, Vn_to_uses_list),
- opt_debug__dump_vn_to_uses(Vn_to_uses_list, no, Str).
-
-opt_debug__dump_useful_locs(VnTables, Str) :-
- vn_table__get_loc_to_vn_table(VnTables, Loc_to_vn_table),
- map__to_assoc_list(Loc_to_vn_table, Loc_to_vn_list),
- opt_debug__dump_lval_to_vn(Loc_to_vn_list, Str).
-
-opt_debug__dump_vn_locs(VnTables, Str) :-
- vn_table__get_vn_to_locs_table(VnTables, Vn_to_locs_table),
- map__to_assoc_list(Vn_to_locs_table, Vn_to_locs_list),
- opt_debug__dump_vn_to_locs(Vn_to_locs_list, Str).
-
-opt_debug__dump_tables(VnTables, Str) :-
- vn_table__get_next_vn(VnTables, NextVn),
- vn_table__get_lval_to_vn_table(VnTables, Lval_to_vn_table),
- vn_table__get_rval_to_vn_table(VnTables, Rval_to_vn_table),
- vn_table__get_vn_to_rval_table(VnTables, Vn_to_rval_table),
- vn_table__get_vn_to_uses_table(VnTables, Vn_to_uses_table),
- vn_table__get_vn_to_locs_table(VnTables, Vn_to_locs_table),
- vn_table__get_loc_to_vn_table(VnTables, Loc_to_vn_table),
- string__int_to_string(NextVn, Next_vn_str),
- map__to_assoc_list(Lval_to_vn_table, Lval_to_vn_list),
- map__to_assoc_list(Rval_to_vn_table, Rval_to_vn_list),
- map__to_assoc_list(Vn_to_rval_table, Vn_to_rval_list),
- map__to_assoc_list(Vn_to_uses_table, Vn_to_uses_list),
- map__to_assoc_list(Vn_to_locs_table, Vn_to_locs_list),
- map__to_assoc_list(Loc_to_vn_table, Loc_to_vn_list),
- opt_debug__dump_lval_to_vn(Lval_to_vn_list, Lval_to_vn_str),
- opt_debug__dump_rval_to_vn(Rval_to_vn_list, _Rval_to_vn_str),
- opt_debug__dump_vn_to_rval(Vn_to_rval_list, Vn_to_rval_str),
- opt_debug__dump_vn_to_uses(Vn_to_uses_list, yes, Vn_to_uses_str),
- opt_debug__dump_vn_to_locs(Vn_to_locs_list, Vn_to_locs_str),
- opt_debug__dump_lval_to_vn(Loc_to_vn_list, Loc_to_vn_str),
- string__append_list([
- "\nNext vn\n", Next_vn_str, "\n",
- % "\nRval to vn\n", Rval_to_vn_str,
- "\nVn to rval\n", Vn_to_rval_str,
- "\nVn to uses\n", Vn_to_uses_str,
- "\nLval to vn\n", Lval_to_vn_str,
- "\nVn to locs\n", Vn_to_locs_str,
- "\nLoc to vn\n", Loc_to_vn_str
- ], Str).
-
-opt_debug__dump_lval_to_vn([], "").
-opt_debug__dump_lval_to_vn([Vnlval - Vn | Lval_to_vn_list], Str) :-
- opt_debug__dump_lval_to_vn(Lval_to_vn_list, Tail_str),
- opt_debug__dump_vnlval(Vnlval, Vnlval_str),
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list([Vnlval_str, " -> ", Vn_str, "\n", Tail_str], Str).
-
-opt_debug__dump_rval_to_vn([], "").
-opt_debug__dump_rval_to_vn([Vnrval - Vn | Rval_to_vn_list], Str) :-
- opt_debug__dump_rval_to_vn(Rval_to_vn_list, Tail_str),
- opt_debug__dump_vnrval(Vnrval, Vnrval_str),
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list([Vnrval_str, " -> ", Vn_str, "\n", Tail_str], Str).
-
-opt_debug__dump_vn_to_rval([], "").
-opt_debug__dump_vn_to_rval([Vn - Vnrval | Vn_to_rval_list], Str) :-
- opt_debug__dump_vn_to_rval(Vn_to_rval_list, Tail_str),
- opt_debug__dump_vn(Vn, Vn_str),
- opt_debug__dump_vnrval(Vnrval, Vnrval_str),
- string__append_list([Vn_str, " -> ", Vnrval_str, "\n", Tail_str], Str).
-
-opt_debug__dump_vn_to_uses([], _, "").
-opt_debug__dump_vn_to_uses([Vn - Uses | Vn_to_uses_list], PrintUnused, Str) :-
- opt_debug__dump_vn_to_uses(Vn_to_uses_list, PrintUnused, Tail_str),
- ( Uses = [], PrintUnused = no ->
- Str = Tail_str
- ;
- opt_debug__dump_vn(Vn, Vn_str),
- opt_debug__dump_uses_list(Uses, Uses_str),
- string__append_list([Vn_str, " -> ", Uses_str, "\n", Tail_str],
- Str)
- ).
-
-opt_debug__dump_vn_to_locs([], "").
-opt_debug__dump_vn_to_locs([Vn - Vn_locs | Vn_to_locs_list], Str) :-
- opt_debug__dump_vn_to_locs(Vn_to_locs_list, Tail_str),
- opt_debug__dump_vn(Vn, Vn_str),
- opt_debug__dump_vnlvals(Vn_locs, Vn_locs_str),
- string__append_list([Vn_str, " -> ", Vn_locs_str, "\n", Tail_str], Str).
-
-opt_debug__dump_uses_list([], "").
-opt_debug__dump_uses_list([Use | Uses], Str) :-
- opt_debug__dump_use(Use, Str1),
- opt_debug__dump_uses_list(Uses, Str2),
- string__append_list([Str1, ", ", Str2], Str).
-
-opt_debug__dump_use(src_ctrl(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["src_ctrl(", N_str, ")"], Str).
-opt_debug__dump_use(src_liveval(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, Vnlval_str),
- string__append_list(["src_liveval(", Vnlval_str, ")"], Str).
-opt_debug__dump_use(src_access(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, Vnlval_str),
- string__append_list(["src_access(", Vnlval_str, ")"], Str).
-opt_debug__dump_use(src_vn(Vn), Str) :-
- opt_debug__dump_vn(Vn, Vn_str),
- string__append_list(["src_vn(", Vn_str, ")"], Str).
-
-opt_debug__dump_vn(Vn, Str) :-
- string__int_to_string(Vn, Str).
-
-opt_debug__dump_vnlvals([], "").
-opt_debug__dump_vnlvals([Lval | Lvals], Str) :-
- opt_debug__dump_vnlval(Lval, Lval_str),
- opt_debug__dump_vnlvals(Lvals, Tail_str),
- string__append_list([" ", Lval_str, Tail_str], Str).
-
opt_debug__dump_reg(r, N, Str) :-
string__int_to_string(N, N_str),
string__append_list(["r(", N_str, ")"], Str).
opt_debug__dump_reg(f, N, Str) :-
string__int_to_string(N, N_str),
string__append_list(["f(", N_str, ")"], Str).
-
-opt_debug__dump_vnlval(vn_reg(Type, Num), Str) :-
- opt_debug__dump_reg(Type, Num, R_str),
- string__append_list(["vn_reg(", R_str, ")"], Str).
-opt_debug__dump_vnlval(vn_temp(Type, Num), Str) :-
- opt_debug__dump_reg(Type, Num, R_str),
- string__append_list(["vn_temp(", R_str, ")"], Str).
-opt_debug__dump_vnlval(vn_stackvar(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["vn_stackvar(", N_str, ")"], Str).
-opt_debug__dump_vnlval(vn_framevar(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["vn_framevar(", N_str, ")"], Str).
-opt_debug__dump_vnlval(vn_succip, Str) :-
- string__append_list(["vn_succip"], Str).
-opt_debug__dump_vnlval(vn_maxfr, Str) :-
- string__append_list(["vn_maxfr"], Str).
-opt_debug__dump_vnlval(vn_curfr, Str) :-
- string__append_list(["vn_curfr"], Str).
-opt_debug__dump_vnlval(vn_prevfr(V), Str) :-
- string__int_to_string(V, V_str),
- string__append_list(["vn_prevfr(", V_str, ")"], Str).
-opt_debug__dump_vnlval(vn_succfr(V), Str) :-
- string__int_to_string(V, V_str),
- string__append_list(["vn_succfr(", V_str, ")"], Str).
-opt_debug__dump_vnlval(vn_redofr(V), Str) :-
- string__int_to_string(V, V_str),
- string__append_list(["vn_redofr(", V_str, ")"], Str).
-opt_debug__dump_vnlval(vn_redoip(V), Str) :-
- string__int_to_string(V, V_str),
- string__append_list(["vn_redoip(", V_str, ")"], Str).
-opt_debug__dump_vnlval(vn_succip(V), Str) :-
- string__int_to_string(V, V_str),
- string__append_list(["vn_succip(", V_str, ")"], Str).
-opt_debug__dump_vnlval(vn_hp, Str) :-
- string__append_list(["vn_hp"], Str).
-opt_debug__dump_vnlval(vn_sp, Str) :-
- string__append_list(["vn_sp"], Str).
-opt_debug__dump_vnlval(vn_field(MT, N, F), Str) :-
- ( MT = yes(T) ->
- string__int_to_string(T, T_str)
- ;
- T_str = "no"
- ),
- string__int_to_string(N, N_str),
- string__int_to_string(F, F_str),
- string__append_list(["vn_field(", T_str, ", ", N_str, ", ",
- F_str, ")"], Str).
-opt_debug__dump_vnlval(vn_mem_ref(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["vn_mem_ref(", N_str, ")"], Str).
-
-opt_debug__dump_vnrval(vn_origlval(Vnlval), Str) :-
- opt_debug__dump_vnlval(Vnlval, Lval_str),
- string__append_list(["vn_origlval(", Lval_str, ")"], Str).
-opt_debug__dump_vnrval(vn_mkword(T, N), Str) :-
- string__int_to_string(T, T_str),
- string__int_to_string(N, N_str),
- string__append_list(["vn_mkword(", T_str, ", ", N_str, ")"], Str).
-opt_debug__dump_vnrval(vn_const(C), Str) :-
- opt_debug__dump_const(C, C_str),
- string__append_list(["vn_const(", C_str, ")"], Str).
-opt_debug__dump_vnrval(vn_create(T, MA, _TA, _U, L, _M), Str) :-
- string__int_to_string(T, T_str),
- opt_debug__dump_maybe_rvals(MA, 3, MA_str),
- string__int_to_string(L, L_str),
- string__append_list(["vn_create(", T_str, ", ", MA_str, ", ",
- L_str, ")"], Str).
-opt_debug__dump_vnrval(vn_unop(O, N), Str) :-
- opt_debug__dump_unop(O, O_str),
- string__int_to_string(N, N_str),
- string__append_list(["vn_unop(", O_str, ", ", N_str, ")"], Str).
-opt_debug__dump_vnrval(vn_binop(O, N1, N2), Str) :-
- opt_debug__dump_binop(O, O_str),
- string__int_to_string(N1, N1_str),
- string__int_to_string(N2, N2_str),
- string__append_list(["vn_binop(", O_str, ", ", N1_str, ", ",
- N2_str, ")"], Str).
-opt_debug__dump_vnrval(vn_stackvar_addr(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["vn_stackvar_addr(", N_str, ")"], Str).
-opt_debug__dump_vnrval(vn_framevar_addr(N), Str) :-
- string__int_to_string(N, N_str),
- string__append_list(["vn_framevar_addr(", N_str, ")"], Str).
-opt_debug__dump_vnrval(vn_heap_addr(B, T, N), Str) :-
- string__int_to_string(B, B_str),
- string__int_to_string(T, T_str),
- string__int_to_string(N, N_str),
- string__append_list(["vn_heap_addr(", B_str, ", ", T_str, ", ",
- N_str, ")"], Str).
opt_debug__dump_lval(reg(Type, Num), Str) :-
opt_debug__dump_reg(Type, Num, R_str),
Index: compiler/optimize.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/optimize.m,v
retrieving revision 1.26
diff -u -b -r1.26 optimize.m
--- compiler/optimize.m 2001/04/24 03:59:01 1.26
+++ compiler/optimize.m 2001/05/11 04:16:02
@@ -28,8 +28,8 @@
:- implementation.
:- import_module jumpopt, labelopt, dupelim, peephole.
-:- import_module frameopt, delay_slot, value_number, use_local_vars, options.
-:- import_module globals, passes_aux, opt_util, opt_debug, vn_debug.
+:- import_module frameopt, delay_slot, use_local_vars, options.
+:- import_module globals, passes_aux, opt_util, opt_debug.
:- import_module wrap_blocks, hlds_pred, llds_out, continuation_info.
:- import_module bool, int, string.
@@ -45,9 +45,7 @@
ProcLabel, C0, ContainsReconstruction) },
optimize__init_opt_debug_info(Name, Arity, PredProcId, Instrs0, C0,
OptDebugInfo0),
- globals__io_lookup_int_option(optimize_repeat, AllRepeat),
- globals__io_lookup_int_option(optimize_vnrepeat, VnRepeat),
- globals__io_lookup_bool_option(optimize_value_number, ValueNumber),
+ globals__io_lookup_int_option(optimize_repeat, Repeat),
{
global_data_maybe_get_proc_layout(GlobalData, PredProcId,
ProcLayout)
@@ -58,23 +56,10 @@
;
set__init(LayoutLabelSet)
},
- ( { ValueNumber = yes } ->
- { NovnRepeat is AllRepeat - VnRepeat },
- optimize__repeat(NovnRepeat, no, ContainsReconstruction,
- LayoutLabelSet, Instrs0, ProcLabel, C0, C1,
+ optimize__repeat(Repeat, LayoutLabelSet, Instrs0, ProcLabel, C0, C1,
OptDebugInfo0, OptDebugInfo1, Instrs1),
- optimize__middle(Instrs1, no, LayoutLabelSet, ProcLabel,
- C1, C2, OptDebugInfo1, OptDebugInfo2, Instrs2),
- optimize__repeat(VnRepeat, yes, ContainsReconstruction,
- LayoutLabelSet, Instrs2, ProcLabel, C2, C,
- OptDebugInfo2, OptDebugInfo, Instrs3)
- ;
- optimize__repeat(AllRepeat, no, ContainsReconstruction,
- LayoutLabelSet, Instrs0, ProcLabel, C0, C1,
- OptDebugInfo0, OptDebugInfo1, Instrs1),
optimize__middle(Instrs1, yes, LayoutLabelSet, ProcLabel,
- C1, C, OptDebugInfo1, OptDebugInfo, Instrs3)
- ),
+ C1, C, OptDebugInfo1, OptDebugInfo, Instrs3),
optimize__last(Instrs3, LayoutLabelSet, C, OptDebugInfo, Instrs),
{ CProc = c_procedure(Name, Arity, PredProcId, Instrs,
ProcLabel, C, ContainsReconstruction) }.
@@ -167,14 +152,13 @@
%-----------------------------------------------------------------------------%
-:- pred optimize__repeat(int::in, bool::in, contains_reconstruction::in,
- set(label)::in, list(instruction)::in, proc_label::in,
- counter::in, counter::out, opt_debug_info::in, opt_debug_info::out,
- list(instruction)::out,
+:- pred optimize__repeat(int::in, set(label)::in, list(instruction)::in,
+ proc_label::in, counter::in, counter::out, opt_debug_info::in,
+ opt_debug_info::out, list(instruction)::out,
io__state::di, io__state::uo) is det.
-optimize__repeat(Iter0, DoVn, ContainsReconstruction, LayoutLabelSet, Instrs0,
- ProcLabel, C0, C, OptDebugInfo0, OptDebugInfo, Instrs) -->
+optimize__repeat(Iter0, LayoutLabelSet, Instrs0, ProcLabel, C0, C,
+ OptDebugInfo0, OptDebugInfo, Instrs) -->
( { Iter0 > 0 } ->
{ Iter1 = Iter0 - 1 },
( { Iter1 = 0 } ->
@@ -182,13 +166,12 @@
;
{ Final = no }
),
- optimize__repeated(Instrs0, DoVn, ContainsReconstruction,
- Final, LayoutLabelSet, ProcLabel, C0, C1,
- OptDebugInfo0, OptDebugInfo1, Instrs1, Mod),
+ optimize__repeated(Instrs0, Final, LayoutLabelSet, ProcLabel,
+ C0, C1, OptDebugInfo0, OptDebugInfo1, Instrs1, Mod),
( { Mod = yes } ->
- optimize__repeat(Iter1, DoVn, ContainsReconstruction,
- LayoutLabelSet, Instrs1, ProcLabel, C1, C,
- OptDebugInfo1, OptDebugInfo, Instrs)
+ optimize__repeat(Iter1, LayoutLabelSet, Instrs1,
+ ProcLabel, C1, C, OptDebugInfo1, OptDebugInfo,
+ Instrs)
;
{ Instrs = Instrs1 },
{ C = C1 },
@@ -203,37 +186,16 @@
% We short-circuit jump sequences before normal peepholing
% to create more opportunities for use of the tailcall macro.
-:- pred optimize__repeated(list(instruction)::in, bool::in,
- contains_reconstruction::in, bool::in, set(label)::in,
+:- pred optimize__repeated(list(instruction)::in, bool::in, set(label)::in,
proc_label::in, counter::in, counter::out,
opt_debug_info::in, opt_debug_info::out, list(instruction)::out,
bool::out, io__state::di, io__state::uo) is det.
-optimize__repeated(Instrs0, DoVn, ContainsReconstruction, Final,
- LayoutLabelSet, ProcLabel, C0, C, OptDebugInfo0, OptDebugInfo,
- Instrs, Mod) -->
- globals__io_lookup_bool_option(very_verbose, VeryVerbose),
+optimize__repeated(Instrs0, Final, LayoutLabelSet, ProcLabel, C0, C,
+ OptDebugInfo0, OptDebugInfo, Instrs, Mod) -->
{ opt_util__find_first_label(Instrs0, Label) },
{ opt_util__format_label(Label, LabelStr) },
-
- globals__io_lookup_bool_option(optimize_value_number, ValueNumber),
- ( { ValueNumber = yes, DoVn = yes } ->
- ( { VeryVerbose = yes } ->
- io__write_string("% Optimizing value number for "),
- io__write_string(LabelStr),
- io__write_string("\n")
- ;
- []
- ),
- value_number_main(Instrs0, ContainsReconstruction,
- LayoutLabelSet, ProcLabel, C0, C1, Instrs1),
- optimize__maybe_opt_debug(Instrs1, C1, "after value numbering",
- OptDebugInfo0, OptDebugInfo1)
- ;
- { Instrs1 = Instrs0 },
- { C1 = C0 },
- { OptDebugInfo1 = OptDebugInfo0 }
- ),
+ globals__io_lookup_bool_option(very_verbose, VeryVerbose),
globals__io_lookup_bool_option(optimize_jumps, Jumpopt),
globals__io_lookup_bool_option(optimize_fulljumps, FullJumpopt),
globals__io_lookup_bool_option(checked_nondet_tailcalls,
@@ -247,15 +209,15 @@
;
[]
),
- { jumpopt_main(Instrs1, LayoutLabelSet, TraceLevel, ProcLabel,
- C1, C2, FullJumpopt, Final, CheckedNondetTailCalls,
- Instrs2, Mod1) },
- optimize__maybe_opt_debug(Instrs2, C2, "after jump opt",
- OptDebugInfo1, OptDebugInfo2)
+ { jumpopt_main(Instrs0, LayoutLabelSet, TraceLevel, ProcLabel,
+ C0, C1, FullJumpopt, Final, CheckedNondetTailCalls,
+ Instrs1, Mod1) },
+ optimize__maybe_opt_debug(Instrs1, C1, "after jump opt",
+ OptDebugInfo0, OptDebugInfo1)
;
- { Instrs2 = Instrs1 },
- { C2 = C1 },
- { OptDebugInfo2 = OptDebugInfo1 },
+ { Instrs1 = Instrs0 },
+ { C1 = C0 },
+ { OptDebugInfo1 = OptDebugInfo0 },
{ Mod1 = no }
),
globals__io_lookup_bool_option(optimize_peep, Peephole),
@@ -268,12 +230,12 @@
[]
),
globals__io_get_gc_method(GC_Method),
- { peephole__optimize(GC_Method, Instrs2, Instrs3, Mod2) },
- optimize__maybe_opt_debug(Instrs3, C2, "after peephole",
- OptDebugInfo2, OptDebugInfo3)
+ { peephole__optimize(GC_Method, Instrs1, Instrs2, Mod2) },
+ optimize__maybe_opt_debug(Instrs2, C1, "after peephole",
+ OptDebugInfo1, OptDebugInfo2)
;
- { Instrs3 = Instrs2 },
- { OptDebugInfo3 = OptDebugInfo2 },
+ { Instrs2 = Instrs1 },
+ { OptDebugInfo2 = OptDebugInfo1 },
{ Mod2 = no }
),
globals__io_lookup_bool_option(optimize_labels, LabelElim),
@@ -285,13 +247,13 @@
;
[]
),
- { labelopt_main(Instrs3, Final, LayoutLabelSet,
- Instrs4, Mod3) },
- optimize__maybe_opt_debug(Instrs4, C2, "after label opt",
- OptDebugInfo3, OptDebugInfo4)
+ { labelopt_main(Instrs2, Final, LayoutLabelSet,
+ Instrs3, Mod3) },
+ optimize__maybe_opt_debug(Instrs3, C1, "after label opt",
+ OptDebugInfo2, OptDebugInfo3)
;
- { Instrs4 = Instrs3 },
- { OptDebugInfo4 = OptDebugInfo3 },
+ { Instrs3 = Instrs2 },
+ { OptDebugInfo3 = OptDebugInfo2 },
{ Mod3 = no }
),
globals__io_lookup_bool_option(optimize_dups, DupElim),
@@ -303,13 +265,13 @@
;
[]
),
- { dupelim_main(Instrs4, ProcLabel, C2, C, Instrs) },
+ { dupelim_main(Instrs3, ProcLabel, C1, C, Instrs) },
optimize__maybe_opt_debug(Instrs, C, "after duplicates",
- OptDebugInfo4, OptDebugInfo)
+ OptDebugInfo3, OptDebugInfo)
;
- { Instrs = Instrs4 },
- { OptDebugInfo = OptDebugInfo4 },
- { C = C2 }
+ { Instrs = Instrs3 },
+ { OptDebugInfo = OptDebugInfo3 },
+ { C = C1 }
),
{ Mod1 = no, Mod2 = no, Mod3 = no, Instrs = Instrs0 ->
Mod = no
@@ -418,9 +380,8 @@
{ opt_util__format_label(Label, LabelStr) },
globals__io_lookup_bool_option(optimize_delay_slot, DelaySlot),
- globals__io_lookup_bool_option(optimize_value_number, ValueNumber),
globals__io_lookup_bool_option(use_local_vars, UseLocalVars),
- ( { DelaySlot = yes ; ValueNumber = yes ; UseLocalVars = yes } ->
+ ( { DelaySlot = yes ; UseLocalVars = yes } ->
% We must get rid of any extra labels added by other passes,
% since they can confuse both wrap_blocks and delay_slot.
( { VeryVerbose = yes } ->
@@ -452,9 +413,9 @@
{ OptDebugInfo2 = OptDebugInfo1 },
{ Instrs2 = Instrs1 }
),
- ( { ValueNumber = yes ; UseLocalVars = yes } ->
+ ( { UseLocalVars = yes } ->
( { VeryVerbose = yes } ->
- io__write_string("% Optimizing post value number for "),
+ io__write_string("% Wrapping blocks for "),
io__write_string(LabelStr),
io__write_string("\n")
;
Index: compiler/options.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/options.m,v
retrieving revision 1.320
diff -u -b -r1.320 options.m
--- compiler/options.m 2001/05/02 11:36:39 1.320
+++ compiler/options.m 2001/05/11 03:29:27
@@ -72,7 +72,6 @@
; debug_modes
; debug_det
; debug_opt
- ; debug_vn % vn = value numbering
; debug_pd % pd = partial deduction/deforestation
; debug_rl_gen
; debug_rl_opt
@@ -386,13 +385,9 @@
; optimize_labels
; optimize_dups
%%% unused: ; optimize_copyprop
- ; optimize_value_number
; optimize_frames
; optimize_delay_slot
; optimize_repeat
- ; optimize_vnrepeat
- ; pred_value_number
- ; vn_fudge
% - RL
; optimize_rl
; optimize_rl_cse
@@ -489,7 +484,6 @@
debug_modes - bool(no),
debug_det - bool(no),
debug_opt - bool(no),
- debug_vn - int(0),
debug_pd - bool(no),
debug_rl_gen - bool(no),
debug_rl_opt - bool(no),
@@ -781,14 +775,9 @@
optimize_labels - bool(no),
optimize_dups - bool(no),
%%% optimize_copyprop - bool(no),
- optimize_value_number - bool(no),
optimize_frames - bool(no),
optimize_delay_slot - bool(no),
optimize_repeat - int(0),
- optimize_vnrepeat - int(1), % ineffective unless
- % value_number is set
- pred_value_number - bool(no),
- vn_fudge - int(1000),
% LLDS -> C
use_macro_for_redo_fail - bool(no),
@@ -888,7 +877,6 @@
long_option("debug-determinism", debug_det).
long_option("debug-det", debug_det).
long_option("debug-opt", debug_opt).
-long_option("debug-vn", debug_vn).
long_option("debug-pd", debug_pd).
long_option("debug-rl-gen", debug_rl_gen).
long_option("debug-rl-opt", debug_rl_opt).
@@ -1226,18 +1214,12 @@
long_option("optimise-dups", optimize_dups).
%%% long_option("optimize-copyprop", optimize_copyprop).
%%% long_option("optimise-copyprop", optimize_copyprop).
-long_option("optimize-value-number", optimize_value_number).
-long_option("optimise-value-number", optimize_value_number).
long_option("optimize-frames", optimize_frames).
long_option("optimise-frames", optimize_frames).
long_option("optimize-delay-slot", optimize_delay_slot).
long_option("optimise-delay-slot", optimize_delay_slot).
long_option("optimize-repeat", optimize_repeat).
long_option("optimise-repeat", optimize_repeat).
-long_option("optimize-vnrepeat", optimize_vnrepeat).
-long_option("optimise-vnrepeat", optimize_vnrepeat).
-long_option("pred-value-number", pred_value_number).
-long_option("vn-fudge", vn_fudge).
% RL optimizations
long_option("optimize-rl", optimize_rl).
@@ -1539,8 +1521,6 @@
% and increases the inlining thresholds
opt_level(4, _, [
- % lazy_code - bool(yes),
- % optimize_value_number - bool(yes),
use_local_vars - bool(yes),
inline_simple_threshold - int(8),
inline_compound_threshold - int(20),
@@ -1555,8 +1535,6 @@
% optimizations, and increases the inlining thresholds still further.
opt_level(5, _, [
- % pred_value_number - bool(yes),
- % optimize_vnrepeat - int(2),
optimize_repeat - int(5),
delay_construct - bool(yes),
inline_compound_threshold - int(100),
@@ -1688,11 +1666,6 @@
"\tOutput detailed debugging traces of determinism analysis.",
"--debug-opt",
"\tOutput detailed debugging traces of the optimization process.",
- "--debug-vn <n>",
- "\tOutput detailed debugging traces of the value numbering",
- "\toptimization pass. The different bits in the number",
- "\targument of this option control the printing of",
- "\tdifferent types of tracing messages.",
"--debug-pd",
"\tOutput detailed debugging traces of the partial",
"\tdeduction and deforestation process.",
@@ -2587,18 +2560,12 @@
"\tEnable elimination of duplicate code.",
%%% "--optimize-copyprop",
%%% "\tEnable the copy propagation optimization.",
- "--optimize-value-number",
- "\tPerform value numbering on extended basic blocks.",
"--no-optimize-frames",
"\tDisable stack frame optimizations.",
"--no-optimize-delay-slot",
"\tDisable branch delay slot optimizations.",
"--optimize-repeat <n>",
- "\tIterate most optimizations at most <n> times (default: 3).",
- "--optimize-vnrepeat <n>",
- "\tIterate value numbering at most <n> times (default: 1).",
- "--pred-value-number",
- "\tExtend value numbering to entire predicates."
+ "\tIterate most optimizations at most <n> times (default: 3)."
]).
:- pred options_help_mlds_mlds_optimization(io__state::di, io__state::uo) is det.
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing doc
Index: doc/user_guide.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/user_guide.texi,v
retrieving revision 1.249
diff -u -b -r1.249 user_guide.texi
--- doc/user_guide.texi 2001/04/24 03:59:10 1.249
+++ doc/user_guide.texi 2001/05/11 04:23:08
@@ -3037,12 +3037,6 @@
Output detailed debugging traces of the optimization process.
@sp 1
- at item --debug-vn <n>
-Output detailed debugging traces of the value numbering optimization pass.
-The different bits in the number argument of this option control the
-printing of different types of tracing messages.
-
- at sp 1
@item --debug-pd
Output detailed debugging traces of the partial
deduction and deforestation process.
@@ -4303,14 +4297,6 @@
@c Enable the copy propagation optimization.
@sp 1
- at item --optimize-value-number
-Perform value numbering on extended basic blocks.
-
- at sp 1
- at item --pred-value-number
-Extend value numbering to whole procedures, rather than just basic blocks.
-
- at sp 1
@item --no-optimize-frames
Disable stack frame optimizations.
@@ -4321,10 +4307,6 @@
@sp 1
@item --optimize-repeat @var{n}
Iterate most optimizations at most @var{n} times (default: 3).
-
- at sp 1
- at item --optimize-vnrepeat @var{n}
-Iterate value numbering at most @var{n} times (default: 1).
@end table
cvs diff: Diffing extras
cvs diff: Diffing extras/aditi
cvs diff: Diffing extras/cgi
cvs diff: Diffing extras/complex_numbers
cvs diff: Diffing extras/complex_numbers/samples
cvs diff: Diffing extras/complex_numbers/tests
cvs diff: Diffing extras/concurrency
cvs diff: Diffing extras/curs
cvs diff: Diffing extras/curs/samples
cvs diff: Diffing extras/curses
cvs diff: Diffing extras/curses/sample
cvs diff: Diffing extras/dynamic_linking
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/mercury_opengl
cvs diff: Diffing extras/graphics/mercury_tcltk
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing extras/graphics/samples/pent
cvs diff: Diffing extras/lazy_evaluation
cvs diff: Diffing extras/lex
cvs diff: Diffing extras/lex/samples
cvs diff: Diffing extras/logged_output
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
cvs diff: Diffing extras/morphine
cvs diff: Diffing extras/morphine/non-regression-tests
cvs diff: Diffing extras/morphine/scripts
cvs diff: Diffing extras/morphine/source
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/stream
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing java
cvs diff: Diffing library
cvs diff: Diffing profiler
cvs diff: Diffing robdd
cvs diff: Diffing runtime
cvs diff: Diffing runtime/GETOPT
cvs diff: Diffing runtime/machdeps
cvs diff: Diffing samples
cvs diff: Diffing samples/c_interface
cvs diff: Diffing samples/c_interface/c_calls_mercury
cvs diff: Diffing samples/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/mercury_calls_c
cvs diff: Diffing samples/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/diff
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
cvs diff: Diffing samples/tests
cvs diff: Diffing samples/tests/c_interface
cvs diff: Diffing samples/tests/c_interface/c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/tests/c_interface/mercury_calls_c
cvs diff: Diffing samples/tests/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/tests/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/tests/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/tests/diff
cvs diff: Diffing samples/tests/muz
cvs diff: Diffing samples/tests/rot13
cvs diff: Diffing samples/tests/solutions
cvs diff: Diffing samples/tests/toplevel
cvs diff: Diffing scripts
cvs diff: Diffing tests
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/debugger/declarative
cvs diff: Diffing tests/dppd
cvs diff: Diffing tests/general
cvs diff: Diffing tests/general/accumulator
cvs diff: Diffing tests/general/structure_reuse
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/exceptions
cvs diff: Diffing tests/hard_coded/purity
cvs diff: Diffing tests/hard_coded/sub-modules
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/invalid/purity
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
--------------------------------------------------------------------------
mercury-reviews mailing list
post: mercury-reviews at cs.mu.oz.au
administrative address: owner-mercury-reviews at cs.mu.oz.au
unsubscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: unsubscribe
subscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------
More information about the reviews
mailing list