[m-rev.] for review: optimize bits_per_int operations
Zoltan Somogyi
zs at csse.unimelb.edu.au
Tue Dec 19 14:51:19 AEDT 2006
On 19-Dec-2006, Ralph Becket <rafe at csse.unimelb.edu.au> wrote:
> etc. I think you've attached the wrong diff for this log file.
Sorry. Here is the right diff.
Zoltan.
cvs diff: Diffing .
cvs diff: Diffing analysis
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/libatomic_ops-1.2
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/doc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/gcc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/hpc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/ibmc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/icc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/msftc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/sunc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/tests
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing boehm_gc/windows-untested
cvs diff: Diffing boehm_gc/windows-untested/vc60
cvs diff: Diffing boehm_gc/windows-untested/vc70
cvs diff: Diffing boehm_gc/windows-untested/vc71
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/add_pragma.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/add_pragma.m,v
retrieving revision 1.54
diff -u -b -r1.54 add_pragma.m
--- compiler/add_pragma.m 1 Dec 2006 15:03:49 -0000 1.54
+++ compiler/add_pragma.m 17 Dec 2006 14:30:31 -0000
@@ -2473,7 +2473,33 @@
PredId, ProcId, PVarSet, PVars, OrigArgTypes, PragmaImpl0,
Context, PredOrFunc, PredName, Arity, Markers, !ClausesInfo,
!ModuleInfo, !Specs) :-
+ module_info_pred_info(!.ModuleInfo, PredId, PredInfo),
+ ( pred_info_is_builtin(PredInfo) ->
+ % When bootstrapping a change that redefines a builtin as
+ % normal Mercury code, you may need to disable this action.
+ Msg = simple_msg(Context,
+ [always([words("Error: foreign_proc for builtin.")])]),
+ Spec = error_spec(severity_error, phase_parse_tree_to_hlds, [Msg]),
+ !:Specs = [Spec | !.Specs]
+ ;
+ clauses_info_do_add_pragma_foreign_proc(Origin, Purity, Attributes0,
+ PredId, ProcId, PVarSet, PVars, OrigArgTypes, PragmaImpl0,
+ Context, PredOrFunc, PredName, Arity, Markers, !ClausesInfo,
+ !ModuleInfo, !Specs)
+ ).
+:- pred clauses_info_do_add_pragma_foreign_proc(foreign_proc_origin::in,
+ purity::in, pragma_foreign_proc_attributes::in, pred_id::in, proc_id::in,
+ prog_varset::in, list(pragma_var)::in, list(mer_type)::in,
+ pragma_foreign_code_impl::in, prog_context::in, pred_or_func::in,
+ sym_name::in, arity::in, pred_markers::in,
+ clauses_info::in, clauses_info::out, module_info::in, module_info::out,
+ list(error_spec)::in, list(error_spec)::out) is det.
+
+clauses_info_do_add_pragma_foreign_proc(Origin, Purity, Attributes0,
+ PredId, ProcId, PVarSet, PVars, OrigArgTypes, PragmaImpl0,
+ Context, PredOrFunc, PredName, Arity, Markers, !ClausesInfo,
+ !ModuleInfo, !Specs) :-
!.ClausesInfo = clauses_info(VarSet0, ExplicitVarTypes, TVarNameMap,
InferredVarTypes, HeadVars, ClauseRep, RttiVarMaps,
_HasForeignClauses),
@@ -2553,9 +2579,9 @@
true
;
ForeignAttributePurity = get_purity(Attributes1),
- (
- ForeignAttributePurity \= Purity
- ->
+ ( ForeignAttributePurity = Purity ->
+ true
+ ;
purity_name(ForeignAttributePurity, ForeignAttributePurityStr),
purity_name(Purity, PurityStr),
Pieces = [words("Error: foreign clause for"),
@@ -2568,8 +2594,6 @@
Spec = error_spec(severity_error, phase_parse_tree_to_hlds,
[Msg]),
!:Specs = [Spec | !.Specs]
- ;
- true
)
),
% Put the purity in the goal_info in case this foreign code is inlined.
Index: compiler/const_prop.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/const_prop.m,v
retrieving revision 1.42
diff -u -b -r1.42 const_prop.m
--- compiler/const_prop.m 1 Dec 2006 15:03:52 -0000 1.42
+++ compiler/const_prop.m 17 Dec 2006 14:02:38 -0000
@@ -25,7 +25,6 @@
:- import_module hlds.hlds_goal.
:- import_module hlds.hlds_module.
-:- import_module hlds.hlds_pred.
:- import_module hlds.instmap.
:- import_module parse_tree.prog_data.
@@ -33,15 +32,15 @@
%---------------------------------------------------------------------------%
- % evaluate_call(PredId, ProcId, Args, VarTypes, Instmap, ModuleInfo,
- % GoalExpr, GoalInfo):
+ % evaluate_call(ModuleName, PredName, Args, VarTypes, Instmap, ModuleInfo,
+ % GoalExpr, !GoalInfo):
%
% This attempts to evaluate a call to the specified procedure with the
- % specified arguments. If the call can be statically evaluated,
- % evaluate_builtin will succeed, returning the new goal in GoalExpr
- % (and updating GoalInfo). Otherwise it fails.
+ % specified arguments. If the call can be statically evaluated, or
+ % simplified, evaluate_builtin will succeed, returning the new goal
+ % in GoalExpr (and updating GoalInfo). Otherwise it fails.
%
-:- pred evaluate_call(pred_id::in, proc_id::in, list(prog_var)::in,
+:- pred evaluate_call(string::in, string::in, int::in, list(prog_var)::in,
vartypes::in, instmap::in, module_info::in, hlds_goal_expr::out,
hlds_goal_info::in, hlds_goal_info::out) is semidet.
@@ -51,7 +50,10 @@
:- implementation.
:- import_module hlds.hlds_goal.
+:- import_module hlds.hlds_pred.
:- import_module hlds.instmap.
+:- import_module libs.globals.
+:- import_module libs.options.
:- import_module mdbcomp.prim_data.
:- import_module parse_tree.prog_data.
@@ -76,41 +78,45 @@
arg_inst :: mer_inst
).
-evaluate_call(PredId, ProcId, Args, VarTypes, InstMap, ModuleInfo, Goal,
- GoalInfo0, GoalInfo) :-
- ModuleName =predicate_module(ModuleInfo, PredId),
- PredName = predicate_name(ModuleInfo, PredId),
- proc_id_to_int(ProcId, ProcInt),
+evaluate_call(ModuleName, PredName, ProcIdInt, Args, VarTypes, InstMap,
+ ModuleInfo, GoalExpr, !GoalInfo) :-
+ module_info_get_globals(ModuleInfo, Globals),
+ globals.lookup_bool_option(Globals, cross_compiling, CrossCompiling),
LookupArgs = (func(Var) = arg_hlds_info(Var, Type, Inst) :-
instmap.lookup_var(InstMap, Var, Inst),
Type = VarTypes ^ det_elem(Var)
),
ArgHldsInfos = list.map(LookupArgs, Args),
- evaluate_call_2(ModuleName, PredName, ProcInt, ArgHldsInfos,
- Goal, GoalInfo0, GoalInfo).
+ evaluate_call_2(ModuleName, PredName, ProcIdInt, ArgHldsInfos,
+ CrossCompiling, GoalExpr, !GoalInfo).
-:- pred evaluate_call_2(module_name::in, string::in, int::in,
- list(arg_hlds_info)::in, hlds_goal_expr::out,
+:- pred evaluate_call_2(string::in, string::in, int::in,
+ list(arg_hlds_info)::in, bool::in, hlds_goal_expr::out,
hlds_goal_info::in, hlds_goal_info::out) is semidet.
-evaluate_call_2(Module, Pred, ModeNum, Args, Goal, !GoalInfo) :-
- % -- not yet:
- % Module = qualified(unqualified("std"), Mod),
- Module = unqualified(Mod),
- ( evaluate_det_call(Mod, Pred, ModeNum, Args, OutputArg, Cons) ->
- make_construction_goal(OutputArg, Cons, Goal, !GoalInfo)
- ; evaluate_test(Mod, Pred, ModeNum, Args, Succeeded) ->
- make_true_or_fail(Succeeded, Goal)
- ; evaluate_semidet_call(Mod, Pred, ModeNum, Args, Result) ->
+evaluate_call_2(ModuleName, Pred, ModeNum, Args, CrossCompiling, GoalExpr,
+ !GoalInfo) :-
+ (
+ evaluate_det_call(ModuleName, Pred, ModeNum, CrossCompiling,
+ Args, OutputArg, Cons)
+ ->
+ make_construction_goal(OutputArg, Cons, GoalExpr, !GoalInfo)
+ ;
+ evaluate_test(ModuleName, Pred, ModeNum, Args, Succeeded)
+ ->
+ make_true_or_fail(Succeeded, GoalExpr)
+ ;
+ evaluate_semidet_call(ModuleName, Pred, ModeNum, Args, Result)
+ ->
(
Result = yes(OutputArg - const(Cons)),
- make_construction_goal(OutputArg, Cons, Goal, !GoalInfo)
+ make_construction_goal(OutputArg, Cons, GoalExpr, !GoalInfo)
;
Result = yes(OutputArg - var(InputArg)),
- make_assignment_goal(OutputArg, InputArg, Goal, !GoalInfo)
+ make_assignment_goal(OutputArg, InputArg, GoalExpr, !GoalInfo)
;
Result = no,
- make_true_or_fail(no, Goal)
+ make_true_or_fail(no, GoalExpr)
)
;
fail
@@ -118,8 +124,8 @@
%---------------------------------------------------------------------------%
- % evaluate_det_call(ModuleName, ProcName, ModeNum, Args, OutputArg,
- % OutputArgVal):
+ % evaluate_det_call(ModuleName, ProcName, ModeNum, CrossCompiling,
+ % Args, OutputArg, OutputArgVal):
%
% This attempts to evaluate a call to
% ModuleName.ProcName(Args)
@@ -130,34 +136,67 @@
% Args is output, and with OutputArgVal being the computed value of
% OutputArg. Otherwise it fails.
%
-:- pred evaluate_det_call(string::in, string::in, int::in,
+:- pred evaluate_det_call(string::in, string::in, int::in, bool::in,
list(arg_hlds_info)::in, arg_hlds_info::out, cons_id::out) is semidet.
%
+% Constant functions
+%
+
+evaluate_det_call("int", "bits_per_int", 0, CrossCompiling, [X],
+ X, int_const(XVal)) :-
+ CrossCompiling = no,
+ XVal = int.bits_per_int.
+
+%
% Unary operators
%
% Integer arithmetic
-evaluate_det_call("int", "+", 0, [X, Y], Y, int_const(YVal)) :-
+evaluate_det_call("int", "+", 0, _, [X, Y], Y, int_const(YVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = XVal.
-evaluate_det_call("int", "-", 0, [X, Y], Y, int_const(YVal)) :-
+evaluate_det_call("int", "-", 0, _, [X, Y], Y, int_const(YVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = -XVal.
-evaluate_det_call("int", "\\", 0, [X, Y], Y, int_const(YVal)) :-
+evaluate_det_call("int", "\\", 0, _, [X, Y], Y, int_const(YVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = \ XVal.
+evaluate_det_call("int", "floor_to_multiple_of_bits_per_int", 0,
+ CrossCompiling, [X, Y], Y, int_const(YVal)) :-
+ CrossCompiling = no,
+ X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
+ YVal = int.floor_to_multiple_of_bits_per_int(XVal).
+
+evaluate_det_call("int", "quot_bits_per_int", 0,
+ CrossCompiling, [X, Y], Y, int_const(YVal)) :-
+ CrossCompiling = no,
+ X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
+ YVal = int.quot_bits_per_int(XVal).
+
+evaluate_det_call("int", "times_bits_per_int", 0,
+ CrossCompiling, [X, Y], Y, int_const(YVal)) :-
+ CrossCompiling = no,
+ X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
+ YVal = int.times_bits_per_int(XVal).
+
+evaluate_det_call("int", "rem_bits_per_int", 0,
+ CrossCompiling, [X, Y], Y, int_const(YVal)) :-
+ CrossCompiling = no,
+ X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
+ YVal = int.rem_bits_per_int(XVal).
+
% Floating point arithmetic
-evaluate_det_call("float", "+", 0, [X, Y], Y, int_const(YVal)) :-
+evaluate_det_call("float", "+", 0, _, [X, Y], Y, int_const(YVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = XVal.
-evaluate_det_call("float", "-", 0, [X, Y], Y, int_const(YVal)) :-
+evaluate_det_call("float", "-", 0, _, [X, Y], Y, int_const(YVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = -XVal.
@@ -167,144 +206,145 @@
% Integer arithmetic
-evaluate_det_call("int", "+", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "+", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal + YVal.
-evaluate_det_call("int", "+", 1, [X, Y, Z], X, int_const(XVal)) :-
+evaluate_det_call("int", "+", 1, _, [X, Y, Z], X, int_const(XVal)) :-
Z ^ arg_inst = bound(_ZUniq, [bound_functor(int_const(ZVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
XVal = ZVal - YVal.
-evaluate_det_call("int", "+", 2, [X, Y, Z], Y, int_const(YVal)) :-
+evaluate_det_call("int", "+", 2, _, [X, Y, Z], Y, int_const(YVal)) :-
Z ^ arg_inst = bound(_ZUniq, [bound_functor(int_const(ZVal), [])]),
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = ZVal - XVal.
-evaluate_det_call("int", "-", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "-", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal - YVal.
-evaluate_det_call("int", "-", 1, [X, Y, Z], X, int_const(XVal)) :-
+evaluate_det_call("int", "-", 1, _, [X, Y, Z], X, int_const(XVal)) :-
Z ^ arg_inst = bound(_ZUniq, [bound_functor(int_const(ZVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
XVal = YVal + ZVal.
-evaluate_det_call("int", "-", 2, [X, Y, Z], Y, int_const(YVal)) :-
+evaluate_det_call("int", "-", 2, _, [X, Y, Z], Y, int_const(YVal)) :-
Z ^ arg_inst = bound(_ZUniq, [bound_functor(int_const(ZVal), [])]),
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
YVal = XVal - ZVal.
-evaluate_det_call("int", "*", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "*", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal * YVal.
-evaluate_det_call("int", "//", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "//", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
YVal \= 0,
ZVal = XVal // YVal.
-evaluate_det_call("int", "plus", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "plus", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal + YVal.
-evaluate_det_call("int", "minus", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "minus", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal - YVal.
-evaluate_det_call("int", "times", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "times", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal * YVal.
-evaluate_det_call("int", "unchecked_quotient", 0, [X, Y, Z], Z,
+evaluate_det_call("int", "unchecked_quotient", 0, _, [X, Y, Z], Z,
int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
YVal \= 0,
ZVal = unchecked_quotient(XVal, YVal).
-evaluate_det_call("int", "mod", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "mod", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
YVal \= 0,
ZVal = XVal mod YVal.
-evaluate_det_call("int", "rem", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "rem", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
YVal \= 0,
ZVal = XVal rem YVal.
-evaluate_det_call("int", "unchecked_rem", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "unchecked_rem", 0, _, [X, Y, Z], Z,
+ int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
YVal \= 0,
ZVal = unchecked_rem(XVal, YVal).
evaluate_det_call("int", "unchecked_left_shift",
- 0, [X, Y, Z], Z, int_const(ZVal)) :-
+ 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = unchecked_left_shift(XVal, YVal).
-evaluate_det_call("int", "<<", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "<<", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal << YVal.
evaluate_det_call("int", "unchecked_right_shift",
- 0, [X, Y, Z], Z, int_const(ZVal)) :-
+ 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = unchecked_right_shift(XVal, YVal).
-evaluate_det_call("int", ">>", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", ">>", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal >> YVal.
-evaluate_det_call("int", "/\\", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "/\\", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal /\ YVal.
-evaluate_det_call("int", "\\/", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "\\/", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal \/ YVal.
-evaluate_det_call("int", "xor", 0, [X, Y, Z], Z, int_const(ZVal)) :-
+evaluate_det_call("int", "xor", 0, _, [X, Y, Z], Z, int_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(int_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(int_const(YVal), [])]),
ZVal = XVal `xor` YVal.
% float arithmetic
-evaluate_det_call("float", "+", 0, [X, Y, Z], Z, float_const(ZVal)) :-
+evaluate_det_call("float", "+", 0, _, [X, Y, Z], Z, float_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(float_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(float_const(YVal), [])]),
ZVal = XVal + YVal.
-evaluate_det_call("float", "-", 0, [X, Y, Z], Z, float_const(ZVal)) :-
+evaluate_det_call("float", "-", 0, _, [X, Y, Z], Z, float_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(float_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(float_const(YVal), [])]),
ZVal = XVal - YVal.
-evaluate_det_call("float", "*", 0, [X, Y, Z], Z, float_const(ZVal)) :-
+evaluate_det_call("float", "*", 0, _, [X, Y, Z], Z, float_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(float_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(float_const(YVal), [])]),
ZVal = XVal * YVal.
-evaluate_det_call("float", "/", 0, [X, Y, Z], Z, float_const(ZVal)) :-
+evaluate_det_call("float", "/", 0, _, [X, Y, Z], Z, float_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(float_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(float_const(YVal), [])]),
YVal \= 0.0,
ZVal = XVal / YVal.
-evaluate_det_call("float", "unchecked_quotient", 0, [X, Y, Z], Z,
+evaluate_det_call("float", "unchecked_quotient", 0, _, [X, Y, Z], Z,
float_const(ZVal)) :-
X ^ arg_inst = bound(_XUniq, [bound_functor(float_const(XVal), [])]),
Y ^ arg_inst = bound(_YUniq, [bound_functor(float_const(YVal), [])]),
@@ -313,7 +353,7 @@
% string operations
-evaluate_det_call("string", Name, _, [X, Y, Z], Z, string_const(ZVal)) :-
+evaluate_det_call("string", Name, _, _, [X, Y, Z], Z, string_const(ZVal)) :-
( Name = "++"
; Name = "append"
),
@@ -328,10 +368,10 @@
%---------------------------------------------------------------------------%
- % evaluate_test(ModuleName, ProcName, ModeNum, ArgList, Result):
+ % evaluate_test(ModuleName, ProcName, ModeNum, Args, Result):
%
% This attempts to evaluate a call to
- % ModuleName.ProcName(ArgList)
+ % ModuleName.ProcName(Args)
% whose mode is specified by ModeNum.
%
% If the call is a semidet call with no outputs that can be statically
Index: compiler/hlds_module.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/hlds_module.m,v
retrieving revision 1.147
diff -u -b -r1.147 hlds_module.m
--- compiler/hlds_module.m 5 Dec 2006 03:50:50 -0000 1.147
+++ compiler/hlds_module.m 17 Dec 2006 08:55:16 -0000
@@ -1258,25 +1258,21 @@
%-----------------------------------------------------------------------------%
predicate_id(ModuleInfo, PredId, ModuleName, PredName, Arity) :-
- module_info_preds(ModuleInfo, Preds),
- map.lookup(Preds, PredId, PredInfo),
+ module_info_pred_info(ModuleInfo, PredId, PredInfo),
ModuleName = pred_info_module(PredInfo),
PredName = pred_info_name(PredInfo),
Arity = pred_info_orig_arity(PredInfo).
predicate_module(ModuleInfo, PredId) = ModuleName :-
- module_info_preds(ModuleInfo, Preds),
- map.lookup(Preds, PredId, PredInfo),
+ module_info_pred_info(ModuleInfo, PredId, PredInfo),
ModuleName = pred_info_module(PredInfo).
predicate_name(ModuleInfo, PredId) = PredName :-
- module_info_preds(ModuleInfo, Preds),
- map.lookup(Preds, PredId, PredInfo),
+ module_info_pred_info(ModuleInfo, PredId, PredInfo),
PredName = pred_info_name(PredInfo).
predicate_arity(ModuleInfo, PredId) = Arity :-
- module_info_preds(ModuleInfo, Preds),
- map.lookup(Preds, PredId, PredInfo),
+ module_info_pred_info(ModuleInfo, PredId, PredInfo),
Arity = pred_info_orig_arity(PredInfo).
%-----------------------------------------------------------------------------%
Index: compiler/options.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/options.m,v
retrieving revision 1.541
diff -u -b -r1.541 options.m
--- compiler/options.m 5 Dec 2006 03:50:56 -0000 1.541
+++ compiler/options.m 17 Dec 2006 08:16:49 -0000
@@ -785,6 +785,7 @@
; help
; version
; fullarch
+ ; cross_compiling
; local_module_id
; compiler_sufficiently_recent
% This option is used to test that the compiler is sufficiently
@@ -1534,6 +1535,7 @@
help - bool(no),
version - bool(no),
fullarch - string(""),
+ cross_compiling - bool(no),
local_module_id - accumulating([]),
compiler_sufficiently_recent - bool(no),
experiment - string("")
@@ -2302,6 +2304,7 @@
long_option("version", version).
long_option("filenames-from-stdin", filenames_from_stdin).
long_option("fullarch", fullarch).
+long_option("cross-compiling", cross_compiling).
long_option("local-module-id", local_module_id).
long_option("bug-intermod-2002-06-13", compiler_sufficiently_recent).
long_option("bug-intermod-2006-09-28", compiler_sufficiently_recent).
@@ -4717,11 +4720,15 @@
"\tcompile several modules without the overhead of process",
"\tcreation for each one.)",
"--version",
- "\tDisplay the compiler version."
+ "\tDisplay the compiler version.",
% The `--fullarch' option is reserved for
% use by the `Mercury.config' file.
+ "--cross-compiling",
+ "\tDo not assume that the code being generated is for the",
+ "\tplatform the compiler is running on."
+
% The `--local-module-id' option is used by `mmc --make'.
]).
Index: compiler/simplify.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/simplify.m,v
retrieving revision 1.199
diff -u -b -r1.199 simplify.m
--- compiler/simplify.m 5 Dec 2006 03:50:58 -0000 1.199
+++ compiler/simplify.m 17 Dec 2006 15:12:01 -0000
@@ -1684,11 +1684,11 @@
hlds_goal_info::in, hlds_goal_info::out,
simplify_info::in, simplify_info::out) is det.
-call_goal(PredId, ProcId, Args, IsBuiltin, Goal0, Goal, GoalInfo0, GoalInfo,
- !Info) :-
- simplify_info_get_module_info(!.Info, ModuleInfo),
- module_info_pred_proc_info(ModuleInfo, PredId, ProcId, PredInfo, ProcInfo),
- goal_info_get_context(GoalInfo0, GoalContext),
+call_goal(PredId, ProcId, Args, IsBuiltin, !GoalExpr, !GoalInfo, !Info) :-
+ simplify_info_get_module_info(!.Info, ModuleInfo0),
+ module_info_pred_proc_info(ModuleInfo0, PredId, ProcId,
+ PredInfo, ProcInfo),
+ goal_info_get_context(!.GoalInfo, GoalContext),
% Check for calls to predicates with `pragma obsolete' declarations.
(
simplify_do_warn_obsolete(!.Info),
@@ -1706,13 +1706,13 @@
% Don't warn about calls from predicates that also have a
% `pragma obsolete' declaration. Doing so just results in
% spurious warnings.
- module_info_pred_info(ModuleInfo, ThisPredId, ThisPredInfo),
+ module_info_pred_info(ModuleInfo0, ThisPredId, ThisPredInfo),
pred_info_get_markers(ThisPredInfo, ThisPredMarkers),
not check_marker(ThisPredMarkers, marker_obsolete)
->
% XXX warn_obsolete isn't really a simple code warning.
% We should add a separate warning type for this.
- ObsoletePredPieces = describe_one_pred_name(ModuleInfo,
+ ObsoletePredPieces = describe_one_pred_name(ModuleInfo0,
should_module_qualify, PredId),
ObsoletePieces = [words("Warning: call to obsolete")] ++
ObsoletePredPieces ++ [suffix("."), nl],
@@ -1817,46 +1817,139 @@
% Check for duplicate calls to the same procedure.
(
simplify_do_opt_duplicate_calls(!.Info),
- goal_info_get_purity(GoalInfo0, purity_pure)
+ goal_info_get_purity(!.GoalInfo, purity_pure)
->
- common_optimise_call(PredId, ProcId, Args, GoalInfo0, Goal0, Goal1,
+ common_optimise_call(PredId, ProcId, Args, !.GoalInfo, !GoalExpr,
!Info)
;
simplify_do_warn_duplicate_calls(!.Info),
- goal_info_get_purity(GoalInfo0, purity_pure)
+ goal_info_get_purity(!.GoalInfo, purity_pure)
->
% We need to do the pass, for the warnings, but we ignore
% the optimized goal and instead use the original one.
- common_optimise_call(PredId, ProcId, Args, GoalInfo0, Goal0, _Goal1,
- !Info),
- Goal1 = Goal0
+ common_optimise_call(PredId, ProcId, Args, !.GoalInfo,
+ !.GoalExpr, _NewGoalExpr, !Info)
;
- Goal1 = Goal0
+ true
),
% Try to evaluate the call at compile-time.
- ( simplify_do_const_prop(!.Info) ->
- simplify_info_get_instmap(!.Info, Instmap0),
+ (
simplify_info_get_module_info(!.Info, ModuleInfo2),
+ simplify_do_const_prop(!.Info),
+ !.GoalExpr = plain_call(CallPredId, CallProcId, CallArgs, _, _, _),
+ module_info_pred_info(ModuleInfo2, CallPredId, CallPredInfo),
+ CallModuleSymName = pred_info_module(CallPredInfo),
+ is_std_lib_module_name(CallModuleSymName, CallModuleName)
+ ->
+ simplify_info_get_instmap(!.Info, Instmap0),
simplify_info_get_var_types(!.Info, VarTypes),
+
+ CallPredName = pred_info_name(CallPredInfo),
+ proc_id_to_int(CallProcId, CallModeNum),
(
- Goal1 = plain_call(_, _, _, _, _, _),
- const_prop.evaluate_call(PredId, ProcId, Args, VarTypes,
- Instmap0, ModuleInfo2, Goal2, GoalInfo0, GoalInfo2)
- ->
- Goal = Goal2,
- GoalInfo = GoalInfo2,
- simplify_info_set_module_info(ModuleInfo2, !Info),
+ const_prop.evaluate_call(CallModuleName, CallPredName, CallModeNum,
+ CallArgs, VarTypes, Instmap0, ModuleInfo2, GoalExprPrime,
+ !GoalInfo)
+ ->
+ !:GoalExpr = GoalExprPrime,
simplify_info_set_requantify(!Info)
;
- Goal = Goal1,
- GoalInfo = GoalInfo0
+ module_info_get_globals(ModuleInfo2, Globals),
+ globals.lookup_bool_option(Globals, cross_compiling,
+ CrossCompiling),
+ simplify_library_call(CallModuleName, CallPredName, CallModeNum,
+ CrossCompiling, CallArgs, GoalExprPrime, !GoalInfo, !Info)
+ ->
+ !:GoalExpr = GoalExprPrime,
+ simplify_info_set_requantify(!Info)
+ ;
+ true
)
;
- Goal = Goal1,
- GoalInfo = GoalInfo0
+ true
).
+ % simplify_det_call(ModuleName, ProcName, ModeNum, CrossCompiling,
+ % Args, GoalExpr, !GoalInfo, !Info):
+ %
+ % This attempts to simplify a call to
+ % ModuleName.ProcName(ArgList)
+ % whose mode is specified by ModeNum.
+ %
+:- pred simplify_library_call(string::in, string::in, int::in, bool::in,
+ list(prog_var)::in, hlds_goal_expr::out,
+ hlds_goal_info::in, hlds_goal_info::out,
+ simplify_info::in, simplify_info::out) is semidet.
+
+simplify_library_call("int", PredName, _ModeNum, CrossCompiling, Args,
+ GoalExpr, !GoalInfo, !Info) :-
+ (
+ PredName = "quot_bits_per_int",
+ Args = [X, Y],
+ CrossCompiling = no,
+ % There is no point in checking whether bits_per_int is 0; it isn't.
+ Op = "unchecked_quotient",
+ IsBuiltin = inline_builtin
+ ;
+ PredName = "times_bits_per_int",
+ Args = [X, Y],
+ CrossCompiling = no,
+ Op = "*",
+ IsBuiltin = inline_builtin
+ ;
+ PredName = "rem_bits_per_int",
+ Args = [X, Y],
+ CrossCompiling = no,
+ % There is no point in checking whether bits_per_int is 0; it isn't.
+ Op = "unchecked_rem",
+ IsBuiltin = inline_builtin
+ ),
+
+ simplify_info_get_varset(!.Info, VarSet0),
+ simplify_info_get_var_types(!.Info, VarTypes0),
+ varset.new_var(VarSet0, ConstVar, VarSet),
+ map.det_insert(VarTypes0, ConstVar, int_type, VarTypes),
+ simplify_info_set_varset(VarSet, !Info),
+ simplify_info_set_var_types(VarTypes, !Info),
+
+ ConstConsId = int_const(int.bits_per_int),
+ ConstUnification = construct(ConstVar, ConstConsId, [], [],
+ construct_dynamically, cell_is_shared, no_construct_sub_info),
+ ConstRHS = rhs_functor(ConstConsId, no, []),
+ % The context shouldn't matter.
+ ConstUnifyContext = unify_context(umc_explicit, []),
+ ConstMode = (free -> ground_inst) - (ground_inst -> ground_inst),
+ ConstGoalExpr = unify(ConstVar, ConstRHS, ConstMode, ConstUnification,
+ ConstUnifyContext),
+ ConstNonLocals = set.make_singleton_set(ConstVar),
+ instmap_delta_from_assoc_list([ConstVar - ground_inst], InstMapDelta),
+ goal_info_init(ConstNonLocals, InstMapDelta,
+ detism_det, purity_pure, ConstGoalInfo),
+ ConstGoal = ConstGoalExpr - ConstGoalInfo,
+
+ IntModuleSymName = mercury_std_lib_module_name("int"),
+ OpSymName = qualified(IntModuleSymName, Op),
+ simplify_info_get_module_info(!.Info, ModuleInfo),
+ module_info_get_predicate_table(ModuleInfo, PredTable),
+ predicate_table_search_func_sym_arity(PredTable, is_fully_qualified,
+ OpSymName, 2, OpPredIds),
+ OpPredIds = [OpPredId],
+ OpProcIdInt = 0,
+ proc_id_to_int(OpProcId, OpProcIdInt),
+ OpArgs = [X, ConstVar, Y],
+ MaybeUnifyContext = no,
+ OpGoalExpr = plain_call(OpPredId, OpProcId, OpArgs, IsBuiltin,
+ MaybeUnifyContext, OpSymName),
+
+ OpGoalInfo0 = !.GoalInfo,
+ goal_info_get_nonlocals(OpGoalInfo0, OpNonLocals0),
+ set.insert(OpNonLocals0, ConstVar, OpNonLocals),
+ goal_info_set_nonlocals(OpNonLocals, OpGoalInfo0, OpGoalInfo),
+ OpGoal = OpGoalExpr - OpGoalInfo,
+
+ GoalExpr = conj(plain_conj, [ConstGoal, OpGoal]).
+
%-----------------------------------------------------------------------------%
:- pred process_compl_unify(prog_var::in, prog_var::in, uni_mode::in,
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing debian/patches
cvs diff: Diffing deep_profiler
cvs diff: Diffing deep_profiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/base64
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/error
cvs diff: Diffing extras/fixed
cvs diff: Diffing extras/gator
cvs diff: Diffing extras/gator/generations
cvs diff: Diffing extras/gator/generations/1
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/easyx
cvs diff: Diffing extras/graphics/easyx/samples
cvs diff: Diffing extras/graphics/mercury_glut
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/gears
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/lex/tests
cvs diff: Diffing extras/log4m
cvs diff: Diffing extras/logged_output
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
cvs diff: Diffing extras/moose/tests
cvs diff: Diffing extras/mopenssl
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/net
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/quickcheck
cvs diff: Diffing extras/quickcheck/tutes
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/solver_types
cvs diff: Diffing extras/solver_types/library
cvs diff: Diffing extras/stream
cvs diff: Diffing extras/stream/tests
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/windows_installer_generator
cvs diff: Diffing extras/windows_installer_generator/sample
cvs diff: Diffing extras/windows_installer_generator/sample/images
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing extras/xml_stylesheets
cvs diff: Diffing java
cvs diff: Diffing java/runtime
cvs diff: Diffing library
Index: library/Mercury.options
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/library/Mercury.options,v
retrieving revision 1.17
diff -u -b -r1.17 Mercury.options
--- library/Mercury.options 1 Dec 2006 15:04:37 -0000 1.17
+++ library/Mercury.options 17 Dec 2006 14:28:44 -0000
@@ -16,6 +16,8 @@
MCFLAGS-set += $(TYPE_SPEC_FLAGS)
MCFLAGS-set_ordlist += $(TYPE_SPEC_FLAGS)
+MCFLAGS-sparse_bitset += --optimize-constant-propagation
+
# Bug workarounds.
MCFLAGS-std_util += --no-halt-at-warn
MCFLAGS-dir += --no-halt-at-warn
cvs diff: Diffing mdbcomp
Index: mdbcomp/prim_data.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/mdbcomp/prim_data.m,v
retrieving revision 1.15
diff -u -b -r1.15 prim_data.m
--- mdbcomp/prim_data.m 24 Nov 2006 03:48:16 -0000 1.15
+++ mdbcomp/prim_data.m 17 Dec 2006 10:43:11 -0000
@@ -214,6 +214,8 @@
%
:- func mercury_std_lib_module_name(string) = sym_name.
+:- pred is_std_lib_module_name(sym_name::in, string::out) is semidet.
+
% Succeeds iff the specified module is one of the builtin modules listed
% above which may be automatically imported.
%
@@ -228,6 +230,7 @@
:- implementation.
:- import_module int.
+:- import_module library.
:- import_module list.
:- import_module string.
@@ -296,6 +299,10 @@
mercury_par_builtin_module = unqualified("par_builtin").
mercury_std_lib_module_name(Name) = unqualified(Name).
+is_std_lib_module_name(SymName, Name) :-
+ SymName = unqualified(Name),
+ mercury_std_library_module(Name).
+
any_mercury_builtin_module(Module) :-
( Module = mercury_public_builtin_module
; Module = mercury_private_builtin_module
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 slice
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/string_format
cvs diff: Diffing tests/general/structure_reuse
cvs diff: Diffing tests/grade_subdirs
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/mmc_make
cvs diff: Diffing tests/mmc_make/lib
cvs diff: Diffing tests/par_conj
cvs diff: Diffing tests/recompilation
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/trailing
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
cvs diff: Diffing vim
cvs diff: Diffing vim/after
cvs diff: Diffing vim/ftplugin
cvs diff: Diffing vim/syntax
--------------------------------------------------------------------------
mercury-reviews mailing list
Post messages to: mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions: mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------
More information about the reviews
mailing list