mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-15 22:03:26 +00:00
1c90f19e02
Estimated hours taken: 20 vn_block: Fix a typo which reflected a fundamental design error. When finding cheaper copies of live lvals, for use in creating specialized copies (parallels) of blocks jumped to from the current location, we used to use the map reflecting the contents of lvals at the start of the block, not at the point of the jump. --pred-value-number, which uses the information computed by the buggy predicate, actually bootstrapped some time ago despite this fundamental bug! value_number: Fix a bug in the creation of parallel code sequences for computed gotos. Add some more opprtunities for printing diagnostics. Move code concerning final verification to vn_verify. vn_verify: Move the remaining code concerned with final verification from value_number to vn_verify. peephole: Add a new pattern, which transforms the sequence incr_sp N; goto L2; L1; incr_sp N; L2 into just L1; incr_sp N; L2 The pattern is of course more broadly applicable, but I have seen it only when it involves a single incr_sp between the two labels. (The longer pattern can be introduced by frameopt.) opt_util: Look inside blocks when checking whether an instruction can fall through. This improves the performance of labelopt. vn_table: Make the type vn_table abstract; add, export and use access functions. vn_util: Remove a noop predicate, since now it won't ever be made to do anything. vn_cost: Refine debugging output. vn_debug: Add some more debugging routines. opt_debug: Add some more debugging routines. det_analysis: Remove an unused argument. labelopt: Formatting change.
777 lines
30 KiB
Mathematica
777 lines
30 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1995 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.
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Debugging support for LLDS to LLDS peephole optimization.
|
|
|
|
% Main author: zs.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module opt_debug.
|
|
|
|
:- interface.
|
|
|
|
:- import_module bool, int, list, assoc_list, std_util.
|
|
|
|
:- import_module vn_type, vn_table, vn_util, livemap, opt_util.
|
|
:- import_module llds, atsort.
|
|
|
|
:- 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.
|
|
|
|
:- pred opt_debug__dump_livemap(livemap, string).
|
|
:- mode opt_debug__dump_livemap(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_livemaplist(assoc_list(label, lvalset), string).
|
|
:- mode opt_debug__dump_livemaplist(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_livevals(lvalset, string).
|
|
:- mode opt_debug__dump_livevals(in, out) is det.
|
|
|
|
:- 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, string).
|
|
:- mode opt_debug__dump_reg(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.
|
|
|
|
:- pred opt_debug__dump_rval(rval, string).
|
|
:- mode opt_debug__dump_rval(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_rvals(list(rval), string).
|
|
:- mode opt_debug__dump_rvals(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_const(rval_const, string).
|
|
:- mode opt_debug__dump_const(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_unop(unary_op, string).
|
|
:- mode opt_debug__dump_unop(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_binop(binary_op, string).
|
|
:- mode opt_debug__dump_binop(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_label(label, string).
|
|
:- mode opt_debug__dump_label(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_labels(list(label), string).
|
|
:- mode opt_debug__dump_labels(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_label_pairs(list(pair(label)), string).
|
|
:- mode opt_debug__dump_label_pairs(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_proclabel(proc_label, string).
|
|
:- mode opt_debug__dump_proclabel(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_maybe_rvals(list(maybe(rval)), int, string).
|
|
:- mode opt_debug__dump_maybe_rvals(in, in, out) is det.
|
|
|
|
:- pred opt_debug__dump_code_addr(code_addr, string).
|
|
:- mode opt_debug__dump_code_addr(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_code_addrs(list(code_addr), string).
|
|
:- mode opt_debug__dump_code_addrs(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_bool(bool, string).
|
|
:- mode opt_debug__dump_bool(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_instr(instr, string).
|
|
:- mode opt_debug__dump_instr(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_fullinstr(instruction, string).
|
|
:- mode opt_debug__dump_fullinstr(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_fullinstrs(list(instruction), string).
|
|
:- mode opt_debug__dump_fullinstrs(in, out) is det.
|
|
|
|
:- pred opt_debug__dump_code_model(code_model, string).
|
|
:- mode opt_debug__dump_code_model(in, out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
:- import_module set, map, string.
|
|
|
|
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),
|
|
opt_debug__dump_intlist(T, T_str),
|
|
string__append_list([" ", H_str, T_str], Str).
|
|
|
|
opt_debug__dump_livemap(Livemap, Str) :-
|
|
map__to_assoc_list(Livemap, Livemaplist),
|
|
opt_debug__dump_livemaplist(Livemaplist, Str).
|
|
|
|
opt_debug__dump_livemaplist([], "").
|
|
opt_debug__dump_livemaplist([Label - Lvalset | Livemaplist], Str) :-
|
|
opt_debug__dump_label(Label, L_str),
|
|
opt_debug__dump_livevals(Lvalset, S_str),
|
|
opt_debug__dump_livemaplist(Livemaplist, Str2),
|
|
string__append_list([L_str, " ->", S_str, "\n", Str2], Str).
|
|
|
|
opt_debug__dump_livevals(Lvalset, Str) :-
|
|
set__to_sorted_list(Lvalset, Lvallist),
|
|
opt_debug__dump_livelist(Lvallist, Str).
|
|
|
|
opt_debug__dump_livelist([], "").
|
|
opt_debug__dump_livelist([Lval | Lvallist], Str) :-
|
|
opt_debug__dump_lval(Lval, L_str),
|
|
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_call_closure(_, Ret, _), Str) :-
|
|
opt_debug__dump_code_addr(Ret, R_str),
|
|
string__append_list(["call_closure(", 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_store_ticket(Vnlval), Str) :-
|
|
opt_debug__dump_vnlval(Vnlval, V_str),
|
|
string__append_list(["store_ticket(", V_str, ")"], Str).
|
|
opt_debug__dump_vninstr(vn_restore_ticket(Vn), Str) :-
|
|
opt_debug__dump_vn(Vn, Vn_str),
|
|
string__append_list(["restore_ticket(", Vn_str, ")"], Str).
|
|
opt_debug__dump_vninstr(vn_discard_ticket, "discard_ticket").
|
|
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(R), Str) :-
|
|
opt_debug__dump_reg(R, R_str),
|
|
string__append_list(["vn_reg(", 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_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(T, N, F), Str) :-
|
|
string__int_to_string(T, T_str),
|
|
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_temp(N), Str) :-
|
|
string__int_to_string(N, N_str),
|
|
string__append_list(["vn_temp(", 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, L), 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_lval(reg(R), Str) :-
|
|
opt_debug__dump_reg(R, R_str),
|
|
string__append_list(["reg(", R_str, ")"], Str).
|
|
opt_debug__dump_lval(stackvar(N), Str) :-
|
|
string__int_to_string(N, N_str),
|
|
string__append_list(["stackvar(", N_str, ")"], Str).
|
|
opt_debug__dump_lval(framevar(N), Str) :-
|
|
string__int_to_string(N, N_str),
|
|
string__append_list(["framevar(", N_str, ")"], Str).
|
|
opt_debug__dump_lval(succip, Str) :-
|
|
string__append_list(["succip"], Str).
|
|
opt_debug__dump_lval(maxfr, Str) :-
|
|
string__append_list(["maxfr"], Str).
|
|
opt_debug__dump_lval(curfr, Str) :-
|
|
string__append_list(["curfr"], Str).
|
|
opt_debug__dump_lval(succfr(R), Str) :-
|
|
opt_debug__dump_rval(R, R_str),
|
|
string__append_list(["succfr(", R_str, ")"], Str).
|
|
opt_debug__dump_lval(prevfr(R), Str) :-
|
|
opt_debug__dump_rval(R, R_str),
|
|
string__append_list(["prevfr(", R_str, ")"], Str).
|
|
opt_debug__dump_lval(redoip(R), Str) :-
|
|
opt_debug__dump_rval(R, R_str),
|
|
string__append_list(["redoip(", R_str, ")"], Str).
|
|
opt_debug__dump_lval(succip(R), Str) :-
|
|
opt_debug__dump_rval(R, R_str),
|
|
string__append_list(["succip(", R_str, ")"], Str).
|
|
opt_debug__dump_lval(hp, Str) :-
|
|
string__append_list(["hp"], Str).
|
|
opt_debug__dump_lval(sp, Str) :-
|
|
string__append_list(["sp"], Str).
|
|
opt_debug__dump_lval(field(T, N, F), Str) :-
|
|
string__int_to_string(T, T_str),
|
|
opt_debug__dump_rval(N, N_str),
|
|
opt_debug__dump_rval(F, F_str),
|
|
string__append_list(["field(", T_str, ", ", N_str, ", ",
|
|
F_str, ")"], Str).
|
|
opt_debug__dump_lval(lvar(_), Str) :-
|
|
string__append_list(["lvar(_)"], Str).
|
|
opt_debug__dump_lval(temp(N), Str) :-
|
|
string__int_to_string(N, N_str),
|
|
string__append_list(["temp(", N_str, ")"], Str).
|
|
|
|
opt_debug__dump_rval(lval(Lval), Str) :-
|
|
opt_debug__dump_lval(Lval, Lval_str),
|
|
string__append_list(["lval(", Lval_str, ")"], Str).
|
|
opt_debug__dump_rval(var(_), Str) :-
|
|
string__append_list(["var(_)"], Str).
|
|
opt_debug__dump_rval(mkword(T, N), Str) :-
|
|
string__int_to_string(T, T_str),
|
|
opt_debug__dump_rval(N, N_str),
|
|
string__append_list(["mkword(", T_str, ", ", N_str, ")"], Str).
|
|
opt_debug__dump_rval(const(C), Str) :-
|
|
opt_debug__dump_const(C, C_str),
|
|
string__append_list(["const(", C_str, ")"], Str).
|
|
opt_debug__dump_rval(create(T, MA, L), 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(["create(", T_str, ", ", MA_str, ", ",
|
|
L_str, ")"], Str).
|
|
opt_debug__dump_rval(unop(O, N), Str) :-
|
|
opt_debug__dump_unop(O, O_str),
|
|
opt_debug__dump_rval(N, N_str),
|
|
string__append_list(["unop(", O_str, ", ", N_str, ")"], Str).
|
|
opt_debug__dump_rval(binop(O, N1, N2), Str) :-
|
|
opt_debug__dump_binop(O, O_str),
|
|
opt_debug__dump_rval(N1, N1_str),
|
|
opt_debug__dump_rval(N2, N2_str),
|
|
string__append_list(["binop(", O_str, ", ", N1_str, ", ",
|
|
N2_str, ")"], Str).
|
|
|
|
opt_debug__dump_rvals([], "").
|
|
opt_debug__dump_rvals([Rval | Rvals], Str) :-
|
|
opt_debug__dump_rval(Rval, R_str),
|
|
opt_debug__dump_rvals(Rvals, S_str),
|
|
string__append_list([R_str, ", ", S_str], Str).
|
|
|
|
opt_debug__dump_const(true, "true").
|
|
opt_debug__dump_const(false, "false").
|
|
opt_debug__dump_const(int_const(I), Str) :-
|
|
string__int_to_string(I, Str).
|
|
opt_debug__dump_const(float_const(F), Str) :-
|
|
string__float_to_string(F, Str).
|
|
opt_debug__dump_const(string_const(I), Str) :-
|
|
string__append_list(["""", I, """"], Str).
|
|
opt_debug__dump_const(address_const(CodeAddr), Str) :-
|
|
opt_debug__dump_code_addr(CodeAddr, C_str),
|
|
string__append_list(["address_const(", C_str, ")"], Str).
|
|
|
|
opt_debug__dump_unop(mktag, "mktag").
|
|
opt_debug__dump_unop(tag, "tag").
|
|
opt_debug__dump_unop(unmktag, "unmktag").
|
|
opt_debug__dump_unop(mkbody, "mkbody").
|
|
opt_debug__dump_unop(body, "body").
|
|
opt_debug__dump_unop(unmkbody, "unmkbody").
|
|
opt_debug__dump_unop(not, "not").
|
|
opt_debug__dump_unop(hash_string, "hash_string").
|
|
opt_debug__dump_unop(bitwise_complement, "bitwise_complement").
|
|
opt_debug__dump_unop(cast_to_unsigned, "cast_to_unsigned").
|
|
|
|
opt_debug__dump_binop(Op, String) :-
|
|
llds__binary_op_to_string(Op, String).
|
|
|
|
opt_debug__dump_maybe_rvals([], _, "").
|
|
opt_debug__dump_maybe_rvals([MR | MRs], N, Str) :-
|
|
( N > 0 ->
|
|
( MR = yes(R) ->
|
|
opt_debug__dump_rval(R, MR_str)
|
|
;
|
|
MR_str = "no"
|
|
),
|
|
N1 is N - 1,
|
|
opt_debug__dump_maybe_rvals(MRs, N1, MRs_str),
|
|
string__append_list([MR_str, ", ", MRs_str], Str)
|
|
;
|
|
Str = "truncated"
|
|
).
|
|
|
|
opt_debug__dump_code_addr(label(Label), Str) :-
|
|
opt_debug__dump_label(Label, Str).
|
|
opt_debug__dump_code_addr(imported(ProcLabel), Str) :-
|
|
opt_debug__dump_proclabel(ProcLabel, Str).
|
|
opt_debug__dump_code_addr(succip, "succip").
|
|
opt_debug__dump_code_addr(do_succeed(Last), Str) :-
|
|
(
|
|
Last = no,
|
|
Str = "do_succeed"
|
|
;
|
|
Last = yes,
|
|
Str = "do_last_succeed"
|
|
).
|
|
opt_debug__dump_code_addr(do_redo, "do_redo").
|
|
opt_debug__dump_code_addr(do_fail, "do_fail").
|
|
|
|
opt_debug__dump_code_addrs([], "").
|
|
opt_debug__dump_code_addrs([Addr | Addrs], Str) :-
|
|
opt_debug__dump_code_addr(Addr, A_str),
|
|
opt_debug__dump_code_addrs(Addrs, A2_str),
|
|
string__append_list([" ", A_str, A2_str], Str).
|
|
|
|
opt_debug__dump_label(local(ProcLabel), Str) :-
|
|
opt_debug__dump_proclabel(ProcLabel, P_str),
|
|
string__append_list([P_str], Str).
|
|
opt_debug__dump_label(local(ProcLabel, N), Str) :-
|
|
opt_debug__dump_proclabel(ProcLabel, P_str),
|
|
string__int_to_string(N, N_str),
|
|
string__append_list([P_str, "_", N_str], Str).
|
|
opt_debug__dump_label(exported(ProcLabel), Str) :-
|
|
opt_debug__dump_proclabel(ProcLabel, P_str),
|
|
string__append_list([P_str], Str).
|
|
|
|
opt_debug__dump_labels([], "").
|
|
opt_debug__dump_labels([Label | Labels], Str) :-
|
|
opt_debug__dump_label(Label, L_str),
|
|
opt_debug__dump_labels(Labels, L2_str),
|
|
string__append_list([" ", L_str, L2_str], Str).
|
|
|
|
opt_debug__dump_label_pairs([], "").
|
|
opt_debug__dump_label_pairs([L1 - L2 | Labels], Str) :-
|
|
opt_debug__dump_label(L1, L1_str),
|
|
opt_debug__dump_label(L2, L2_str),
|
|
opt_debug__dump_label_pairs(Labels, L_str),
|
|
string__append_list([" ", L1_str, "-", L2_str, L_str], Str).
|
|
|
|
opt_debug__dump_proclabel(proc(Module, Pred, Arity, Mode), Str) :-
|
|
string__int_to_string(Arity, A_str),
|
|
string__int_to_string(Mode, M_str),
|
|
string__append_list([Module, "_", Pred, "_", A_str, "_", M_str], Str).
|
|
opt_debug__dump_proclabel(special_proc(Module, Pred, Type, Arity, Mode), Str) :-
|
|
string__int_to_string(Arity, A_str),
|
|
string__int_to_string(Mode, M_str),
|
|
string__append_list(
|
|
[Module, "_", Pred, "_", Type, "_", A_str, "_", M_str], Str).
|
|
|
|
opt_debug__dump_bool(yes, "yes").
|
|
opt_debug__dump_bool(no, "no").
|
|
|
|
opt_debug__dump_code_model(model_det, "model_det").
|
|
opt_debug__dump_code_model(model_semi, "model_semi").
|
|
opt_debug__dump_code_model(model_non, "model_non").
|
|
|
|
opt_debug__dump_instr(comment(Comment), Str) :-
|
|
string__append_list(["comment(", Comment, ")"], Str).
|
|
opt_debug__dump_instr(livevals(Livevals), Str) :-
|
|
opt_debug__dump_livevals(Livevals, L_str),
|
|
string__append_list(["livevals(", L_str, ")"], Str).
|
|
opt_debug__dump_instr(block(N, _), Str) :-
|
|
string__int_to_string(N, N_str),
|
|
string__append_list(["block(", N_str, ", ...)"], Str).
|
|
opt_debug__dump_instr(assign(Lval, Rval), Str) :-
|
|
opt_debug__dump_lval(Lval, L_str),
|
|
opt_debug__dump_rval(Rval, R_str),
|
|
string__append_list(["assign(", L_str, ", ", R_str, ")"], Str).
|
|
opt_debug__dump_instr(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_instr(call_closure(CodeModel, Ret, _), Str) :-
|
|
opt_debug__dump_code_model(CodeModel, F_str),
|
|
opt_debug__dump_code_addr(Ret, R_str),
|
|
string__append_list(["call_closure(", F_str, ", ", R_str, ", ...)"],
|
|
Str).
|
|
opt_debug__dump_instr(mkframe(Name, Size, Redoip), Str) :-
|
|
string__int_to_string(Size, S_str),
|
|
opt_debug__dump_code_addr(Redoip, R_str),
|
|
string__append_list(["mkframe(", Name, ", ", S_str, ", ", R_str, ")"],
|
|
Str).
|
|
opt_debug__dump_instr(modframe(Redoip), Str) :-
|
|
opt_debug__dump_code_addr(Redoip, R_str),
|
|
string__append_list(["modframe(", R_str, ")"], Str).
|
|
opt_debug__dump_instr(label(Label), Str) :-
|
|
opt_debug__dump_label(Label, L_str),
|
|
string__append_list(["label(", L_str, ")"], Str).
|
|
opt_debug__dump_instr(goto(CodeAddr), Str) :-
|
|
opt_debug__dump_code_addr(CodeAddr, C_str),
|
|
string__append_list(["goto(", C_str, ")"], Str).
|
|
opt_debug__dump_instr(computed_goto(Rval, Labels), Str) :-
|
|
opt_debug__dump_rval(Rval, R_str),
|
|
opt_debug__dump_labels(Labels, L_str),
|
|
string__append_list(["computed_goto(", R_str, ", ", L_str, ")"], Str).
|
|
opt_debug__dump_instr(c_code(Code), Str) :-
|
|
string__append_list(["c_code(", Code, ")"], Str).
|
|
opt_debug__dump_instr(if_val(Rval, CodeAddr), Str) :-
|
|
opt_debug__dump_rval(Rval, R_str),
|
|
opt_debug__dump_code_addr(CodeAddr, C_str),
|
|
string__append_list(["if_val(", R_str, ", ", C_str, ")"], Str).
|
|
opt_debug__dump_instr(incr_hp(Lval, MaybeTag, Size), Str) :-
|
|
opt_debug__dump_lval(Lval, L_str),
|
|
(
|
|
MaybeTag = no,
|
|
T_str = "no"
|
|
;
|
|
MaybeTag = yes(Tag),
|
|
string__int_to_string(Tag, T_str)
|
|
),
|
|
opt_debug__dump_rval(Size, S_str),
|
|
string__append_list(["incr_hp(", L_str, ", ", T_str, ", ", S_str, ")"],
|
|
Str).
|
|
opt_debug__dump_instr(mark_hp(Lval), Str) :-
|
|
opt_debug__dump_lval(Lval, L_str),
|
|
string__append_list(["mark_hp(", L_str, ")"], Str).
|
|
opt_debug__dump_instr(restore_hp(Rval), Str) :-
|
|
opt_debug__dump_rval(Rval, R_str),
|
|
string__append_list(["restore_hp(", R_str, ")"], Str).
|
|
opt_debug__dump_instr(store_ticket(Lval), Str) :-
|
|
opt_debug__dump_lval(Lval, L_str),
|
|
string__append_list(["store_ticket(", L_str, ")"], Str).
|
|
opt_debug__dump_instr(restore_ticket(Rval), Str) :-
|
|
opt_debug__dump_rval(Rval, R_str),
|
|
string__append_list(["restore_ticket(", R_str, ")"], Str).
|
|
opt_debug__dump_instr(discard_ticket, "discard_ticket").
|
|
opt_debug__dump_instr(incr_sp(Size), Str) :-
|
|
string__int_to_string(Size, S_str),
|
|
string__append_list(["incr_sp(", S_str, ")"], Str).
|
|
opt_debug__dump_instr(decr_sp(Size), Str) :-
|
|
string__int_to_string(Size, S_str),
|
|
string__append_list(["decr_sp(", S_str, ")"], Str).
|
|
|
|
% XXX should probably give more info than this
|
|
opt_debug__dump_instr(pragma_c(_, _, Code, _), Str) :-
|
|
string__append_list(["pragma_c(", Code, ")"], Str).
|
|
|
|
|
|
opt_debug__dump_fullinstr(Uinstr - Comment, Str) :-
|
|
opt_debug__dump_instr(Uinstr, U_str),
|
|
string__append_list([U_str, " - ", Comment, "\n"], Str).
|
|
|
|
opt_debug__dump_fullinstrs([], "").
|
|
opt_debug__dump_fullinstrs([Instr | Instrs], Str) :-
|
|
opt_debug__dump_fullinstr(Instr, S1_str),
|
|
opt_debug__dump_fullinstrs(Instrs, S2_str),
|
|
string__append_list([S1_str, S2_str], Str).
|