mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-14 05:12:33 +00:00
863874df85
Estimated hours taken: 6 Branches: main Document my recent change implementing coverage testing. At the same time, eliminate the old hack that allowed a file containing a list of file names to be considered a trace count file. We haven't needed it since the addition of mtc_union, and it can lead to incomprensible error messages. (The presence of the old hack made documenting coverage testing harder.) In the process, fix the tools code for rerunning failed test cases only. doc/user_guide.texi: Document my recent change implementing coverage testing, and the elimination of the old hack. mdbcomp/trace_counts.m: Modify the predicates for reading in trace count files along the lines above. mdbcomp/slice_and_dice.m: Modify the predicates for reading in slices and dices along the lines above. Rename some function symbols to avoid ambiguities. compiler/tupling.m: slice/mcov.m: slice/mtc_diff.m: slice/mtc_union.m: trace/mercury_trace_declarative.c: Conform to the changes above. slice/mcov.m: Fix the usage message, which referred to this program by its old name mct. Allow the output to be restricted to a set of named modules only. This is to make testing easier. slice/mtc_diff.m: Rename the long form of the -o option from --out to --output-file, to make it consistent with the other programs. tests/run_one_test: tools/bootcheck: Modify the algorithm we use to gather trace counts for the Mercury compiler from both passed and failed test cases to run mtc_union periodically instead of gathering all the trace counts file and keeping them to the end (which takes far too much disk space). Fix an old bug: gather trace counts from executions of the Mercury compiler only. tests/debugger/Mmakefile: tests/debugger/dice.passes: Modify the dice test case to compute the union of the trace counts for the passed versions of this test case to use mtc_union to create dice.passes, instead of having dice.passes statically contain the list of the names of the passed trace count files (since that capability is deleted by this diff). tools/bootcheck: tests/Mmake.common: Fix the code for rerunning failed tests only. mdbcomp/prim_data.m: Eliminate some ambiguities in predicate names. compiler/*.m: Conform to the change to prim_data.m. compiler/error_util.m: Add reading files as a phase in error messages. compiler/mercury_compile.m: Use the new facilities in error_util for printing an error message.
1176 lines
42 KiB
Mathematica
1176 lines
42 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 1996-2006 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: bytecode.m.
|
|
% Author: zs.
|
|
%
|
|
% This module defines the bytecode used by the debugger.
|
|
%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- module bytecode_backend.bytecode.
|
|
:- interface.
|
|
|
|
:- import_module backend_libs.
|
|
:- import_module backend_libs.builtin_ops.
|
|
:- import_module hlds.
|
|
:- import_module hlds.hlds_data.
|
|
:- import_module libs.
|
|
:- import_module libs.tree.
|
|
:- import_module mdbcomp.
|
|
:- import_module mdbcomp.prim_data.
|
|
:- import_module parse_tree.
|
|
:- import_module parse_tree.prog_data.
|
|
|
|
:- import_module char.
|
|
:- import_module io.
|
|
:- import_module list.
|
|
:- import_module pair.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- type byte_tree == tree(list(byte_code)).
|
|
|
|
:- type byte_code
|
|
---> byte_enter_pred(byte_pred_id, int, byte_is_func, int)
|
|
; byte_endof_pred
|
|
; byte_enter_proc(byte_proc_id, determinism, int, int, int,
|
|
list(byte_var_info))
|
|
; byte_endof_proc
|
|
; byte_label(byte_label_id)
|
|
; byte_enter_disjunction(byte_label_id)
|
|
; byte_endof_disjunction
|
|
; byte_enter_disjunct(byte_label_id)
|
|
; byte_endof_disjunct(byte_label_id)
|
|
; byte_enter_switch(byte_var, byte_label_id)
|
|
; byte_endof_switch
|
|
; byte_enter_switch_arm(byte_cons_id, byte_label_id)
|
|
; byte_endof_switch_arm(byte_label_id)
|
|
; byte_enter_if(byte_label_id, byte_label_id, byte_temp)
|
|
; byte_enter_then(byte_temp)
|
|
; byte_endof_then(byte_label_id)
|
|
; byte_enter_else(byte_temp)
|
|
; byte_endof_if
|
|
; byte_enter_negation(byte_temp, byte_label_id)
|
|
; byte_endof_negation_goal(byte_temp)
|
|
; byte_endof_negation
|
|
; byte_enter_commit(byte_temp)
|
|
; byte_endof_commit(byte_temp)
|
|
; byte_assign(byte_var, byte_var)
|
|
; byte_test(byte_var, byte_var, byte_test_id)
|
|
; byte_construct(byte_var, byte_cons_id, list(byte_var))
|
|
; byte_deconstruct(byte_var, byte_cons_id, list(byte_var))
|
|
; byte_complex_construct(byte_var, byte_cons_id,
|
|
list(pair(byte_var, byte_dir)))
|
|
; byte_complex_deconstruct(byte_var, byte_cons_id,
|
|
list(pair(byte_var, byte_dir)))
|
|
; byte_place_arg(byte_reg_type, int, byte_var)
|
|
; byte_pickup_arg(byte_reg_type, int, byte_var)
|
|
; byte_call(byte_module_id, byte_pred_id, arity, byte_is_func,
|
|
byte_proc_id)
|
|
; byte_higher_order_call(byte_var, arity, arity, determinism)
|
|
; byte_builtin_binop(binary_op, byte_arg, byte_arg, byte_var)
|
|
; byte_builtin_unop(unary_op, byte_arg, byte_var)
|
|
; byte_builtin_bintest(binary_op, byte_arg, byte_arg)
|
|
; byte_builtin_untest(unary_op, byte_arg)
|
|
; byte_semidet_succeed
|
|
; byte_semidet_success_check
|
|
; byte_fail
|
|
; byte_context(int)
|
|
; byte_not_supported.
|
|
|
|
% Currently we only support integer registers.
|
|
% This might one day be extended to support separate
|
|
% floating-point registers.
|
|
:- type byte_reg_type
|
|
---> byte_reg_r. % general-purpose (integer) register.
|
|
|
|
:- type byte_cons_id
|
|
---> byte_cons(byte_module_id, string, arity, byte_cons_tag)
|
|
; byte_int_const(int)
|
|
; byte_string_const(string)
|
|
; byte_float_const(float)
|
|
; byte_char_const(char)
|
|
; byte_pred_const(byte_module_id, byte_pred_id, arity, byte_is_func,
|
|
byte_proc_id)
|
|
; byte_type_ctor_info_const(byte_module_id, string, int)
|
|
; byte_base_typeclass_info_const(byte_module_id, class_id, string)
|
|
; byte_type_info_cell_constructor
|
|
; byte_typeclass_info_cell_constructor.
|
|
|
|
:- type byte_var_info
|
|
---> var_info(string, mer_type).
|
|
|
|
:- type byte_cons_tag
|
|
---> byte_no_tag
|
|
; byte_unshared_tag(tag_bits)
|
|
; byte_shared_remote_tag(tag_bits, int)
|
|
; byte_shared_local_tag(tag_bits, int)
|
|
; byte_enum_tag(int).
|
|
|
|
:- type byte_arg
|
|
---> byte_arg_var(byte_var)
|
|
; byte_arg_int_const(int)
|
|
; byte_arg_float_const(float).
|
|
|
|
:- type byte_dir
|
|
---> to_arg
|
|
; to_var
|
|
; to_none.
|
|
|
|
:- type byte_test_id
|
|
---> int_test
|
|
; char_test
|
|
; string_test
|
|
; float_test
|
|
; enum_test
|
|
; dummy_test.
|
|
|
|
:- type byte_module_id == module_name.
|
|
:- type byte_pred_id == string.
|
|
:- type byte_proc_id == int.
|
|
:- type byte_label_id == int.
|
|
:- type byte_var == int.
|
|
:- type byte_temp == int.
|
|
:- type byte_is_func == int. % 0 if a predicate, 1 if a function
|
|
|
|
:- pred output_bytecode_file(string::in, list(byte_code)::in,
|
|
io::di, io::uo) is det.
|
|
|
|
:- pred debug_bytecode_file(string::in, list(byte_code)::in,
|
|
io::di, io::uo) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module backend_libs.bytecode_data.
|
|
:- import_module backend_libs.c_util.
|
|
:- import_module libs.compiler_util.
|
|
|
|
:- import_module assoc_list.
|
|
:- import_module string.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred bytecode.version(int::out) is det.
|
|
|
|
bytecode.version(9).
|
|
|
|
output_bytecode_file(FileName, ByteCodes, !IO) :-
|
|
io.open_binary_output(FileName, Result, !IO),
|
|
( Result = ok(FileStream) ->
|
|
io.set_binary_output_stream(FileStream, OutputStream, !IO),
|
|
bytecode.version(Version),
|
|
output_short(Version, !IO),
|
|
output_bytecode_list(ByteCodes, !IO),
|
|
io.set_binary_output_stream(OutputStream, _, !IO),
|
|
io.close_binary_output(FileStream, !IO)
|
|
;
|
|
io.progname_base("byte.m", ProgName, !IO),
|
|
io.write_string("\n", !IO),
|
|
io.write_string(ProgName, !IO),
|
|
io.write_string(": can't open `", !IO),
|
|
io.write_string(FileName, !IO),
|
|
io.write_string("' for output\n", !IO),
|
|
io.set_exit_status(1, !IO)
|
|
).
|
|
|
|
debug_bytecode_file(FileName, ByteCodes, !IO) :-
|
|
io.open_output(FileName, Result, !IO),
|
|
( Result = ok(FileStream) ->
|
|
io.set_output_stream(FileStream, OutputStream, !IO),
|
|
bytecode.version(Version),
|
|
io.write_string("bytecode_version ", !IO),
|
|
io.write_int(Version, !IO),
|
|
io.write_string("\n", !IO),
|
|
debug_bytecode_list(ByteCodes, !IO),
|
|
io.set_output_stream(OutputStream, _, !IO),
|
|
io.close_output(FileStream, !IO)
|
|
;
|
|
io.progname_base("byte.m", ProgName, !IO),
|
|
io.write_string("\n", !IO),
|
|
io.write_string(ProgName, !IO),
|
|
io.write_string(": can't open `", !IO),
|
|
io.write_string(FileName, !IO),
|
|
io.write_string("' for output\n", !IO),
|
|
io.set_exit_status(1, !IO)
|
|
).
|
|
|
|
:- pred output_bytecode_list(list(byte_code)::in, io::di, io::uo) is det.
|
|
|
|
output_bytecode_list([], !IO).
|
|
output_bytecode_list([ByteCode | ByteCodes], !IO) :-
|
|
byte_code(ByteCode, Byte),
|
|
io.write_byte(Byte, !IO),
|
|
output_args(ByteCode, !IO),
|
|
output_bytecode_list(ByteCodes, !IO).
|
|
|
|
:- pred debug_bytecode_list(list(byte_code)::in, io::di, io::uo) is det.
|
|
|
|
debug_bytecode_list([], !IO).
|
|
debug_bytecode_list([ByteCode | ByteCodes], !IO) :-
|
|
byte_debug(ByteCode, Debug),
|
|
debug_string(Debug, !IO),
|
|
debug_args(ByteCode, !IO),
|
|
io.write_char('\n', !IO),
|
|
debug_bytecode_list(ByteCodes, !IO).
|
|
|
|
:- pred output_args(byte_code::in, io::di, io::uo) is det.
|
|
|
|
output_args(byte_enter_pred(PredId, PredArity, IsFunc, ProcCount), !IO) :-
|
|
output_pred_id(PredId, !IO),
|
|
output_length(PredArity, !IO),
|
|
output_is_func(IsFunc, !IO),
|
|
output_length(ProcCount, !IO).
|
|
output_args(byte_endof_pred, !IO).
|
|
output_args(byte_enter_proc(ProcId, Detism, LabelCount, LabelId, TempCount,
|
|
Vars), !IO) :-
|
|
output_proc_id(ProcId, !IO),
|
|
output_determinism(Detism, !IO),
|
|
output_length(LabelCount, !IO),
|
|
output_label_id(LabelId, !IO),
|
|
output_length(TempCount, !IO),
|
|
list.length(Vars, VarCount),
|
|
output_length(VarCount, !IO),
|
|
output_var_infos(Vars, !IO).
|
|
output_args(byte_endof_proc, !IO).
|
|
output_args(byte_label(LabelId), !IO) :-
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_enter_disjunction(LabelId), !IO) :-
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_endof_disjunction, !IO).
|
|
output_args(byte_enter_disjunct(LabelId), !IO) :-
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_endof_disjunct(LabelId), !IO) :-
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_enter_switch(Var, LabelId), !IO) :-
|
|
output_var(Var, !IO),
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_endof_switch, !IO).
|
|
output_args(byte_enter_switch_arm(ConsId, NextLabelId), !IO) :-
|
|
output_cons_id(ConsId, !IO),
|
|
output_label_id(NextLabelId, !IO).
|
|
output_args(byte_endof_switch_arm(LabelId), !IO) :-
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_enter_if(ElseLabelId, FollowLabelId, FramePtrTemp), !IO) :-
|
|
output_label_id(ElseLabelId, !IO),
|
|
output_label_id(FollowLabelId, !IO),
|
|
output_temp(FramePtrTemp, !IO).
|
|
output_args(byte_enter_then(FramePtrTemp), !IO) :-
|
|
output_temp(FramePtrTemp, !IO).
|
|
output_args(byte_endof_then(FollowLabelId), !IO) :-
|
|
output_label_id(FollowLabelId, !IO).
|
|
output_args(byte_enter_else(FramePtrTemp), !IO) :-
|
|
output_temp(FramePtrTemp, !IO).
|
|
output_args(byte_endof_if, !IO).
|
|
output_args(byte_enter_negation(FramePtrTemp, LabelId), !IO) :-
|
|
output_temp(FramePtrTemp, !IO),
|
|
output_label_id(LabelId, !IO).
|
|
output_args(byte_endof_negation_goal(FramePtrTemp), !IO) :-
|
|
output_temp(FramePtrTemp, !IO).
|
|
output_args(byte_endof_negation, !IO).
|
|
output_args(byte_enter_commit(Temp), !IO) :-
|
|
output_temp(Temp, !IO).
|
|
output_args(byte_endof_commit(Temp), !IO) :-
|
|
output_temp(Temp, !IO).
|
|
output_args(byte_assign(Var1, Var2), !IO) :-
|
|
output_var(Var1, !IO),
|
|
output_var(Var2, !IO).
|
|
output_args(byte_test(Var1, Var2, TestId), !IO) :-
|
|
output_var(Var1, !IO),
|
|
output_var(Var2, !IO),
|
|
output_test_id(TestId, !IO).
|
|
output_args(byte_construct(Var, ConsId, Vars), !IO) :-
|
|
output_var(Var, !IO),
|
|
output_cons_id(ConsId, !IO),
|
|
list.length(Vars, Length),
|
|
output_length(Length, !IO),
|
|
output_vars(Vars, !IO).
|
|
output_args(byte_deconstruct(Var, ConsId, Vars), !IO) :-
|
|
output_var(Var, !IO),
|
|
output_cons_id(ConsId, !IO),
|
|
list.length(Vars, Length),
|
|
output_length(Length, !IO),
|
|
output_vars(Vars, !IO).
|
|
output_args(byte_complex_construct(Var, ConsId, VarDirs), !IO) :-
|
|
output_var(Var, !IO),
|
|
output_cons_id(ConsId, !IO),
|
|
list.length(VarDirs, Length),
|
|
output_length(Length, !IO),
|
|
output_var_dirs(VarDirs, !IO).
|
|
output_args(byte_complex_deconstruct(Var, ConsId, VarDirs), !IO) :-
|
|
output_var(Var, !IO),
|
|
output_cons_id(ConsId, !IO),
|
|
list.length(VarDirs, Length),
|
|
output_length(Length, !IO),
|
|
output_var_dirs(VarDirs, !IO).
|
|
output_args(byte_place_arg(RegType, RegNum, Var), !IO) :-
|
|
output_reg(RegType, RegNum, !IO),
|
|
output_var(Var, !IO).
|
|
output_args(byte_pickup_arg(RegType, RegNum, Var), !IO) :-
|
|
output_reg(RegType, RegNum, !IO),
|
|
output_var(Var, !IO).
|
|
output_args(byte_call(ModuleId, PredId, Arity, IsFunc, ProcId), !IO) :-
|
|
output_module_id(ModuleId, !IO),
|
|
output_pred_id(PredId, !IO),
|
|
output_length(Arity, !IO),
|
|
output_is_func(IsFunc, !IO),
|
|
output_proc_id(ProcId, !IO).
|
|
output_args(byte_higher_order_call(PredVar, InVarCount, OutVarCount, Detism),
|
|
!IO) :-
|
|
output_var(PredVar, !IO),
|
|
output_length(InVarCount, !IO),
|
|
output_length(OutVarCount, !IO),
|
|
output_determinism(Detism, !IO).
|
|
output_args(byte_builtin_binop(Binop, Var1, Var2, Var3), !IO) :-
|
|
output_binop(Binop, !IO),
|
|
output_arg(Var1, !IO),
|
|
output_arg(Var2, !IO),
|
|
output_var(Var3, !IO).
|
|
output_args(byte_builtin_unop(Unop, Var1, Var2), !IO) :-
|
|
output_unop(Unop, !IO),
|
|
output_arg(Var1, !IO),
|
|
output_var(Var2, !IO).
|
|
output_args(byte_builtin_bintest(Binop, Var1, Var2), !IO) :-
|
|
output_binop(Binop, !IO),
|
|
output_arg(Var1, !IO),
|
|
output_arg(Var2, !IO).
|
|
output_args(byte_builtin_untest(Unop, Var1), !IO) :-
|
|
output_unop(Unop, !IO),
|
|
output_arg(Var1, !IO).
|
|
output_args(byte_semidet_succeed, !IO).
|
|
output_args(byte_semidet_success_check, !IO).
|
|
output_args(byte_fail, !IO).
|
|
output_args(byte_context(Line), !IO) :-
|
|
output_short(Line, !IO).
|
|
output_args(byte_not_supported, !IO).
|
|
|
|
:- pred debug_args(byte_code::in, io::di, io::uo) is det.
|
|
|
|
debug_args(byte_enter_pred(PredId, PredArity, IsFunc, ProcsCount), !IO) :-
|
|
debug_pred_id(PredId, !IO),
|
|
debug_length(PredArity, !IO),
|
|
debug_is_func(IsFunc, !IO),
|
|
debug_length(ProcsCount, !IO).
|
|
debug_args(byte_endof_pred, !IO).
|
|
debug_args(byte_enter_proc(ProcId, Detism, LabelCount, LabelId, TempCount,
|
|
Vars), !IO) :-
|
|
debug_proc_id(ProcId, !IO),
|
|
debug_determinism(Detism, !IO),
|
|
debug_length(LabelCount, !IO),
|
|
debug_label_id(LabelId, !IO),
|
|
debug_length(TempCount, !IO),
|
|
list.length(Vars, VarCount),
|
|
debug_length(VarCount, !IO),
|
|
debug_var_infos(Vars, !IO).
|
|
debug_args(byte_endof_proc, !IO).
|
|
debug_args(byte_label(LabelId), !IO) :-
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_enter_disjunction(LabelId), !IO) :-
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_endof_disjunction, !IO).
|
|
debug_args(byte_enter_disjunct(LabelId), !IO) :-
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_endof_disjunct(LabelId), !IO) :-
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_enter_switch(Var, LabelId), !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_endof_switch, !IO).
|
|
debug_args(byte_enter_switch_arm(ConsId, NextLabelId), !IO) :-
|
|
debug_cons_id(ConsId, !IO),
|
|
debug_label_id(NextLabelId, !IO).
|
|
debug_args(byte_endof_switch_arm(LabelId), !IO) :-
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_enter_if(ElseLabelId, FollowLabelId, FramePtrTemp), !IO) :-
|
|
debug_label_id(ElseLabelId, !IO),
|
|
debug_label_id(FollowLabelId, !IO),
|
|
debug_temp(FramePtrTemp, !IO).
|
|
debug_args(byte_enter_then(FramePtrTemp), !IO) :-
|
|
debug_temp(FramePtrTemp, !IO).
|
|
debug_args(byte_endof_then(FollowLabelId), !IO) :-
|
|
debug_label_id(FollowLabelId, !IO).
|
|
debug_args(byte_enter_else(FramePtrTemp), !IO) :-
|
|
debug_temp(FramePtrTemp, !IO).
|
|
debug_args(byte_endof_if, !IO).
|
|
debug_args(byte_enter_negation(FramePtrTemp, LabelId), !IO) :-
|
|
debug_temp(FramePtrTemp, !IO),
|
|
debug_label_id(LabelId, !IO).
|
|
debug_args(byte_endof_negation_goal(FramePtrTemp), !IO) :-
|
|
debug_temp(FramePtrTemp, !IO).
|
|
debug_args(byte_endof_negation, !IO).
|
|
debug_args(byte_enter_commit(Temp), !IO) :-
|
|
debug_temp(Temp, !IO).
|
|
debug_args(byte_endof_commit(Temp), !IO) :-
|
|
debug_temp(Temp, !IO).
|
|
debug_args(byte_assign(Var1, Var2), !IO) :-
|
|
debug_var(Var1, !IO),
|
|
debug_var(Var2, !IO).
|
|
debug_args(byte_test(Var1, Var2, TestId), !IO) :-
|
|
debug_var(Var1, !IO),
|
|
debug_var(Var2, !IO),
|
|
debug_test_id(TestId, !IO).
|
|
debug_args(byte_construct(Var, ConsId, Vars), !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_cons_id(ConsId, !IO),
|
|
list.length(Vars, Length),
|
|
debug_length(Length, !IO),
|
|
debug_vars(Vars, !IO).
|
|
debug_args(byte_deconstruct(Var, ConsId, Vars), !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_cons_id(ConsId, !IO),
|
|
list.length(Vars, Length),
|
|
debug_length(Length, !IO),
|
|
debug_vars(Vars, !IO).
|
|
debug_args(byte_complex_construct(Var, ConsId, VarDirs), !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_cons_id(ConsId, !IO),
|
|
list.length(VarDirs, Length),
|
|
debug_length(Length, !IO),
|
|
debug_var_dirs(VarDirs, !IO).
|
|
debug_args(byte_complex_deconstruct(Var, ConsId, VarDirs), !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_cons_id(ConsId, !IO),
|
|
list.length(VarDirs, Length),
|
|
debug_length(Length, !IO),
|
|
debug_var_dirs(VarDirs, !IO).
|
|
debug_args(byte_place_arg(RegType, RegNum, Var), !IO) :-
|
|
debug_reg(RegType, RegNum, !IO),
|
|
debug_var(Var, !IO).
|
|
debug_args(byte_pickup_arg(RegType, RegNum, Var), !IO) :-
|
|
debug_reg(RegType, RegNum, !IO),
|
|
debug_var(Var, !IO).
|
|
debug_args(byte_call(ModuleId, PredId, Arity, IsFunc, ProcId), !IO) :-
|
|
debug_module_id(ModuleId, !IO),
|
|
debug_pred_id(PredId, !IO),
|
|
debug_length(Arity, !IO),
|
|
debug_is_func(IsFunc, !IO),
|
|
debug_proc_id(ProcId, !IO).
|
|
debug_args(byte_higher_order_call(PredVar, InVarCount, OutVarCount, Detism),
|
|
!IO) :-
|
|
debug_var(PredVar, !IO),
|
|
debug_length(InVarCount, !IO),
|
|
debug_length(OutVarCount, !IO),
|
|
debug_determinism(Detism, !IO).
|
|
debug_args(byte_builtin_binop(Binop, Var1, Var2, Var3), !IO) :-
|
|
debug_binop(Binop, !IO),
|
|
debug_arg(Var1, !IO),
|
|
debug_arg(Var2, !IO),
|
|
debug_var(Var3, !IO).
|
|
debug_args(byte_builtin_unop(Unop, Var1, Var2), !IO) :-
|
|
debug_unop(Unop, !IO),
|
|
debug_arg(Var1, !IO),
|
|
debug_var(Var2, !IO).
|
|
debug_args(byte_builtin_bintest(Binop, Var1, Var2), !IO) :-
|
|
debug_binop(Binop, !IO),
|
|
debug_arg(Var1, !IO),
|
|
debug_arg(Var2, !IO).
|
|
debug_args(byte_builtin_untest(Unop, Var1), !IO) :-
|
|
debug_unop(Unop, !IO),
|
|
debug_arg(Var1, !IO).
|
|
debug_args(byte_semidet_succeed, !IO).
|
|
debug_args(byte_semidet_success_check, !IO).
|
|
debug_args(byte_fail, !IO).
|
|
debug_args(byte_context(Line), !IO) :-
|
|
debug_int(Line, !IO).
|
|
debug_args(byte_not_supported, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_var_infos(list(byte_var_info)::in, io::di, io::uo) is det.
|
|
|
|
output_var_infos([], !IO).
|
|
output_var_infos([Var | Vars], !IO) :-
|
|
output_var_info(Var, !IO),
|
|
output_var_infos(Vars, !IO).
|
|
|
|
:- pred output_var_info(byte_var_info::in, io::di, io::uo) is det.
|
|
|
|
output_var_info(var_info(Name, _), !IO) :-
|
|
output_string(Name, !IO).
|
|
|
|
:- pred debug_var_infos(list(byte_var_info)::in, io::di, io::uo) is det.
|
|
|
|
debug_var_infos([], !IO).
|
|
debug_var_infos([Var | Vars], !IO) :-
|
|
debug_var_info(Var, !IO),
|
|
debug_var_infos(Vars, !IO).
|
|
|
|
:- pred debug_var_info(byte_var_info::in, io::di, io::uo) is det.
|
|
|
|
debug_var_info(var_info(Name, _), !IO) :-
|
|
debug_string(Name, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_determinism(determinism::in, io::di, io::uo) is det.
|
|
|
|
output_determinism(Detism, !IO) :-
|
|
determinism_code(Detism, Code),
|
|
output_byte(Code, !IO).
|
|
|
|
:- pred debug_determinism(determinism::in, io::di, io::uo) is det.
|
|
|
|
debug_determinism(Detism, !IO) :-
|
|
determinism_debug(Detism, Debug),
|
|
debug_string(Debug, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_reg(byte_reg_type::in, int::in, io::di, io::uo) is det.
|
|
|
|
output_reg(byte_reg_r, N, !IO) :-
|
|
output_byte(N, !IO).
|
|
|
|
:- pred debug_reg(byte_reg_type::in, int::in, io::di, io::uo) is det.
|
|
|
|
debug_reg(byte_reg_r, N, !IO) :-
|
|
debug_int(N, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_is_func(byte_is_func::in, io::di, io::uo) is det.
|
|
|
|
output_is_func(IsFunc, !IO) :-
|
|
( ( IsFunc = 1 ; IsFunc = 0 ) ->
|
|
output_byte(IsFunc, !IO)
|
|
;
|
|
unexpected(this_file, "output_is_func: " ++
|
|
"invalid predicate or function specified in bytecode")
|
|
).
|
|
|
|
:- pred debug_is_func(byte_is_func::in, io::di, io::uo) is det.
|
|
|
|
debug_is_func(IsFunc, !IO) :-
|
|
( IsFunc = 1 ->
|
|
debug_string("func", !IO)
|
|
; IsFunc = 0 ->
|
|
debug_string("pred", !IO)
|
|
;
|
|
unexpected(this_file, "debug_is_func: " ++
|
|
"invalid predicate or function specifier in bytecode.")
|
|
).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_length(int::in, io::di, io::uo) is det.
|
|
|
|
output_length(Length, !IO) :-
|
|
output_short(Length, !IO).
|
|
|
|
:- pred debug_length(int::in, io::di, io::uo) is det.
|
|
|
|
debug_length(Length, !IO) :-
|
|
debug_int(Length, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_arg(byte_arg::in, io::di, io::uo) is det.
|
|
|
|
output_arg(byte_arg_var(Var), !IO) :-
|
|
output_byte(0, !IO),
|
|
output_var(Var, !IO).
|
|
output_arg(byte_arg_int_const(IntVal), !IO) :-
|
|
output_byte(1, !IO),
|
|
output_int(IntVal, !IO).
|
|
output_arg(byte_arg_float_const(FloatVal), !IO) :-
|
|
output_byte(2, !IO),
|
|
output_float(FloatVal, !IO).
|
|
|
|
:- pred debug_arg(byte_arg::in, io::di, io::uo) is det.
|
|
|
|
debug_arg(byte_arg_var(Var), !IO) :-
|
|
debug_string("var", !IO),
|
|
debug_var(Var, !IO).
|
|
debug_arg(byte_arg_int_const(IntVal), !IO) :-
|
|
debug_string("int", !IO),
|
|
debug_int(IntVal, !IO).
|
|
debug_arg(byte_arg_float_const(FloatVal), !IO) :-
|
|
debug_string("float", !IO),
|
|
debug_float(FloatVal, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_var(byte_var::in, io::di, io::uo) is det.
|
|
|
|
output_var(Var, !IO) :-
|
|
output_short(Var, !IO).
|
|
|
|
:- pred output_vars(list(byte_var)::in, io::di, io::uo) is det.
|
|
|
|
output_vars([], !IO).
|
|
output_vars([Var | Vars], !IO) :-
|
|
output_var(Var, !IO),
|
|
output_vars(Vars, !IO).
|
|
|
|
:- pred debug_var(byte_var::in, io::di, io::uo) is det.
|
|
|
|
debug_var(Var, !IO) :-
|
|
debug_int(Var, !IO).
|
|
|
|
:- pred debug_vars(list(byte_var)::in, io::di, io::uo) is det.
|
|
|
|
debug_vars([], !IO).
|
|
debug_vars([Var | Vars], !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_vars(Vars, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_temp(byte_temp::in, io::di, io::uo) is det.
|
|
|
|
output_temp(Var, !IO) :-
|
|
output_short(Var, !IO).
|
|
|
|
:- pred debug_temp(byte_temp::in, io::di, io::uo) is det.
|
|
|
|
debug_temp(Var, !IO) :-
|
|
debug_int(Var, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_dir(byte_dir::in, io::di, io::uo) is det.
|
|
|
|
output_dir(to_arg, !IO) :-
|
|
output_byte(0, !IO).
|
|
output_dir(to_var, !IO) :-
|
|
output_byte(1, !IO).
|
|
output_dir(to_none, !IO) :-
|
|
output_byte(2, !IO).
|
|
|
|
:- pred output_var_dirs(assoc_list(byte_var, byte_dir)::in,
|
|
io::di, io::uo) is det.
|
|
|
|
output_var_dirs([], !IO).
|
|
output_var_dirs([Var - Dir | VarDirs], !IO) :-
|
|
output_var(Var, !IO),
|
|
output_dir(Dir, !IO),
|
|
output_var_dirs(VarDirs, !IO).
|
|
|
|
:- pred debug_dir(byte_dir::in, io::di, io::uo) is det.
|
|
|
|
debug_dir(to_arg, !IO) :-
|
|
debug_string("to_arg", !IO).
|
|
debug_dir(to_var, !IO) :-
|
|
debug_string("to_var", !IO).
|
|
debug_dir(to_none, !IO) :-
|
|
debug_string("to_none", !IO).
|
|
|
|
:- pred debug_var_dirs(assoc_list(byte_var, byte_dir)::in,
|
|
io::di, io::uo) is det.
|
|
|
|
debug_var_dirs([], !IO).
|
|
debug_var_dirs([Var - Dir | VarDirs], !IO) :-
|
|
debug_var(Var, !IO),
|
|
debug_dir(Dir, !IO),
|
|
debug_var_dirs(VarDirs, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_test_id(byte_test_id::in, io::di, io::uo) is det.
|
|
|
|
output_test_id(int_test, !IO) :- output_byte(0, !IO).
|
|
output_test_id(char_test, !IO) :- output_byte(1, !IO).
|
|
output_test_id(string_test, !IO) :- output_byte(2, !IO).
|
|
output_test_id(float_test, !IO) :- output_byte(3, !IO).
|
|
output_test_id(enum_test, !IO) :- output_byte(4, !IO).
|
|
output_test_id(dummy_test, !IO) :- output_byte(5, !IO).
|
|
|
|
:- pred debug_test_id(byte_test_id::in, io::di, io::uo) is det.
|
|
|
|
debug_test_id(int_test, !IO) :- debug_string("int", !IO).
|
|
debug_test_id(char_test, !IO) :- debug_string("char", !IO).
|
|
debug_test_id(string_test, !IO) :- debug_string("string", !IO).
|
|
debug_test_id(float_test, !IO) :- debug_string("float", !IO).
|
|
debug_test_id(enum_test, !IO) :- debug_string("enum", !IO).
|
|
debug_test_id(dummy_test, !IO) :- debug_string("dummy", !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_module_id(byte_module_id::in, io::di, io::uo) is det.
|
|
|
|
output_module_id(ModuleId, !IO) :-
|
|
output_string(sym_name_to_string(ModuleId), !IO).
|
|
|
|
:- pred debug_module_id(byte_module_id::in, io::di, io::uo) is det.
|
|
|
|
debug_module_id(ModuleId, !IO) :-
|
|
debug_sym_name(ModuleId, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_pred_id(byte_pred_id::in, io::di, io::uo) is det.
|
|
|
|
output_pred_id(PredId, !IO) :-
|
|
output_string(PredId, !IO).
|
|
|
|
:- pred debug_pred_id(byte_pred_id::in, io::di, io::uo) is det.
|
|
|
|
debug_pred_id(PredId, !IO) :-
|
|
debug_string(PredId, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_proc_id(byte_proc_id::in, io::di, io::uo) is det.
|
|
|
|
output_proc_id(ProcId, !IO) :-
|
|
output_byte(ProcId, !IO).
|
|
|
|
:- pred debug_proc_id(byte_proc_id::in, io::di, io::uo) is det.
|
|
|
|
debug_proc_id(ProcId, !IO) :-
|
|
debug_int(ProcId, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_label_id(int::in, io::di, io::uo) is det.
|
|
|
|
output_label_id(LabelId, !IO) :-
|
|
output_short(LabelId, !IO).
|
|
|
|
:- pred debug_label_id(int::in, io::di, io::uo) is det.
|
|
|
|
debug_label_id(LabelId, !IO) :-
|
|
debug_int(LabelId, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_cons_id(byte_cons_id::in, io::di, io::uo) is det.
|
|
|
|
output_cons_id(byte_cons(ModuleId, Functor, Arity, Tag), !IO) :-
|
|
output_byte(0, !IO),
|
|
output_module_id(ModuleId, !IO),
|
|
output_string(Functor, !IO),
|
|
output_short(Arity, !IO),
|
|
output_tag(Tag, !IO).
|
|
output_cons_id(byte_int_const(IntVal), !IO) :-
|
|
output_byte(1, !IO),
|
|
output_int(IntVal, !IO).
|
|
output_cons_id(byte_string_const(StringVal), !IO) :-
|
|
output_byte(2, !IO),
|
|
output_string(StringVal, !IO).
|
|
output_cons_id(byte_float_const(FloatVal), !IO) :-
|
|
output_byte(3, !IO),
|
|
output_float(FloatVal, !IO).
|
|
output_cons_id(byte_pred_const(ModuleId, PredId, Arity, IsFunc, ProcId), !IO) :-
|
|
output_byte(4, !IO),
|
|
output_module_id(ModuleId, !IO),
|
|
output_pred_id(PredId, !IO),
|
|
output_length(Arity, !IO),
|
|
output_is_func(IsFunc, !IO),
|
|
output_proc_id(ProcId, !IO).
|
|
output_cons_id(byte_type_ctor_info_const(ModuleId, TypeName, TypeArity), !IO) :-
|
|
output_byte(6, !IO),
|
|
output_module_id(ModuleId, !IO),
|
|
output_string(TypeName, !IO),
|
|
output_byte(TypeArity, !IO).
|
|
output_cons_id(byte_char_const(Char), !IO) :-
|
|
output_byte(7, !IO),
|
|
char.to_int(Char, Byte),
|
|
output_byte(Byte, !IO).
|
|
% XXX
|
|
output_cons_id(byte_base_typeclass_info_const(_, _, _), !IO) :-
|
|
sorry(this_file, "bytecode for typeclass not yet implemented."),
|
|
output_byte(8, !IO).
|
|
output_cons_id(byte_type_info_cell_constructor, !IO) :-
|
|
sorry(this_file, "bytecode for type_info_cell_constructor " ++
|
|
"not yet implemented."),
|
|
output_byte(9, !IO).
|
|
output_cons_id(byte_typeclass_info_cell_constructor, !IO) :-
|
|
sorry(this_file, "bytecode for typeclass_info_cell_constructor " ++
|
|
"not yet implemented."),
|
|
output_byte(10, !IO).
|
|
|
|
:- pred debug_cons_id(byte_cons_id::in, io::di, io::uo) is det.
|
|
|
|
debug_cons_id(byte_cons(ModuleId, Functor, Arity, Tag), !IO) :-
|
|
debug_string("functor", !IO),
|
|
debug_sym_name(ModuleId, !IO),
|
|
debug_string(Functor, !IO),
|
|
debug_int(Arity, !IO),
|
|
debug_tag(Tag, !IO).
|
|
debug_cons_id(byte_int_const(IntVal), !IO) :-
|
|
debug_string("int_const", !IO),
|
|
debug_int(IntVal, !IO).
|
|
debug_cons_id(byte_string_const(StringVal), !IO) :-
|
|
debug_string("string_const", !IO),
|
|
debug_cstring(StringVal, !IO).
|
|
debug_cons_id(byte_float_const(FloatVal), !IO) :-
|
|
debug_string("float_const", !IO),
|
|
debug_float(FloatVal, !IO).
|
|
debug_cons_id(byte_pred_const(ModuleId, PredId, Arity, IsFunc, ProcId), !IO) :-
|
|
debug_string("pred_const", !IO),
|
|
debug_module_id(ModuleId, !IO),
|
|
debug_pred_id(PredId, !IO),
|
|
debug_length(Arity, !IO),
|
|
debug_is_func(IsFunc, !IO),
|
|
debug_proc_id(ProcId, !IO).
|
|
debug_cons_id(byte_type_ctor_info_const(ModuleId, TypeName, TypeArity), !IO) :-
|
|
debug_string("type_ctor_info_const", !IO),
|
|
debug_module_id(ModuleId, !IO),
|
|
debug_string(TypeName, !IO),
|
|
debug_int(TypeArity, !IO).
|
|
debug_cons_id(byte_base_typeclass_info_const(ModuleId,
|
|
class_id(ClassName, ClassArity), Instance), !IO) :-
|
|
debug_string("base_typeclass_info_const", !IO),
|
|
debug_module_id(ModuleId, !IO),
|
|
debug_string("class_id", !IO),
|
|
debug_sym_name(ClassName, !IO),
|
|
debug_string("/", !IO),
|
|
debug_int(ClassArity, !IO),
|
|
debug_string(Instance, !IO).
|
|
debug_cons_id(byte_char_const(Char), !IO) :-
|
|
debug_string("char_const", !IO),
|
|
string.from_char_list([Char], String),
|
|
debug_string(String, !IO).
|
|
debug_cons_id(byte_type_info_cell_constructor, !IO) :-
|
|
debug_string("type_info_cell_constructor", !IO).
|
|
debug_cons_id(byte_typeclass_info_cell_constructor, !IO) :-
|
|
debug_string("typeclass_info_cell_constructor", !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_tag(byte_cons_tag::in, io::di, io::uo) is det.
|
|
|
|
output_tag(byte_unshared_tag(Primary), !IO) :-
|
|
output_byte(0, !IO),
|
|
output_byte(Primary, !IO).
|
|
output_tag(byte_shared_remote_tag(Primary, Secondary), !IO) :-
|
|
output_byte(1, !IO),
|
|
output_byte(Primary, !IO),
|
|
output_int(Secondary, !IO).
|
|
output_tag(byte_shared_local_tag(Primary, Secondary), !IO) :-
|
|
output_byte(2, !IO),
|
|
output_byte(Primary, !IO),
|
|
output_int(Secondary, !IO).
|
|
output_tag(byte_enum_tag(Enum), !IO) :-
|
|
output_byte(3, !IO),
|
|
output_byte(Enum, !IO).
|
|
output_tag(byte_no_tag, !IO) :-
|
|
output_byte(4, !IO).
|
|
|
|
:- pred debug_tag(byte_cons_tag::in, io::di, io::uo) is det.
|
|
|
|
debug_tag(byte_unshared_tag(Primary), !IO) :-
|
|
debug_string("unshared_tag", !IO),
|
|
debug_int(Primary, !IO).
|
|
debug_tag(byte_shared_remote_tag(Primary, Secondary), !IO) :-
|
|
debug_string("shared_remote_tag", !IO),
|
|
debug_int(Primary, !IO),
|
|
debug_int(Secondary, !IO).
|
|
debug_tag(byte_shared_local_tag(Primary, Secondary), !IO) :-
|
|
debug_string("shared_local_tag", !IO),
|
|
debug_int(Primary, !IO),
|
|
debug_int(Secondary, !IO).
|
|
debug_tag(byte_enum_tag(Enum), !IO) :-
|
|
debug_string("enum_tag", !IO),
|
|
debug_int(Enum, !IO).
|
|
debug_tag(byte_no_tag, !IO) :-
|
|
debug_string("no_tag", !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_binop(binary_op::in, io::di, io::uo) is det.
|
|
|
|
output_binop(Binop, !IO) :-
|
|
binop_code(Binop, Code),
|
|
output_byte(Code, !IO).
|
|
|
|
:- pred debug_binop(binary_op::in, io::di, io::uo) is det.
|
|
|
|
debug_binop(Binop, !IO) :-
|
|
binop_debug(Binop, Debug),
|
|
debug_string(Debug, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred output_unop(unary_op::in, io::di, io::uo) is det.
|
|
|
|
output_unop(Unop, !IO) :-
|
|
unop_code(Unop, Code),
|
|
output_byte(Code, !IO).
|
|
|
|
:- pred debug_unop(unary_op::in, io::di, io::uo) is det.
|
|
|
|
debug_unop(Unop, !IO) :-
|
|
unop_debug(Unop, Debug),
|
|
debug_string(Debug, !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- pred byte_code(byte_code::in, int::out) is det.
|
|
|
|
byte_code(byte_enter_pred(_, _, _, _), 0).
|
|
byte_code(byte_endof_pred, 1).
|
|
byte_code(byte_enter_proc(_, _, _, _, _, _), 2).
|
|
byte_code(byte_endof_proc, 3).
|
|
byte_code(byte_label(_), 4).
|
|
byte_code(byte_enter_disjunction(_), 5).
|
|
byte_code(byte_endof_disjunction, 6).
|
|
byte_code(byte_enter_disjunct(_), 7).
|
|
byte_code(byte_endof_disjunct(_), 8).
|
|
byte_code(byte_enter_switch(_, _), 9).
|
|
byte_code(byte_endof_switch, 10).
|
|
byte_code(byte_enter_switch_arm(_, _), 11).
|
|
byte_code(byte_endof_switch_arm(_), 12).
|
|
byte_code(byte_enter_if(_, _, _), 13).
|
|
byte_code(byte_enter_then(_), 14).
|
|
byte_code(byte_endof_then(_), 15).
|
|
byte_code(byte_endof_if, 16).
|
|
byte_code(byte_enter_negation(_, _), 17).
|
|
byte_code(byte_endof_negation, 18).
|
|
byte_code(byte_enter_commit(_), 19).
|
|
byte_code(byte_endof_commit(_), 20).
|
|
byte_code(byte_assign(_, _), 21).
|
|
byte_code(byte_test(_, _, _), 22).
|
|
byte_code(byte_construct(_, _, _), 23).
|
|
byte_code(byte_deconstruct(_, _, _), 24).
|
|
byte_code(byte_complex_construct(_, _, _), 25).
|
|
byte_code(byte_complex_deconstruct(_, _, _), 26).
|
|
byte_code(byte_place_arg(_, _, _), 27).
|
|
byte_code(byte_pickup_arg(_, _, _), 28).
|
|
byte_code(byte_call(_, _, _, _, _), 29).
|
|
byte_code(byte_higher_order_call(_, _, _, _), 30).
|
|
byte_code(byte_builtin_binop(_, _, _, _), 31).
|
|
byte_code(byte_builtin_unop(_, _, _), 32).
|
|
byte_code(byte_builtin_bintest(_, _, _), 33).
|
|
byte_code(byte_builtin_untest(_, _), 34).
|
|
byte_code(byte_semidet_succeed, 35).
|
|
byte_code(byte_semidet_success_check, 36).
|
|
byte_code(byte_fail, 37).
|
|
byte_code(byte_context(_), 38).
|
|
byte_code(byte_not_supported, 39).
|
|
byte_code(byte_enter_else(_), 40).
|
|
byte_code(byte_endof_negation_goal(_), 41).
|
|
|
|
:- pred byte_debug(byte_code::in, string::out) is det.
|
|
|
|
byte_debug(byte_enter_pred(_, _, _, _), "enter_pred").
|
|
byte_debug(byte_endof_pred, "endof_pred").
|
|
byte_debug(byte_enter_proc(_, _, _, _, _, _), "enter_proc").
|
|
byte_debug(byte_endof_proc, "endof_proc").
|
|
byte_debug(byte_label(_), "label").
|
|
byte_debug(byte_enter_disjunction(_), "enter_disjunction").
|
|
byte_debug(byte_endof_disjunction, "endof_disjunction").
|
|
byte_debug(byte_enter_disjunct(_), "enter_disjunct").
|
|
byte_debug(byte_endof_disjunct(_), "endof_disjunct").
|
|
byte_debug(byte_enter_switch(_, _), "enter_switch").
|
|
byte_debug(byte_endof_switch, "endof_switch").
|
|
byte_debug(byte_enter_switch_arm(_, _), "enter_switch_arm").
|
|
byte_debug(byte_endof_switch_arm(_), "endof_switch_arm").
|
|
byte_debug(byte_enter_if(_, _, _), "enter_if").
|
|
byte_debug(byte_enter_then(_), "enter_then").
|
|
byte_debug(byte_endof_then(_), "endof_then").
|
|
byte_debug(byte_enter_else(_), "enter_else").
|
|
byte_debug(byte_endof_if, "endof_if").
|
|
byte_debug(byte_enter_negation(_,_), "enter_negation").
|
|
byte_debug(byte_endof_negation_goal(_), "endof_negation_goal").
|
|
byte_debug(byte_endof_negation, "endof_negation").
|
|
byte_debug(byte_enter_commit(_), "enter_commit").
|
|
byte_debug(byte_endof_commit(_), "endof_commit").
|
|
byte_debug(byte_assign(_, _), "assign").
|
|
byte_debug(byte_test(_, _, _), "test").
|
|
byte_debug(byte_construct(_, _, _), "construct").
|
|
byte_debug(byte_deconstruct(_, _, _), "deconstruct").
|
|
byte_debug(byte_complex_construct(_, _, _), "complex_construct").
|
|
byte_debug(byte_complex_deconstruct(_, _, _), "complex_deconstruct").
|
|
byte_debug(byte_place_arg(_, _, _), "place_arg").
|
|
byte_debug(byte_pickup_arg(_, _, _), "pickup_arg").
|
|
byte_debug(byte_call(_, _, _, _, _), "call").
|
|
byte_debug(byte_higher_order_call(_, _, _, _), "higher_order_call").
|
|
byte_debug(byte_builtin_binop(_, _, _, _), "builtin_binop").
|
|
byte_debug(byte_builtin_unop(_, _, _), "builtin_unop").
|
|
byte_debug(byte_builtin_bintest(_, _, _), "builtin_bintest").
|
|
byte_debug(byte_builtin_untest(_, _), "builtin_untest").
|
|
byte_debug(byte_semidet_succeed, "semidet_succeed").
|
|
byte_debug(byte_semidet_success_check, "semidet_success_check").
|
|
byte_debug(byte_fail, "fail").
|
|
byte_debug(byte_context(_), "context").
|
|
byte_debug(byte_not_supported, "not_supported").
|
|
|
|
:- pred determinism_code(determinism::in, int::out) is det.
|
|
|
|
determinism_code(detism_det, 0).
|
|
determinism_code(detism_semi, 1).
|
|
determinism_code(detism_multi, 2).
|
|
determinism_code(detism_non, 3).
|
|
determinism_code(detism_cc_multi, 4).
|
|
determinism_code(detism_cc_non, 5).
|
|
determinism_code(detism_erroneous, 6).
|
|
determinism_code(detism_failure, 7).
|
|
|
|
:- pred determinism_debug(determinism::in, string::out) is det.
|
|
|
|
determinism_debug(detism_det, "det").
|
|
determinism_debug(detism_semi, "semidet").
|
|
determinism_debug(detism_multi, "multidet").
|
|
determinism_debug(detism_non, "nondet").
|
|
determinism_debug(detism_cc_multi, "cc_multidet").
|
|
determinism_debug(detism_cc_non, "cc_nondet").
|
|
determinism_debug(detism_erroneous, "erroneous").
|
|
determinism_debug(detism_failure, "failure").
|
|
|
|
:- pred binop_code(binary_op::in, int::out) is det.
|
|
|
|
binop_code(int_add, 0).
|
|
binop_code(int_sub, 1).
|
|
binop_code(int_mul, 2).
|
|
binop_code(int_div, 3).
|
|
binop_code(int_mod, 4).
|
|
binop_code(unchecked_left_shift, 5).
|
|
binop_code(unchecked_right_shift, 6).
|
|
binop_code(bitwise_and, 7).
|
|
binop_code(bitwise_or, 8).
|
|
binop_code(bitwise_xor, 9).
|
|
binop_code(logical_and, 10).
|
|
binop_code(logical_or, 11).
|
|
binop_code(eq, 12).
|
|
binop_code(ne, 13).
|
|
binop_code(array_index(_Type), 14).
|
|
binop_code(str_eq, 15).
|
|
binop_code(str_ne, 16).
|
|
binop_code(str_lt, 17).
|
|
binop_code(str_gt, 18).
|
|
binop_code(str_le, 19).
|
|
binop_code(str_ge, 20).
|
|
binop_code(int_lt, 21).
|
|
binop_code(int_gt, 22).
|
|
binop_code(int_le, 23).
|
|
binop_code(int_ge, 24).
|
|
binop_code(float_plus, 25).
|
|
binop_code(float_minus, 26).
|
|
binop_code(float_times, 27).
|
|
binop_code(float_divide, 28).
|
|
binop_code(float_eq, 29).
|
|
binop_code(float_ne, 30).
|
|
binop_code(float_lt, 31).
|
|
binop_code(float_gt, 32).
|
|
binop_code(float_le, 33).
|
|
binop_code(float_ge, 34).
|
|
binop_code(body, 35).
|
|
binop_code(unsigned_le, 36).
|
|
|
|
:- pred binop_debug(binary_op::in, string::out) is det.
|
|
|
|
binop_debug(int_add, "+").
|
|
binop_debug(int_sub, "-").
|
|
binop_debug(int_mul, "*").
|
|
binop_debug(int_div, "/").
|
|
binop_debug(int_mod, "mod").
|
|
binop_debug(unchecked_left_shift, "<<").
|
|
binop_debug(unchecked_right_shift, ">>").
|
|
binop_debug(bitwise_and, "&").
|
|
binop_debug(bitwise_or, "|").
|
|
binop_debug(bitwise_xor, "^").
|
|
binop_debug(logical_and, "and").
|
|
binop_debug(logical_or, "or").
|
|
binop_debug(eq, "eq").
|
|
binop_debug(ne, "ne").
|
|
binop_debug(array_index(_Type), "array_index").
|
|
binop_debug(str_eq, "str_eq").
|
|
binop_debug(str_ne, "str_ne").
|
|
binop_debug(str_lt, "str_lt").
|
|
binop_debug(str_gt, "str_gt").
|
|
binop_debug(str_le, "str_le").
|
|
binop_debug(str_ge, "str_ge").
|
|
binop_debug(int_lt, "<").
|
|
binop_debug(int_gt, ">").
|
|
binop_debug(int_le, "<=").
|
|
binop_debug(int_ge, ">=").
|
|
binop_debug(float_plus, "float_plus").
|
|
binop_debug(float_minus, "float_minus").
|
|
binop_debug(float_times, "float_times").
|
|
binop_debug(float_divide, "float_divide").
|
|
binop_debug(float_eq, "float_eq").
|
|
binop_debug(float_ne, "float_ne").
|
|
binop_debug(float_lt, "float_lt").
|
|
binop_debug(float_gt, "float_gt").
|
|
binop_debug(float_le, "float_le").
|
|
binop_debug(float_ge, "float_ge").
|
|
binop_debug(body, "body").
|
|
binop_debug(unsigned_le, "unsigned_le").
|
|
|
|
:- pred unop_code(unary_op::in, int::out) is det.
|
|
|
|
unop_code(mktag, 0).
|
|
unop_code(tag, 1).
|
|
unop_code(unmktag, 2).
|
|
unop_code(mkbody, 3).
|
|
unop_code(unmkbody, 4).
|
|
unop_code(strip_tag, 5).
|
|
unop_code(hash_string, 6).
|
|
unop_code(bitwise_complement, 7).
|
|
unop_code(logical_not, 8).
|
|
|
|
:- pred unop_debug(unary_op::in, string::out) is det.
|
|
|
|
unop_debug(mktag, "mktag").
|
|
unop_debug(tag, "tag").
|
|
unop_debug(unmktag, "unmktag").
|
|
unop_debug(mkbody, "mkbody").
|
|
unop_debug(unmkbody, "unmkbody").
|
|
unop_debug(strip_tag, "strip_tag").
|
|
unop_debug(hash_string, "hash_string").
|
|
unop_debug(bitwise_complement, "bitwise_complement").
|
|
unop_debug(logical_not, "not").
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% debug_cstring prints a string quoted in the manner of C.
|
|
%
|
|
:- pred debug_cstring(string::in, io::di, io::uo) is det.
|
|
|
|
debug_cstring(Str, !IO) :-
|
|
io.write_char('"', !IO),
|
|
c_util.output_quoted_string(Str, !IO),
|
|
io.write_char('"', !IO),
|
|
% XXX: We need the trailing space in case something follows
|
|
% the string as a bytecode argument. This is not very elegant.
|
|
io.write_char(' ', !IO).
|
|
|
|
:- pred debug_string(string::in, io::di, io::uo) is det.
|
|
|
|
debug_string(Val, !IO) :-
|
|
io.write_string(Val, !IO),
|
|
io.write_char(' ', !IO).
|
|
|
|
:- pred debug_int(int::in, io::di, io::uo) is det.
|
|
|
|
debug_int(Val, !IO) :-
|
|
io.write_int(Val, !IO),
|
|
io.write_char(' ', !IO).
|
|
|
|
:- pred debug_float(float::in, io::di, io::uo) is det.
|
|
|
|
debug_float(Val, !IO) :-
|
|
io.write_float(Val, !IO),
|
|
io.write_char(' ', !IO).
|
|
|
|
:- pred debug_sym_name(sym_name::in, io::di, io::uo) is det.
|
|
|
|
debug_sym_name(unqualified(Val), !IO) :-
|
|
io.write_string(Val, !IO),
|
|
io.write_char(' ', !IO).
|
|
debug_sym_name(qualified(Module, Val), !IO) :-
|
|
debug_sym_name(Module, !IO),
|
|
io.write_char(':', !IO),
|
|
io.write_string(Val, !IO),
|
|
io.write_char(' ', !IO).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- func this_file = string.
|
|
|
|
this_file = "bytecode.m".
|
|
|
|
%---------------------------------------------------------------------------%
|
|
:- end_module bytecode.
|
|
%---------------------------------------------------------------------------%
|