[m-rev.] for review: deleting code_exprn

Zoltan Somogyi zs at cs.mu.OZ.AU
Mon Oct 14 19:00:07 AEST 2002


Estimated hours taken: 2

Delete the old, lazy LLDS code generator, since we won't be maintaining it
anymore. Its deletion speeds up the compiler by 0.2% when using the LLDS
back end.

compiler/code_exprn.m:
	Replace the module with a notice saying this file isn't used anymore.

compiler/code_info.m:
	Delete lots of code that switches between code_exprn.m and var_locn.m.

	Simplify the data structures accordingly.

compiler/exprn_aux.m:
	Since var_locn requires static ground terms and it is now the only
	LLDS code generator, assume static ground terms are always set.

compiler/handle_options.m:
	Do not set the options required by var_locn (static ground terms and
	follow vars) conditionally; all the users of these options have been
	updated to implicitly use the required values.

compiler/hlds_goal.m:
	Update a comment.

compiler/ll_backend.m:
	Delete code_exprn from the list submodules of this module.

compiler/llds_out.m:
compiler/lookup_switch.m:
	Behave as if static ground terms is always set.

compiler/store_alloc.m:
	Behave as if follow_vars is always set.

	Delete a now unused field from a structure.

compiler/options.m:
	Delete the --lazy-code option that used to select code_exprn over
	var_locn.

	Delete the follow_vars option, since it is now always assumed to be on.

	Keep the static ground terms option, but document it as being used
	only by the MLDS backends.

compiler/var_locn.m:
	Behave as if static ground terms is always set.

	Factor out some common code.

doc/user_guide.texi:
	Delete the documentation of --follow-vars, and move the documentation
	of --static-ground-terms to the MLDS section. --lazy-code was already
	undocumented.

Zoltan.

cvs diff: Diffing .
cvs diff: Diffing bench
cvs diff: Diffing bench/progs
cvs diff: Diffing bench/progs/compress
cvs diff: Diffing bench/progs/icfp2000
cvs diff: Diffing bench/progs/icfp2001
cvs diff: Diffing bench/progs/nuc
cvs diff: Diffing bench/progs/ray
cvs diff: Diffing bench/progs/tree234
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/doc
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/code_exprn.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/code_exprn.m,v
retrieving revision 1.65
diff -u -b -r1.65 code_exprn.m
--- compiler/code_exprn.m	28 Mar 2002 03:42:43 -0000	1.65
+++ compiler/code_exprn.m	14 Oct 2002 06:59:20 -0000
@@ -4,1927 +4,4 @@
 % Public License - see the file COPYING in the Mercury distribution.
 %-----------------------------------------------------------------------------%
 %
-<old contents of file omitted>
+% This file is no longer needed.
Index: compiler/code_info.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/code_info.m,v
retrieving revision 1.271
diff -u -b -r1.271 code_info.m
--- compiler/code_info.m	30 Aug 2002 07:22:33 -0000	1.271
+++ compiler/code_info.m	14 Oct 2002 08:18:54 -0000
@@ -19,7 +19,7 @@
 %	- handling failure continuations
 %	- handling liveness issues
 %	- saving and restoring heap pointers, trail tickets etc
-%	- interfacing to code_exprn
+%	- interfacing to var_locn
 %	- managing the info required by garbage collection and value numbering
 %	- managing stack slots
 %
@@ -44,7 +44,7 @@
 :- import_module parse_tree__prog_out.
 :- import_module check_hlds__type_util, check_hlds__mode_util.
 :- import_module ll_backend__arg_info, ll_backend__code_util.
-:- import_module ll_backend__code_exprn, ll_backend__exprn_aux.
+:- import_module ll_backend__exprn_aux.
 :- import_module ll_backend__var_locn.
 :- import_module ll_backend__llds_out.
 :- import_module libs__trace_params.
@@ -190,10 +190,10 @@
 :- pred code_info__set_zombies(set(prog_var)::in,
 	code_info::in, code_info::out) is det.
 
-:- pred code_info__get_var_locns_info(var_locns_info::out,
+:- pred code_info__get_var_locn_info(var_locn_info::out,
 	code_info::in, code_info::out) is det.
 
-:- pred code_info__set_var_locns_info(var_locns_info::in,
+:- pred code_info__set_var_locn_info(var_locn_info::in,
 	code_info::in, code_info::out) is det.
 
 :- pred code_info__get_temps_in_use(set(lval)::out,
@@ -307,7 +307,7 @@
 				% Zombie variables; variables that are not
 				% forward live but which are protected by
 				% an enclosing resume point.
-		var_locns_info :: var_locns_info,
+		var_locn_info :: var_locn_info,
 				% A map storing the information about
 				% the status of each known variable.
 				% (Known vars = forward live vars + zombies)
@@ -369,10 +369,6 @@
 				% more temporary nondet frames.
 	).
 
-:- type var_locns_info
-	--->	exprn_info(exprn_info)
-	;	var_locn_info(var_locn_info).
-
 %---------------------------------------------------------------------------%
 
 code_info__init(SaveSuccip, Globals, PredId, ProcId, PredInfo, ProcInfo,
@@ -384,7 +380,6 @@
 	arg_info__build_input_arg_list(ProcInfo, ArgList),
 	proc_info_varset(ProcInfo, VarSet),
 	proc_info_stack_slots(ProcInfo, StackSlots),
-	globals__lookup_bool_option(Globals, lazy_code, LazyCode),
 	globals__get_options(Globals, Options),
 	globals__get_trace_level(Globals, TraceLevel),
 	( eff_trace_level_is_none(PredInfo, ProcInfo, TraceLevel) = no ->
@@ -395,19 +390,8 @@
 		MaybeFailVars = no,
 		EffLiveness = Liveness
 	),
-	(
-		LazyCode = yes,
-		ArgRvalList = assoc_list__map_values(
-			exprn_aux__var_lval_to_rval, ArgList),
-		code_exprn__init_state(ArgRvalList, VarSet, StackSlots,
-			FollowVars, Options, ExprnInfo),
-		VarLocnsInfo = exprn_info(ExprnInfo)
-	;
-		LazyCode = no,
 		var_locn__init_state(ArgList, EffLiveness, VarSet,
 			StackSlots, FollowVars, Options, VarLocnInfo),
-		VarLocnsInfo = var_locn_info(VarLocnInfo)
-	),
 	stack__init(ResumePoints),
 	globals__lookup_bool_option(Globals, allow_hijacks, AllowHijack),
 	(
@@ -446,7 +430,7 @@
 			Liveness,
 			InstMap,
 			Zombies,
-			VarLocnsInfo,
+			VarLocnInfo,
 			TempsInUse,
 			DummyFailInfo	% code_info__init_fail_info
 					% will override this dummy value
@@ -500,7 +484,7 @@
 	CI, CI).
 code_info__get_instmap(CI^code_info_loc_dep^instmap, CI, CI).
 code_info__get_zombies(CI^code_info_loc_dep^zombies, CI, CI).
-code_info__get_var_locns_info(CI^code_info_loc_dep^var_locns_info, CI, CI).
+code_info__get_var_locn_info(CI^code_info_loc_dep^var_locn_info, CI, CI).
 code_info__get_temps_in_use(CI^code_info_loc_dep^temps_in_use, CI, CI).
 code_info__get_fail_info(CI^code_info_loc_dep^fail_info, CI, CI).
 code_info__get_label_counter(CI^code_info_persistent^label_num_src, CI, CI).
@@ -527,8 +511,8 @@
 	CI^code_info_loc_dep^forward_live_vars := LV).
 code_info__set_instmap(IM, CI, CI^code_info_loc_dep^instmap := IM).
 code_info__set_zombies(Zs, CI, CI^code_info_loc_dep^zombies := Zs).
-code_info__set_var_locns_info(EI, CI,
-	CI^code_info_loc_dep^var_locns_info := EI).
+code_info__set_var_locn_info(EI, CI,
+	CI^code_info_loc_dep^var_locn_info := EI).
 code_info__set_temps_in_use(TI, CI, CI^code_info_loc_dep^temps_in_use := TI).
 code_info__set_fail_info(FI, CI, CI^code_info_loc_dep^fail_info := FI).
 code_info__set_label_counter(LC, CI,
@@ -692,51 +676,21 @@
 :- mode code_info__add_resume_layout_for_label(in, in, in, out) is det.
 
 code_info__get_stack_slots(StackSlots, CI, CI) :-
-	code_info__get_var_locns_info(VarInfo, CI, _),
-	(
-		VarInfo = exprn_info(ExprnInfo),
-		code_exprn__get_stack_slots(StackSlots, ExprnInfo, _)
-	;
-		VarInfo = var_locn_info(VarLocnInfo),
-		var_locn__get_stack_slots(StackSlots, VarLocnInfo, _)
-	).
+	code_info__get_var_locn_info(VarLocnInfo, CI, _),
+	var_locn__get_stack_slots(StackSlots, VarLocnInfo, _).
 
 code_info__get_follow_var_map(FollowVarMap, CI, CI) :-
-	code_info__get_var_locns_info(VarInfo, CI, _),
-	(
-		VarInfo = exprn_info(ExprnInfo),
-		code_exprn__get_follow_vars(FollowVars, ExprnInfo, _),
-		FollowVars = follow_vars(FollowVarMap, _)
-	;
-		VarInfo = var_locn_info(VarLocnInfo),
-		var_locn__get_follow_var_map(FollowVarMap, VarLocnInfo, _)
-	).
+	code_info__get_var_locn_info(VarLocnInfo, CI, _),
+	var_locn__get_follow_var_map(FollowVarMap, VarLocnInfo, _).
 
 code_info__get_next_non_reserved(NextNonReserved, CI, CI) :-
-	code_info__get_var_locns_info(VarInfo, CI, _),
-	(
-		VarInfo = exprn_info(ExprnInfo),
-		code_exprn__get_follow_vars(FollowVars, ExprnInfo, _),
-		FollowVars = follow_vars(_, NextNonReserved)
-	;
-		VarInfo = var_locn_info(VarLocnInfo),
-		var_locn__get_next_non_reserved(NextNonReserved, VarLocnInfo,
-			_)
-	).
+	code_info__get_var_locn_info(VarLocnInfo, CI, _),
+	var_locn__get_next_non_reserved(NextNonReserved, VarLocnInfo, _).
 
 code_info__set_follow_vars(FollowVars, CI0, CI) :-
-	code_info__get_var_locns_info(VarInfo0, CI0, _),
-	(
-		VarInfo0 = exprn_info(ExprnInfo0),
-		code_exprn__set_follow_vars(FollowVars, ExprnInfo0, ExprnInfo),
-		VarInfo = exprn_info(ExprnInfo)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__set_follow_vars(FollowVars,
-			VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	),
-	code_info__set_var_locns_info(VarInfo, CI0, CI).
+	code_info__get_var_locn_info(VarLocnInfo0, CI0, _),
+	var_locn__set_follow_vars(FollowVars, VarLocnInfo0, VarLocnInfo),
+	code_info__set_var_locn_info(VarLocnInfo, CI0, CI).
 
 %-----------------------------------------------------------------------------%
 
@@ -1025,24 +979,18 @@
 	code_info__set_fail_info(NewFailInfo).
 
 code_info__generate_branch_end(StoreMap, MaybeEnd0, MaybeEnd, Code) -->
-	{ map__to_assoc_list(StoreMap, VarLocs) },
-	code_info__get_var_locns_info(VarInfo),
-	(
-		{ VarInfo = exprn_info(_) }
-	;
-			% The eager code generator generates better code
+		% The code generator generates better code
 			% if it knows in advance where each variable should
 			% go. We don't need to reset the follow_vars
 			% afterwards, since every goal following a branched
 			% control structure must in any case be annotated with
 			% its own follow_var set.
-		{ VarInfo = var_locn_info(_) },
+	{ map__to_assoc_list(StoreMap, VarLocs) },
 		{ map__from_assoc_list(VarLocs, FollowVarsMap) },
 		{ assoc_list__values(VarLocs, Locs) },
 		{ code_util__max_mentioned_reg(Locs, MaxMentionedReg) },
 		code_info__set_follow_vars(follow_vars(FollowVarsMap,
-			MaxMentionedReg + 1))
-	),
+		MaxMentionedReg + 1)),
 	code_info__get_instmap(InstMap),
 	( { instmap__is_reachable(InstMap) } ->
 		code_info__place_vars(VarLocs, Code)
@@ -1139,19 +1087,9 @@
 
 code_info__remake_with_store_map(StoreMap) -->
 	{ map__to_assoc_list(StoreMap, VarLvals) },
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		VarRvals = assoc_list__map_values(exprn_aux__var_lval_to_rval,
-			VarLvals),
-		code_exprn__reinit_state(VarRvals, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__reinit_state(VarLvals, VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__reinit_state(VarLvals, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__save_hp_in_branch(Code, Slot, Pos0, Pos) :-
 	Pos0 = position_info(CodeInfo0),
@@ -2609,19 +2547,9 @@
 code_info__set_var_locations(Map) -->
 	{ map__to_assoc_list(Map, LvalList0) },
 	{ code_info__flatten_varlval_list(LvalList0, LvalList) },
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		RvalList = assoc_list__map_values(exprn_aux__var_lval_to_rval,
-			LvalList),
-		code_exprn__reinit_state(RvalList, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__reinit_state(LvalList, VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__reinit_state(LvalList, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 :- pred code_info__flatten_varlval_list(assoc_list(prog_var, set(lval))::in,
 	assoc_list(prog_var, lval)::out) is det.
@@ -2787,69 +2715,34 @@
 
 code_info__make_vars_forward_live(Vars) -->
 	code_info__get_stack_slots(StackSlots),
-	code_info__get_var_locns_info(VarInfo0),
+	code_info__get_var_locn_info(VarLocnInfo0),
 	{ set__to_sorted_list(Vars, VarList) },
 	{ code_info__make_vars_forward_live_2(VarList, StackSlots, 1,
-		VarInfo0, VarInfo) },
-	code_info__set_var_locns_info(VarInfo).
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
-:- pred code_info__make_vars_forward_live_2(list(prog_var), stack_slots, int,
-	var_locns_info, var_locns_info).
-:- mode code_info__make_vars_forward_live_2(in, in, in, in, out) is det.
+:- pred code_info__make_vars_forward_live_2(list(prog_var)::in,
+	stack_slots::in, int::in, var_locn_info::in, var_locn_info::out) is det.
 
-code_info__make_vars_forward_live_2([], _, _, VarInfo, VarInfo).
+code_info__make_vars_forward_live_2([], _, _, VarLocnInfo, VarLocnInfo).
 code_info__make_vars_forward_live_2([Var | Vars], StackSlots, N0,
-		VarInfo0, VarInfo) :-
+		VarLocnInfo0, VarLocnInfo) :-
 	( map__search(StackSlots, Var, Lval0) ->
 		Lval = Lval0,
 		N1 = N0
 	;
-		code_info__find_unused_reg(N0, VarInfo0, N1),
+		code_info__find_unused_reg(N0, VarLocnInfo0, N1),
 		Lval = reg(r, N1)
 	),
-	(
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__maybe_set_var_location(Var, Lval, Exprn0, Exprn1),
-		VarInfo1 = exprn_info(Exprn1)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__set_magic_var_location(Var, Lval,
-			VarLocn0, VarLocn1),
-		VarInfo1 = var_locn_info(VarLocn1)
-	),
+	var_locn__set_magic_var_location(Var, Lval, VarLocnInfo0, VarLocnInfo1),
 	code_info__make_vars_forward_live_2(Vars, StackSlots, N1,
-		VarInfo1, VarInfo).
-
-:- pred code_info__find_unused_reg(int, var_locns_info, int).
-:- mode code_info__find_unused_reg(in, in, out) is det.
-
-code_info__find_unused_reg(N0, VarInfo0, N) :-
-	(
-		VarInfo0 = exprn_info(Exprn0),
-		code_info__find_unused_reg_lazy(N0, Exprn0, N)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		code_info__find_unused_reg_eager(N0, VarLocn0, N)
-	).
+		VarLocnInfo1, VarLocnInfo).
 
-:- pred code_info__find_unused_reg_eager(int, var_locn_info, int).
-:- mode code_info__find_unused_reg_eager(in, in, out) is det.
+:- pred code_info__find_unused_reg(int::in, var_locn_info::in, int::out) is det.
 
-code_info__find_unused_reg_eager(N0, Exprn0, N) :-
+code_info__find_unused_reg(N0, Exprn0, N) :-
 	( var_locn__lval_in_use(reg(r, N0), Exprn0, _) ->
-		N1 is N0 + 1,
-		code_info__find_unused_reg_eager(N1, Exprn0, N)
-	;
-		N = N0
-	).
-
-:- pred code_info__find_unused_reg_lazy(int, exprn_info, int).
-:- mode code_info__find_unused_reg_lazy(in, in, out) is det.
-
-code_info__find_unused_reg_lazy(N0, Exprn0, N) :-
-	( code_exprn__lval_in_use(reg(r, N0), Exprn0, _) ->
-		N1 is N0 + 1,
-		code_info__find_unused_reg_lazy(N1, Exprn0, N)
+		code_info__find_unused_reg(N0 + 1, Exprn0, N)
 	;
 		N = N0
 	).
@@ -2877,17 +2770,10 @@
 
 code_info__maybe_make_vars_forward_dead_2([], _) --> [].
 code_info__maybe_make_vars_forward_dead_2([V | Vs], FirstTime) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__var_becomes_dead(V, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__var_becomes_dead(V, FirstTime, VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo),
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__var_becomes_dead(V, FirstTime,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo),
 	code_info__maybe_make_vars_forward_dead_2(Vs, FirstTime).
 
 code_info__pickup_zombies(Zombies) -->
@@ -3146,7 +3032,7 @@
 %---------------------------------------------------------------------------%
 %---------------------------------------------------------------------------%
 
-	% Submodule to deal with code_exprn or var_locn.
+	% Submodule to deal with var_locn.
 
 :- interface.
 
@@ -3226,10 +3112,10 @@
 :- pred code_info__setup_return(assoc_list(prog_var, arg_info)::in,
 	set(lval)::out, code_tree::out, code_info::in, code_info::out) is det.
 
-:- pred code_info__eager_lock_regs(int::in, assoc_list(prog_var, lval)::in,
+:- pred code_info__lock_regs(int::in, assoc_list(prog_var, lval)::in,
 	code_info::in, code_info::out) is det.
 
-:- pred code_info__eager_unlock_regs(code_info::in, code_info::out) is det.
+:- pred code_info__unlock_regs(code_info::in, code_info::out) is det.
 
 	% Record the fact that all the registers have been clobbered (as by a
 	% call). If the bool argument is true, then the call cannot return, and
@@ -3255,22 +3141,9 @@
 
 :- implementation.
 
-:- pred code_info__pick_and_place_vars(assoc_list(prog_var, set(lval))::in,
-	set(lval)::out, code_tree::out, code_info::in, code_info::out) is det.
-
-:- pred code_info__place_vars(assoc_list(prog_var, lval)::in,
-	code_tree::out, code_info::in, code_info::out) is det.
-
 code_info__variable_locations(Lvals) -->
-	code_info__get_var_locns_info(VarInfo),
-	{
-		VarInfo = exprn_info(Exprn),
-		code_exprn__get_varlocs(Exprn, Rvals),
-		Lvals = map__map_values(code_info__rval_map_to_lval_map, Rvals)
-	;
-		VarInfo = var_locn_info(VarLocn),
-		var_locn__get_var_locations(VarLocn, Lvals)
-	}.
+	code_info__get_var_locn_info(VarLocnInfo),
+	{ var_locn__get_var_locations(VarLocnInfo, Lvals) }.
 
 :- func code_info__rval_map_to_lval_map(prog_var, set(rval)) = set(lval).
 
@@ -3282,117 +3155,56 @@
 code_info__rval_is_lval(lval(Lval)) = Lval.
 
 code_info__set_var_location(Var, Lval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__set_var_location(Var, Lval, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__check_and_set_magic_var_location(Var, Lval,
-			VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__check_and_set_magic_var_location(Var, Lval,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__assign_var_to_var(Var, AssignedVar) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__cache_exprn(Var, var(AssignedVar), Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocInfo0),
-		var_locn__assign_var_to_var(Var, AssignedVar,
-			VarLocInfo0, VarLocInfo),
-		VarInfo = var_locn_info(VarLocInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__assign_var_to_var(Var, AssignedVar,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__assign_lval_to_var(Var, Lval, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__cache_exprn(Var, lval(Lval), Exprn0, Exprn),
-		Code = empty,
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocInfo0),
-		var_locn__assign_lval_to_var(Var, Lval, Code,
-			VarLocInfo0, VarLocInfo),
-		VarInfo = var_locn_info(VarLocInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__assign_lval_to_var(Var, Lval, Code,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__assign_const_to_var(Var, ConstRval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__cache_exprn(Var, ConstRval, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocInfo0),
-		var_locn__assign_const_to_var(Var, ConstRval,
-			VarLocInfo0, VarLocInfo),
-		VarInfo = var_locn_info(VarLocInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__assign_const_to_var(Var, ConstRval,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__assign_expr_to_var(Var, Rval, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
+	code_info__get_var_locn_info(VarLocnInfo0),
 	{
 		code_util__lvals_in_rval(Rval, Lvals),
 		Lvals = []
 	->
-		(
-			VarInfo0 = exprn_info(Exprn0),
-			code_exprn__cache_exprn(Var, Rval, Exprn0, Exprn),
-			VarInfo = exprn_info(Exprn),
-			Code = empty
-		;
-			VarInfo0 = var_locn_info(VarLocInfo0),
 			var_locn__assign_expr_to_var(Var, Rval, Code,
-				VarLocInfo0, VarLocInfo),
-			VarInfo = var_locn_info(VarLocInfo)
-		)
+			VarLocnInfo0, VarLocnInfo)
 	;
 		error("code_info__assign_expr_to_var: non-var lvals")
 	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__assign_cell_to_var(Var, Ptag, Vector, TypeMsg, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
+	code_info__get_var_locn_info(VarLocnInfo0),
 	code_info__get_next_cell_number(CellNum),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-			% XXX Later we will need to worry about
-			% whether the cell must be unique or not.
-		Reuse = no,
-		Rval = create(Ptag, Vector, uniform(no), can_be_either,
-			CellNum, TypeMsg, Reuse),
-		code_exprn__cache_exprn(Var, Rval, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn),
-		Code = empty
-	;
-		VarInfo0 = var_locn_info(VarLocInfo0),
-		var_locn__assign_cell_to_var(Var, Ptag, Vector, CellNum,
-			TypeMsg, Code, VarLocInfo0, VarLocInfo),
-		VarInfo = var_locn_info(VarLocInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	{ var_locn__assign_cell_to_var(Var, Ptag, Vector, CellNum,
+		TypeMsg, Code, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__place_var(Var, Lval, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__place_var(Var, Lval, Code, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__place_var(Var, Lval, Code, VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__place_var(Var, Lval, Code, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
+
+:- pred code_info__pick_and_place_vars(assoc_list(prog_var, set(lval))::in,
+	set(lval)::out, code_tree::out, code_info::in, code_info::out) is det.
 
 code_info__pick_and_place_vars(VarLocSets, LiveLocs, Code) -->
 	{ code_info__pick_var_places(VarLocSets, VarLocs) },
@@ -3415,178 +3227,89 @@
 		VarLvals = VarLvals0
 	).
 
+:- pred code_info__place_vars(assoc_list(prog_var, lval)::in,
+	code_tree::out, code_info::in, code_info::out) is det.
+
 code_info__place_vars(VarLocs, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__place_vars(VarLocs, Code, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__place_vars(VarLocs, Code, VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__place_vars(VarLocs, Code, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__produce_variable(Var, Code, Rval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__produce_var(Var, Rval, Code, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__produce_var(Var, Rval, Code, VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__produce_var(Var, Rval, Code, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__produce_variable_in_reg(Var, Code, Lval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__produce_var_in_reg(Var, Lval, Code, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__produce_var_in_reg(Var, Lval, Code,
-			VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__produce_var_in_reg(Var, Lval, Code,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__produce_variable_in_reg_or_stack(Var, Code, Lval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__produce_var_in_reg_or_stack(Var, Lval, Code,
-			Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__produce_var_in_reg_or_stack(Var, Lval, Code,
-			VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__produce_var_in_reg_or_stack(Var, Lval, Code,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
-code_info__materialize_vars_in_rval(Rval0, Rval, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__materialize_vars_in_rval(Rval0, Rval, Code,
-			Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
+code_info__materialize_vars_in_rval(Rval0, Rval, Code, CI0, CI) :-
+	code_info__get_var_locn_info(VarLocnInfo0, CI0, CI1),
 		( Rval0 = lval(Lval0) ->
 			var_locn__materialize_vars_in_lval(Lval0, Lval, Code,
 				VarLocnInfo0, VarLocnInfo),
-			Rval = lval(Lval),
-			VarInfo = var_locn_info(VarLocnInfo)
+		Rval = lval(Lval)
 		; exprn_aux__vars_in_rval(Rval0, []) ->
 			Rval = Rval0,
 			Code = empty,
-			VarInfo = VarInfo0
+		VarLocnInfo = VarLocnInfo0
 		;
-			error("eager code_info__materialize_vars_in_rval")
-		)
-	},
-	code_info__set_var_locns_info(VarInfo).
+		error("code_info__materialize_vars_in_rval")
+	),
+	code_info__set_var_locn_info(VarLocnInfo, CI1, CI).
 
 code_info__acquire_reg_for_var(Var, Lval) -->
 	code_info__get_follow_var_map(FollowVarsMap),
 	code_info__get_next_non_reserved(NextNonReserved),
-	code_info__get_var_locns_info(VarInfo0),
+	code_info__get_var_locn_info(VarLocnInfo0),
 	{
 		map__search(FollowVarsMap, Var, PrefLval),
 		PrefLval = reg(PrefRegType, PrefRegNum),
 		PrefRegNum >= 1
 	->
-		(
-			VarInfo0 = exprn_info(Exprn0),
-			code_exprn__acquire_reg_prefer_given(PrefRegType,
-				PrefRegNum, Lval, Exprn0, Exprn),
-			VarInfo = exprn_info(Exprn)
-		;
-			VarInfo0 = var_locn_info(VarLocn0),
 			require(unify(PrefRegType, r), "acquire non-r reg"),
 			var_locn__acquire_reg_prefer_given(PrefRegNum, Lval,
-				VarLocn0, VarLocn),
-			VarInfo = var_locn_info(VarLocn)
-		)
+			VarLocnInfo0, VarLocnInfo)
 	;
 		% XXX We should only get a register if the map__search
 		% succeeded; otherwise we should put the var in its stack slot.
-		(
-			VarInfo0 = exprn_info(Exprn0),
-			code_exprn__acquire_reg(r, Lval, Exprn0, Exprn),
-			VarInfo = exprn_info(Exprn)
-		;
-			VarInfo0 = var_locn_info(VarLocn0),
-			var_locn__acquire_reg_start_at_given(
-				NextNonReserved, Lval, VarLocn0, VarLocn),
-			VarInfo = var_locn_info(VarLocn)
-		)
+		var_locn__acquire_reg_start_at_given(NextNonReserved, Lval,
+			VarLocnInfo0, VarLocnInfo)
 	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__acquire_reg(Type, Lval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__acquire_reg(Type, Lval, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		require(unify(Type, r),
-			"code_info__acquire_reg: unknown reg type"),
-		var_locn__acquire_reg(Lval, VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ require(unify(Type, r),
+		"code_info__acquire_reg: unknown reg type") },
+	{ var_locn__acquire_reg(Lval, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__release_reg(Lval) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__release_reg(Lval, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__release_reg(Lval, VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__release_reg(Lval, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__reserve_r1(Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(_Exprn0),
-		VarInfo = VarInfo0,
-		Code = empty
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__clear_r1(Code, VarLocnInfo0, VarLocnInfo1),
-		var_locn__acquire_reg_require_given(reg(r, 1), VarLocnInfo1,
-			VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
-
-code_info__clear_r1(Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__clear_r1(Code, Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__release_reg(reg(r, 1), VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo),
-		Code = empty
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__clear_r1(Code, VarLocnInfo0, VarLocnInfo1) },
+	{ var_locn__acquire_reg_require_given(reg(r, 1),
+		VarLocnInfo1, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
+
+code_info__clear_r1(empty) -->
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__release_reg(reg(r, 1), VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 %---------------------------------------------------------------------------%
 
@@ -3627,62 +3350,32 @@
 		)
 	),
 
-	code_info__get_var_locns_info(VarInfo0),
-	(
-		{ VarInfo0 = exprn_info(_) },
-
-		code_info__place_vars(StackVarLocs, StackCode),
-		{ assoc_list__values(StackVarLocs, StackLocs) },
-		{ set__list_to_set(StackLocs, StackLiveLocs) },
-
-		code_info__setup_call_args_lazy(InArgInfos, caller,
-			ArgLiveLocs, ArgCode),
-		{ set__union(StackLiveLocs, ArgLiveLocs, LiveLocs) },
-		{ Code = tree(StackCode, ArgCode) }
-	;
-		{ VarInfo0 = var_locn_info(VarLocnInfo0) },
+	code_info__get_var_locn_info(VarLocnInfo0),
 		{ code_info__var_arg_info_to_lval(InArgInfos, InArgLocs) },
 		{ list__append(StackVarLocs, InArgLocs, AllLocs) },
 		{ var_locn__place_vars(AllLocs, Code,
 			VarLocnInfo0, VarLocnInfo) },
-		code_info__set_var_locns_info(var_locn_info(VarLocnInfo)),
+	code_info__set_var_locn_info(VarLocnInfo),
 		{ assoc_list__values(AllLocs, LiveLocList) },
-		{ set__list_to_set(LiveLocList, LiveLocs) }
+	{ set__list_to_set(LiveLocList, LiveLocs) }.
 
 		% { assoc_list__keys(InArgLocs, InArgVars) },
 		% { set__init(DeadVars0) },
 		% code_info__which_variables_are_forward_live(InArgVars,
 		% 	DeadVars0, DeadVars),
 		% code_info__make_vars_forward_dead(DeadVars)
-	).
 
 :- pred code_info__setup_call_args(assoc_list(prog_var, arg_info)::in,
 	call_direction::in, set(lval)::out, code_tree::out,
 	code_info::in, code_info::out) is det.
 
-code_info__setup_call_args(VarArgInfos, Direction, LiveLocs, Code) -->
-	code_info__get_var_locns_info(VarInfo0),
-	(
-		{ VarInfo0 = exprn_info(_) },
-		code_info__setup_call_args_lazy(VarArgInfos, Direction,
-			LiveLocs, Code)
-	;
-		{ VarInfo0 = var_locn_info(_) },
-		code_info__setup_call_args_eager(VarArgInfos, Direction,
-			LiveLocs, Code)
-	).
-
-:- pred code_info__setup_call_args_eager(assoc_list(prog_var, arg_info)::in,
-	call_direction::in, set(lval)::out, code_tree::out,
-	code_info::in, code_info::out) is det.
-
-code_info__setup_call_args_eager(AllArgsInfos, Direction, LiveLocs, Code) -->
+code_info__setup_call_args(AllArgsInfos, Direction, LiveLocs, Code) -->
 	{ list__filter(code_info__call_arg_in_selected_dir(Direction),
 		AllArgsInfos, ArgsInfos) },
 	{ code_info__var_arg_info_to_lval(ArgsInfos, ArgsLocns) },
-	code_info__get_eager_var_locns_info(VarLocnInfo0),
+	code_info__get_var_locn_info(VarLocnInfo0),
 	{ var_locn__place_vars(ArgsLocns, Code, VarLocnInfo0, VarLocnInfo1) },
-	code_info__set_var_locns_info(var_locn_info(VarLocnInfo1)),
+	code_info__set_var_locn_info(VarLocnInfo1),
 	{ assoc_list__values(ArgsLocns, LiveLocList) },
 	{ set__list_to_set(LiveLocList, LiveLocs) },
 	{ assoc_list__keys(ArgsLocns, ArgVars) },
@@ -3715,68 +3408,6 @@
 	),
 	code_info__which_variables_are_forward_live(Vars, DeadVars1, DeadVars).
 
-:- pred code_info__setup_call_args_lazy(assoc_list(prog_var, arg_info)::in,
-	call_direction::in, set(lval)::out, code_tree::out,
-	code_info::in, code_info::out) is det.
-
-code_info__setup_call_args_lazy([], _Direction, set__init, empty) --> [].
-code_info__setup_call_args_lazy([First | Rest], Direction, LiveLocs, Code) -->
-	( { code_info__call_arg_in_selected_dir(Direction, First) } ->
-		{ First = V - arg_info(Loc, _Mode) },
-		{ code_util__arg_loc_to_register(Loc, Reg) },
-		code_info__get_lazy_var_locns_info(Exprn0),
-		{ code_exprn__place_var(V, Reg, Code0, Exprn0, Exprn1) },
-			% We need to test that either the variable
-			% is live OR it occurs in the remaining arguments
-			% because of a bug in polymorphism.m which
-			% causes some compiler generated code to violate
-			% superhomogeneous form
-		(
-			code_info__variable_is_forward_live(V)
-		->
-			{ IsLive = yes }
-		;
-			{ IsLive = no }
-		),
-		{
-			list__member(Vtmp - _, Rest),
-			V = Vtmp
-		->
-			Occurs = yes
-		;
-			Occurs = no
-		},
-		(
-				% We can't simply use a disj here
-				% because of bugs in modes/det_analysis
-			{ bool__or(Occurs, IsLive, yes) }
-		->
-			{ code_exprn__lock_reg(Reg, Exprn1, Exprn2) },
-			code_info__set_var_locns_info(exprn_info(Exprn2)),
-			code_info__setup_call_args_lazy(Rest, Direction,
-				LiveLocs1, Code1),
-			code_info__get_lazy_var_locns_info(Exprn3),
-			{ code_exprn__unlock_reg(Reg, Exprn3, Exprn) },
-			code_info__set_var_locns_info(exprn_info(Exprn)),
-			{ Code = tree(Code0, Code1) }
-		;
-			{ code_exprn__lock_reg(Reg, Exprn1, Exprn2) },
-			code_info__set_var_locns_info(exprn_info(Exprn2)),
-			{ set__singleton_set(Vset, V) },
-			code_info__make_vars_forward_dead(Vset),
-			code_info__setup_call_args_lazy(Rest, Direction,
-				LiveLocs1, Code1),
-			code_info__get_lazy_var_locns_info(Exprn4),
-			{ code_exprn__unlock_reg(Reg, Exprn4, Exprn) },
-			code_info__set_var_locns_info(exprn_info(Exprn)),
-			{ Code = tree(Code0, Code1) }
-		),
-		{ set__insert(LiveLocs1, Reg, LiveLocs) }
-	;
-		code_info__setup_call_args_lazy(Rest, Direction,
-			LiveLocs, Code)
-	).
-
 :- pred code_info__call_arg_in_selected_dir(call_direction::in,
 	pair(prog_var, arg_info)::in) is semidet.
 
@@ -3789,85 +3420,26 @@
 		Direction = callee
 	).
 
-code_info__eager_lock_regs(N, Exceptions) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(_),
-		VarInfo = VarInfo0
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__lock_regs(N, Exceptions, VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
-
-code_info__eager_unlock_regs -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(_),
-		VarInfo = VarInfo0
-	;
-		VarInfo0 = var_locn_info(VarLocnInfo0),
-		var_locn__unlock_regs(VarLocnInfo0, VarLocnInfo),
-		VarInfo = var_locn_info(VarLocnInfo)
-	},
-	code_info__set_var_locns_info(VarInfo).
-
-:- pred code_info__get_eager_var_locns_info(var_locn_info::out,
-	code_info::in, code_info::out) is det.
-
-code_info__get_eager_var_locns_info(VarLocnInfo) -->
-	code_info__get_var_locns_info(VarInfo),
-	{
-		VarInfo = exprn_info(_),
-		error("lazy code_info__get_eager_var_locns_info")
-	;
-		VarInfo = var_locn_info(VarLocnInfo)
-	}.
-
-:- pred code_info__get_lazy_var_locns_info(exprn_info::out,
-	code_info::in, code_info::out) is det.
-
-code_info__get_lazy_var_locns_info(Exprn) -->
-	code_info__get_var_locns_info(VarInfo),
-	{
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo = var_locn_info(_),
-		error("eager code_info__get_lazy_var_locns_info")
-	}.
+code_info__lock_regs(N, Exceptions) -->
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__lock_regs(N, Exceptions, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
+
+code_info__unlock_regs -->
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__unlock_regs(VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
-	% As a sanity check, we could test whether any known variable
-	% has its only value in a register, but we do so only with eager
-	% code generation.
 code_info__clear_all_registers(OkToDeleteAny) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(Exprn0),
-		code_exprn__clobber_regs([], Exprn0, Exprn),
-		VarInfo = exprn_info(Exprn)
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__clobber_all_regs(OkToDeleteAny, VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__clobber_all_regs(OkToDeleteAny,
+		VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__clobber_regs(Regs) -->
-	code_info__get_var_locns_info(VarInfo0),
-	{
-		VarInfo0 = exprn_info(_Exprn0),
-		% The clobber_regs predicate has no function except to ensure
-		% that sanity check in eager code generation does not fail
-		% when it shouldn't. Since lazy code generation lacks this
-		% sanity check, it doesn't need to do anything.
-		VarInfo = VarInfo0
-	;
-		VarInfo0 = var_locn_info(VarLocn0),
-		var_locn__clobber_regs(Regs, VarLocn0, VarLocn),
-		VarInfo = var_locn_info(VarLocn)
-	},
-	code_info__set_var_locns_info(VarInfo).
+	code_info__get_var_locn_info(VarLocnInfo0),
+	{ var_locn__clobber_regs(Regs, VarLocnInfo0, VarLocnInfo) },
+	code_info__set_var_locn_info(VarLocnInfo).
 
 code_info__save_variables(OutArgs, SavedLocs, Code) -->
 	code_info__compute_forward_live_var_saves(OutArgs, VarLocs),
@@ -3902,14 +3474,8 @@
 	code_info__get_variable_slot(Var, Slot).
 
 code_info__max_reg_in_use(Max) -->
-	code_info__get_var_locns_info(VarInfo),
-	{
-		VarInfo = exprn_info(Exprn),
-		code_exprn__max_reg_in_use(Exprn, Max)
-	;
-		VarInfo = var_locn_info(VarLocn),
-		var_locn__max_reg_in_use(VarLocn, Max)
-	}.
+	code_info__get_var_locn_info(VarLocnInfo),
+	{ var_locn__max_reg_in_use(VarLocnInfo, Max) }.
 
 %---------------------------------------------------------------------------%
 %---------------------------------------------------------------------------%
Index: compiler/exprn_aux.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/exprn_aux.m,v
retrieving revision 1.43
diff -u -b -r1.43 exprn_aux.m
--- compiler/exprn_aux.m	7 May 2002 11:02:43 -0000	1.43
+++ compiler/exprn_aux.m	16 Sep 2002 11:18:10 -0000
@@ -12,10 +12,9 @@
 :- import_module list, std_util, bool, assoc_list.
 
 :- type exprn_opts
-	--->	nlg_asm_sgt_ubf(
+	--->	nlg_asm_ubf(
 			bool,	% --use-non-local-gotos
 			bool,	% --use-asm-labels
-			bool,	% --static-ground-terms
 			bool	% --unboxed-float
 		).
 
@@ -108,9 +107,8 @@
 exprn_aux__init_exprn_opts(Options, ExprnOpts) :-
 	getopt__lookup_bool_option(Options, gcc_non_local_gotos, NLG),
 	getopt__lookup_bool_option(Options, asm_labels, ASM),
-	getopt__lookup_bool_option(Options, static_ground_terms, SGT),
 	getopt__lookup_bool_option(Options, unboxed_float, UBF),
-	ExprnOpts = nlg_asm_sgt_ubf(NLG, ASM, SGT, UBF).
+	ExprnOpts = nlg_asm_ubf(NLG, ASM, UBF).
 
 % Determine whether a const (well, what _we_ consider to be a const)
 % is constant as far as the C compiler is concerned -- specifically,
@@ -120,25 +118,7 @@
 exprn_aux__const_is_constant(true, _, yes).
 exprn_aux__const_is_constant(false, _, yes).
 exprn_aux__const_is_constant(int_const(_), _, yes).
-exprn_aux__const_is_constant(float_const(_), ExprnOpts, IsConst) :-
-	ExprnOpts = nlg_asm_sgt_ubf(_NLG, _ASM, StaticGroundTerms,
-		UnboxedFloat),
-	( UnboxedFloat = yes ->
-		%
-		% If we're using unboxed (single-precision) floats,
-		% floating point values are always constants
-		%
-		IsConst = yes
-	;
-		%
-		% If we're using boxed floats, then we can generate a static
-		% constant variable to hold a float constant, and gcc
-		% doesn't mind us converting from its address to word
-		% in a static initializer.  However, we only do this if
-		% --static-ground-terms is enabled.
-		%
-		IsConst = StaticGroundTerms
-	).
+exprn_aux__const_is_constant(float_const(_), _, yes).
 exprn_aux__const_is_constant(string_const(_), _, yes).
 exprn_aux__const_is_constant(multi_string_const(_, _), _, yes).
 exprn_aux__const_is_constant(code_addr_const(CodeAddr), ExprnOpts, IsConst) :-
@@ -151,10 +131,10 @@
 	is det.
 
 exprn_aux__addr_is_constant(label(Label), ExprnOpts, IsConst) :-
-	ExprnOpts = nlg_asm_sgt_ubf(NonLocalGotos, AsmLabels, _SGT, _UBF),
+	ExprnOpts = nlg_asm_ubf(NonLocalGotos, AsmLabels, _UBF),
 	exprn_aux__label_is_constant(Label, NonLocalGotos, AsmLabels, IsConst).
 exprn_aux__addr_is_constant(imported(_), ExprnOpts, IsConst) :-
-	ExprnOpts = nlg_asm_sgt_ubf(NonLocalGotos, AsmLabels, _SGT, _UBF),
+	ExprnOpts = nlg_asm_ubf(NonLocalGotos, AsmLabels, _UBF),
 	exprn_aux__imported_is_constant(NonLocalGotos, AsmLabels, IsConst).
 exprn_aux__addr_is_constant(succip, _, no).
 exprn_aux__addr_is_constant(do_succeed(_), _, no).
Index: compiler/handle_options.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/handle_options.m,v
retrieving revision 1.153
diff -u -b -r1.153 handle_options.m
--- compiler/handle_options.m	9 Sep 2002 08:55:08 -0000	1.153
+++ compiler/handle_options.m	16 Sep 2002 11:10:30 -0000
@@ -1106,18 +1106,6 @@
 :- pred postprocess_options_lowlevel(io__state::di, io__state::uo) is det.
 
 postprocess_options_lowlevel -->
-		% --no-lazy-code assumes that const(_) rvals are really
-		% constant, and that create(_) rvals with constant arguments
-		% can be materialized in an assignable rval without further
-		% code. For float_consts, the former is true only if either
-		% static_ground_terms or unboxed_floats is true, and the latter
-		% cannot be true without static_ground_terms.
-	option_neg_implies(lazy_code, static_ground_terms, bool(yes)),
-
-		% --no-lazy-code requires --follow-vars for acceptable
-		% performance.
-	option_neg_implies(lazy_code, follow_vars, bool(yes)),
-
 		% --optimize-saved-vars-cell requires --use-local-vars for
 		% acceptable performance.
 	option_implies(optimize_saved_vars_cell, use_local_vars, bool(yes)),
Index: compiler/hlds_goal.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/hlds_goal.m,v
retrieving revision 1.99
diff -u -b -r1.99 hlds_goal.m
--- compiler/hlds_goal.m	9 Sep 2002 07:48:12 -0000	1.99
+++ compiler/hlds_goal.m	14 Oct 2002 06:58:32 -0000
@@ -531,7 +531,7 @@
 	% alternative is set by the `mark_static_terms.m' pass,
 	% and is currently only used for the MLDS back-end
 	% (for the LLDS back-end, the same optimization is
-	% handled by code_exprn.m).
+	% handled by var_locn.m).
 	% The `reuse_cell' alternative is not yet used.
 :- type how_to_construct
 	--->	construct_statically(		% Use a statically initialized
Index: compiler/ll_backend.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/ll_backend.m,v
retrieving revision 1.2
diff -u -b -r1.2 ll_backend.m
--- compiler/ll_backend.m	28 Mar 2002 03:43:10 -0000	1.2
+++ compiler/ll_backend.m	14 Oct 2002 06:58:36 -0000
@@ -45,7 +45,6 @@
    :- include_module trace.
 
    :- include_module code_info.
-   :- include_module code_exprn.
    :- include_module exprn_aux.
    :- include_module code_aux. % XXX
    :- include_module continuation_info.
Index: compiler/llds_out.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/llds_out.m,v
retrieving revision 1.201
diff -u -b -r1.201 llds_out.m
--- compiler/llds_out.m	29 Sep 2002 10:30:41 -0000	1.201
+++ compiler/llds_out.m	29 Sep 2002 10:36:08 -0000
@@ -2246,9 +2246,7 @@
 		% variable holding that constant.
 		%
 		globals__io_lookup_bool_option(unboxed_float, UnboxedFloat),
-		globals__io_lookup_bool_option(static_ground_terms,
-			StaticGroundTerms),
-		( { UnboxedFloat = no, StaticGroundTerms = yes } ->
+		( { UnboxedFloat = no } ->
 			{ llds_out__float_literal_name(FloatVal, FloatName) },
 			{ FloatLabel = float_label(FloatName) },
 			( { decl_set_is_member(FloatLabel, DeclSet0) } ->
@@ -2293,10 +2291,8 @@
 		%
 	( { c_util__float_op(Op, OpStr) } ->
 	    globals__io_lookup_bool_option(unboxed_float, UnboxFloat),
-	    globals__io_lookup_bool_option(static_ground_terms,
-					StaticGroundTerms),
 	    (
-		{ UnboxFloat = no, StaticGroundTerms = yes },
+		{ UnboxFloat = no },
 		{ llds_out__float_const_binop_expr_name(Op, Rval1, Rval2,
 			FloatName) }
 	    ->
@@ -3811,9 +3807,8 @@
 	% earlier
 	%
 	globals__io_lookup_bool_option(unboxed_float, UnboxFloat),
-	globals__io_lookup_bool_option(static_ground_terms, StaticGroundTerms),
 	(
-		{ UnboxFloat = no, StaticGroundTerms = yes },
+		{ UnboxFloat = no },
 		{ llds_out__float_const_expr_name(Rval, FloatName) }
 	->
 		output_llds_type_cast(data_ptr),
@@ -3839,9 +3834,8 @@
 	% earlier
 	%
 	globals__io_lookup_bool_option(unboxed_float, UnboxFloat),
-	globals__io_lookup_bool_option(static_ground_terms, StaticGroundTerms),
 	(
-		{ UnboxFloat = no, StaticGroundTerms = yes },
+		{ UnboxFloat = no },
 		{ llds_out__float_const_expr_name(Rval, FloatName) }
 	->
 		output_llds_type_cast(word),
Index: compiler/lookup_switch.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/lookup_switch.m,v
retrieving revision 1.44
diff -u -b -r1.44 lookup_switch.m
--- compiler/lookup_switch.m	28 Mar 2002 03:43:11 -0000	1.44
+++ compiler/lookup_switch.m	14 Oct 2002 07:55:32 -0000
@@ -95,8 +95,6 @@
 		% some circumstances, but it would take a pretty complex
 		% heuristic to get it right, so, lets just use a simple
 		% one - no static ground terms, no lookup switch.
-	code_info__get_globals(Globals),
-	{ globals__lookup_bool_option(Globals, static_ground_terms, yes) },
 	{
 		% We want to generate a lookup switch for any switch
 		% that is dense enough - we don't care how many cases
@@ -115,13 +113,11 @@
 	% If there are going to be no gaps in the lookup
 	% table then we won't need a bitvector test to see
 	% if this switch has a value for this case.
-	(
-		{ NumCases = Range }
-	->
-		{ NeedBitVecTest0 = cannot_fail }
+	{ NumCases = Range ->
+		NeedBitVecTest0 = cannot_fail
 	;
-		{ NeedBitVecTest0 = can_fail }
-	),
+		NeedBitVecTest0 = can_fail
+	},
 	(
 		{ SwitchCanFail = can_fail },
 		% For semidet switches, we normally need to check that
@@ -248,9 +244,6 @@
 	% nonlocal gotos, asm labels enabled, and static ground terms, etc.
 :- pred lookup_switch__rval_is_constant(rval::in, exprn_opts::in) is semidet.
 
-	% Based on code_exprn__rval_is_constant, but differs in
-	% that it doesn't happen with respect to the expression cache.
-
 lookup_switch__rval_is_constant(const(Const), ExprnOpts) :-
 	exprn_aux__const_is_constant(Const, ExprnOpts, yes).
 lookup_switch__rval_is_constant(unop(_, Exprn), ExprnOpts) :-
@@ -265,8 +258,6 @@
 	(
 		StatDyn = must_be_static
 	;
-		ExprnOpts = nlg_asm_sgt_ubf(_, _, StaticGroundTerms, _),
-		StaticGroundTerms = yes,
 		lookup_switch__rvals_are_constant(Args, ExprnOpts)
 	).
 
Index: compiler/options.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/options.m,v
retrieving revision 1.388
diff -u -b -r1.388 options.m
--- compiler/options.m	19 Sep 2002 13:58:59 -0000	1.388
+++ compiler/options.m	14 Oct 2002 08:25:30 -0000
@@ -342,7 +342,6 @@
 		;	reclaim_heap_on_failure
 		;	reclaim_heap_on_semidet_failure
 		;	reclaim_heap_on_nondet_failure
-		;	lazy_code
 		;	have_delay_slot
 		;	num_real_r_regs
 		;	num_real_f_regs
@@ -440,10 +439,9 @@
 		;	  tag_switch_size
 		;	  try_switch_size
 		;	  binary_switch_size
-		;	static_ground_terms
+		;	static_ground_terms % used only by the MLDS backends
 		;	middle_rec
 		;	simple_neg
-		;	follow_vars
 		;	allow_hijacks
 	%	- MLDS
 		;	optimize_tailcalls
@@ -849,7 +847,6 @@
 	low_level_debug		-	bool(no),
 	trad_passes		-	bool(yes),
 	polymorphism		-	bool(yes),
-	lazy_code		-	bool(no),
 	reclaim_heap_on_failure	-	bool_special,
 	reclaim_heap_on_semidet_failure	-	bool(yes),
 	reclaim_heap_on_nondet_failure	-	bool(yes),
@@ -973,7 +970,6 @@
 	static_ground_terms	-	bool(no),
 	middle_rec		-	bool(no),
 	simple_neg		-	bool(no),
-	follow_vars		-	bool(no),
 	allow_hijacks		-	bool(yes),
 % MLDS
 	optimize_tailcalls	- 	bool(no),
@@ -1408,7 +1404,6 @@
 long_option("low-level-debug",		low_level_debug).
 long_option("polymorphism",		polymorphism).
 long_option("trad-passes",		trad_passes).
-long_option("lazy-code",		lazy_code).
 long_option("reclaim-heap-on-failure",	reclaim_heap_on_failure).
 long_option("reclaim-heap-on-semidet-failure",
 					reclaim_heap_on_semidet_failure).
@@ -1551,7 +1546,6 @@
 long_option("static-ground-terms",	static_ground_terms).
 long_option("middle-rec",		middle_rec).
 long_option("simple-neg",		simple_neg).
-long_option("follow-vars",		follow_vars).
 long_option("allow-hijacks",		allow_hijacks).
 
 % MLDS optimizations
@@ -1989,7 +1983,6 @@
 	c_optimize		-	bool(yes),	% XXX we want `gcc -O1'
 	optimize_frames		-	bool(yes),
 	optimize_delay_slot	-	bool(DelaySlot),
-	follow_vars		-	bool(yes),
 	middle_rec		-	bool(yes),
 	emit_c_loops		-	bool(yes),
 	optimize_tailcalls	-	bool(yes)
@@ -3274,8 +3267,6 @@
 		"\tDisable the middle recursion optimization.",
 		"--no-simple-neg",
-		"\tDon't generate simplified code for simple negations.",
+		"\tDon't generate simplified code for simple negations."
-		"--no-follow-vars",
-		"\tDon't optimize the assignment of registers in branched goals."
 %		"--no-allow-hijacks",
 %		"\tDo not generate code in which a procedure hijacks",
 %		"\ta nondet stack frame that possibly belongs to",
Index: compiler/store_alloc.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/store_alloc.m,v
retrieving revision 1.80
diff -u -b -r1.80 store_alloc.m
--- compiler/store_alloc.m	30 Jul 2002 08:25:11 -0000	1.80
+++ compiler/store_alloc.m	16 Sep 2002 14:46:48 -0000
@@ -55,11 +55,7 @@
 
 allocate_store_maps(RunType, ProcInfo0, PredId, ModuleInfo, ProcInfo) :-
 	module_info_globals(ModuleInfo, Globals),
-	globals__lookup_bool_option(Globals, follow_vars, ApplyFollowVars),
-	(
-		RunType = final_allocation,
-		ApplyFollowVars = yes
-	->
+	( RunType = final_allocation ->
 		proc_info_goal(ProcInfo0, Goal0),
 
 		find_final_follow_vars(ProcInfo0,
@@ -86,10 +82,8 @@
 	),
 	arg_info__build_input_arg_list(ProcInfo0, InputArgLvals),
 	LastLocns0 = initial_last_locns(InputArgLvals),
-	globals__lookup_int_option(Globals, num_real_r_regs, NumRealRRegs),
 	proc_info_stack_slots(ProcInfo0, StackSlots),
-	StoreAllocInfo = store_alloc_info(ModuleInfo, ApplyFollowVars,
-		NumRealRRegs, StackSlots),
+	StoreAllocInfo = store_alloc_info(ModuleInfo, StackSlots),
 	store_alloc_in_goal(Goal2, Liveness0, ResumeVars0, LastLocns0,
 		StoreAllocInfo, Goal, _, _),
 	proc_info_set_goal(ProcInfo0, Goal, ProcInfo).
@@ -106,10 +100,6 @@
 :- type store_alloc_info
 	--->	store_alloc_info(
 			module_info		:: module_info,
-			done_follow_vars	:: bool,
-						% was follow_vars run?
-			num_real_r_regs		:: int,
-						% the number of real r regs
 			stack_slots		:: stack_slots
 						% maps each var to its stack
 						% slot (if it has one)
@@ -419,25 +409,14 @@
 	;
 		% We have not yet allocated a slot for this variable,
 		% which means it is not in the follow vars (if any).
-		StoreAllocInfo = store_alloc_info(_, FollowVars, NumRealRRegs,
-			StackSlots),
+		StoreAllocInfo = store_alloc_info(_, StackSlots),
 		(
 			map__search(StackSlots, Var, StackSlot),
-			\+ set__member(StackSlot, SeenLvals0),
-			(
-				FollowVars = yes
-				% If follow_vars was run, then the only
+			\+ set__member(StackSlot, SeenLvals0)
+			% Follow_vars was run, so the only
 				% reason why a var would not be in the
 				% follow_vars set is if it was supposed to
 				% be in its stack slot.
-			;
-				FollowVars = no,
-				% If follow_vars was not run, then we
-				% prefer to put the variable in a register,
-				% provided it is a real register.
-				next_free_reg(N0, SeenLvals0, TentativeReg),
-				TentativeReg =< NumRealRRegs
-			)
 		->
 			Locn = StackSlot,
 			N1 = N0
Index: compiler/var_locn.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/var_locn.m,v
retrieving revision 1.6
diff -u -b -r1.6 var_locn.m
--- compiler/var_locn.m	28 Mar 2002 03:43:47 -0000	1.6
+++ compiler/var_locn.m	14 Oct 2002 08:22:55 -0000
@@ -1820,8 +1820,6 @@
 % var_locn__expr_is_constant(Rval0, VarStateMap, ExprnOpts, Rval)
 % Check if Rval0 is a constant rval, after substituting the values of the
 % variables inside it. Returns the substituted, ground rval in Rval.
-% Note that this predicate is similar to code_exprn__expr_is_constant,
-% but of courses its own version of the variable state data structure.
 
 :- pred var_locn__expr_is_constant(rval::in, var_state_map::in, exprn_opts::in,
 	rval::out) is semidet.
@@ -1847,16 +1845,12 @@
 		VarStateMap, ExprnOpts, NewRval) :-
 	Reuse = no,
 	( StatDyn = must_be_static ->
-		NewRval = create(Tag, Args0, ArgTypes, StatDyn,
-			Label, Msg, Reuse)
+		Args = Args0
 	;
-		ExprnOpts = nlg_asm_sgt_ubf(_, _, StaticGroundTerms, _),
-		StaticGroundTerms = yes,
 		var_locn__args_are_constant(Args0, VarStateMap, ExprnOpts,
-			Args),
-		NewRval = create(Tag, Args, ArgTypes, StatDyn,
-			Label, Msg, Reuse)
-	).
+			Args)
+	),
+	NewRval = create(Tag, Args, ArgTypes, StatDyn, Label, Msg, Reuse).
 
 var_locn__expr_is_constant(var(Var), VarStateMap, ExprnOpts, Rval) :-
 	map__search(VarStateMap, Var, State),
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing deep_profiler
cvs diff: Diffing deep_profiler/notes
cvs diff: Diffing doc
Index: doc/user_guide.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/user_guide.texi,v
retrieving revision 1.330
diff -u -b -r1.330 user_guide.texi
--- doc/user_guide.texi	10 Oct 2002 07:40:13 -0000	1.330
+++ doc/user_guide.texi	14 Oct 2002 08:30:29 -0000
@@ -5699,17 +5699,29 @@
 Treat tailcalls as ordinary calls rather than optimizing
 by turning self-tailcalls into loops.
 
+ at sp 1
 @item --no-optimize-initializations
 @findex --no-optimize-initializations
 @findex --optimize-initializations
 Leave initializations of local variables as assignment statements,
 rather than converting such assignments statements into initializers.
 
+ at sp 1
 @item --eliminate-local-variables
 @findex --no-eliminate-local-variables
 @findex --eliminate-local-variables
 Eliminate local variables with known values, where possible,
 by replacing occurrences of such variables with their values.
+
+ at sp 1
+ at item --no-static-ground-terms
+ at findex --no-static-ground-terms
+ at findex --static-ground-terms
+Disable the optimization of constructing constant ground terms
+at compile time and storing them as static constants.
+Note that auxiliary data structures created by the compiler
+for purposes such as run time type information
+will still be created as static constants.
 @end table
 
 @node Medium-level (HLDS -> LLDS) optimization options
@@ -5721,16 +5733,7 @@
 low-level intermediate code from our high-level data structure.
 
 @table @code
- at item --no-static-ground-terms
- at findex --no-static-ground-terms
- at findex --static-ground-terms
-Disable the optimization of constructing constant ground terms
-at compile time and storing them as static constants.
-Note that auxiliary data structures created by the compiler
-for purposes such as debugging
-will still be created as static constants.
 
- at sp 1
 @item --no-smart-indexing
 @findex --no-smart-indexing
 @findex --smart-indexing
@@ -5798,12 +5801,6 @@
 @findex --no-simple-neg
 @findex --simple-neg
 Don't generate simplified code for simple negations.
-
- at sp 1
- at item --no-follow-vars
- at findex --follow-vars
- at findex --no-follow-vars
-Don't optimize the assignment of registers in branched goals.
 
 @end table
 
cvs diff: Diffing extras
cvs diff: Diffing extras/aditi
cvs diff: Diffing extras/cgi
cvs diff: Diffing extras/complex_numbers
cvs diff: Diffing extras/complex_numbers/samples
cvs diff: Diffing extras/complex_numbers/tests
cvs diff: Diffing extras/concurrency
cvs diff: Diffing extras/curs
cvs diff: Diffing extras/curs/samples
cvs diff: Diffing extras/curses
cvs diff: Diffing extras/curses/sample
cvs diff: Diffing extras/dynamic_linking
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/mercury_opengl
cvs diff: Diffing extras/graphics/mercury_tcltk
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing extras/graphics/samples/pent
cvs diff: Diffing extras/lazy_evaluation
cvs diff: Diffing extras/lex
cvs diff: Diffing extras/lex/samples
cvs diff: Diffing extras/logged_output
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
cvs diff: Diffing extras/morphine
cvs diff: Diffing extras/morphine/non-regression-tests
cvs diff: Diffing extras/morphine/scripts
cvs diff: Diffing extras/morphine/source
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/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/stream
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing java
cvs diff: Diffing java/library
cvs diff: Diffing java/runtime
cvs diff: Diffing library
cvs diff: Diffing profiler
cvs diff: Diffing robdd
cvs diff: Diffing runtime
cvs diff: Diffing runtime/GETOPT
cvs diff: Diffing runtime/machdeps
cvs diff: Diffing samples
cvs diff: Diffing samples/c_interface
cvs diff: Diffing samples/c_interface/c_calls_mercury
cvs diff: Diffing samples/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/mercury_calls_c
cvs diff: Diffing samples/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/diff
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
cvs diff: Diffing samples/tests
cvs diff: Diffing samples/tests/c_interface
cvs diff: Diffing samples/tests/c_interface/c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/tests/c_interface/mercury_calls_c
cvs diff: Diffing samples/tests/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/tests/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/tests/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/tests/diff
cvs diff: Diffing samples/tests/muz
cvs diff: Diffing samples/tests/rot13
cvs diff: Diffing samples/tests/solutions
cvs diff: Diffing samples/tests/toplevel
cvs diff: Diffing scripts
cvs diff: Diffing tests
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/debugger/declarative
cvs diff: Diffing tests/dppd
cvs diff: Diffing tests/general
cvs diff: Diffing tests/general/accumulator
cvs diff: Diffing tests/general/structure_reuse
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/exceptions
cvs diff: Diffing tests/hard_coded/purity
cvs diff: Diffing tests/hard_coded/sub-modules
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/invalid/purity
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/recompilation
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
cvs diff: Diffing vim
cvs diff: Diffing vim/after
cvs diff: Diffing vim/ftplugin
cvs diff: Diffing vim/syntax
--------------------------------------------------------------------------
mercury-reviews mailing list
post:  mercury-reviews at cs.mu.oz.au
administrative address: owner-mercury-reviews at cs.mu.oz.au
unsubscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: unsubscribe
subscribe:   Address: mercury-reviews-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------



More information about the reviews mailing list