for review: compiler support for Mark's declarative debugger

[Zoltan Somogyi]

For review by Tyson.

I propose to commit this only after the release, but Mark should probably
apply the patch to his workspace now.

Estimated hours taken: 5

Add compiler support for Mark's declarative debugger. The runtime support
will come later. from Mark.

compiler/options.m:
	Add a new option, --trace-decl, that causes the compiler to reserve
	two extra stack slots in every stack frame. The declarative debugger
	will use these slots to store pointers to the proof tree node of the
	current call, and the location in the parent's proof tree node where
	the proof tree node of this call ought to be inserted.

	Since there is no runtime support yet, the option is not yet included
	in the help message.

compiler/trace.m:
	Generalize the code for reserving stack slots for tracing, and
	expand it to conditionall allocate two slots for the declarative
	debugger.

	Add a new type trace_slot_info, and use that instead of maybe(int)
	to describe the stack slots used by the trace system, for passing
	through code_info and code_gen to continuation_info.

compiler/code_info.m:
compiler/code_gen.m:
compiler/continuation_info.m:
	Minor changes (mostly to variable names and comments) to refer
	to trace_slot_info.

compiler/stack_layout.m:
	Include the numbers of the two stack slots used for declarative
	debugging in the procedure's stack layout structure. Actually,
	since these two stack slots are always adjacent, we only store
	the number of the first.

runtime/mercury_stack_layout.h:
	Extend the MR_Stack_Layout_Entry struct to cover the new entry.

doc/user_guide.texi:
	Add documentation of the new option, commented out for now.

Zoltan.

cvs diff: Diffing .
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing bytecode/test
cvs diff: Diffing compiler
Index: compiler/code_gen.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/code_gen.m,v
retrieving revision 1.56
diff -u -u -r1.56 code_gen.m
--- code_gen.m	1998/10/16 06:16:56	1.56
+++ code_gen.m	1998/10/22 07:33:20
@@ -202,7 +202,7 @@
 		% execution tracing.
 	code_info__init(VarSet, Liveness, StackSlots, SaveSuccip, Globals,
 		PredId, ProcId, ProcInfo, InitialInst, FollowVars,
-		ModuleInfo, CellCount0, OutsideResumePoint, MaybeFromFullSlot,
+		ModuleInfo, CellCount0, OutsideResumePoint, TraceSlotInfo,
 		CodeInfo0),
 
 		% Generate code for the procedure.
@@ -235,7 +235,7 @@
 			no, EntryLabel),
 		continuation_info__add_proc_info(proc(PredId, ProcId),
 			EntryLabel, TotalSlots, Detism, MaybeSuccipSlot,
-			MaybeTraceCallLabel, MaybeFromFullSlot,
+			MaybeTraceCallLabel, TraceSlotInfo,
 			LayoutInfo, ContInfo0, ContInfo)
 	;
 		ContInfo = ContInfo0
Index: compiler/code_info.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/code_info.m,v
retrieving revision 1.229
diff -u -u -r1.229 code_info.m
--- code_info.m	1998/10/16 06:16:59	1.229
+++ code_info.m	1998/10/22 07:32:58
@@ -62,11 +62,11 @@
 :- type code_info.
 
 		% Create a new code_info structure. Also return the
-		% outermost resumption point, and the number of stack slot
-		% (if any) that contains the from_full tracing flag.
+		% outermost resumption point, and info about the non-fixed
+		% stack slots used for tracing purposes.
 :- pred code_info__init(varset, set(var), stack_slots, bool, globals,
 	pred_id, proc_id, proc_info, instmap, follow_vars, module_info,
-	int, resume_point_info, maybe(int), code_info).
+	int, resume_point_info, trace_slot_info, code_info).
 :- mode code_info__init(in, in, in, in, in, in, in, in, in, in, in, in,
 	out, out, out) is det.
 
@@ -268,7 +268,7 @@
 
 code_info__init(Varset, Liveness, StackSlots, SaveSuccip, Globals,
 		PredId, ProcId, ProcInfo, Instmap, FollowVars, ModuleInfo,
-		CellCount, ResumePoint, MaybeFromFullSlot, CodeInfo) :-
+		CellCount, ResumePoint, TraceSlotInfo, CodeInfo) :-
 	proc_info_headvars(ProcInfo, HeadVars),
 	proc_info_arg_info(ProcInfo, ArgInfos),
 	proc_info_interface_code_model(ProcInfo, CodeModel),
@@ -320,25 +320,25 @@
 		AvailSlots
 	),
 	code_info__init_maybe_trace_info(Globals, ModuleInfo, ProcInfo,
-		MaybeFailVars, MaybeFromFullSlot, CodeInfo0, CodeInfo1),
+		MaybeFailVars, TraceSlotInfo, CodeInfo0, CodeInfo1),
 	code_info__init_fail_info(CodeModel, MaybeFailVars, ResumePoint,
 		CodeInfo1, CodeInfo).
 
 :- pred code_info__init_maybe_trace_info(globals, module_info, proc_info,
-	maybe(set(var)), maybe(int), code_info, code_info).
+	maybe(set(var)), trace_slot_info, code_info, code_info).
 :- mode code_info__init_maybe_trace_info(in, in, in, out, out, in, out) is det.
 
 code_info__init_maybe_trace_info(Globals, ModuleInfo, ProcInfo,
-		MaybeFailVars, MaybeFromFullSlot) -->
+		MaybeFailVars, TraceSlotInfo) -->
 	{ globals__get_trace_level(Globals, TraceLevel) },
 	( { TraceLevel \= none } ->
-		trace__setup(Globals, MaybeFromFullSlot, TraceInfo),
+		trace__setup(Globals, TraceSlotInfo, TraceInfo),
 		code_info__set_maybe_trace_info(yes(TraceInfo)),
 		{ trace__fail_vars(ModuleInfo, ProcInfo, FailVars) },
 		{ MaybeFailVars = yes(FailVars) }
 	;
 		{ MaybeFailVars = no },
-		{ MaybeFromFullSlot = no }
+		{ TraceSlotInfo = trace_slot_info(no, no) }
 	).
 
 %---------------------------------------------------------------------------%
Index: compiler/continuation_info.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/continuation_info.m,v
retrieving revision 1.15
diff -u -u -r1.15 continuation_info.m
--- continuation_info.m	1998/10/16 06:17:06	1.15
+++ continuation_info.m	1998/10/22 07:15:48
@@ -46,7 +46,7 @@
 
 :- interface.
 
-:- import_module llds, hlds_pred, prog_data, hlds_data.
+:- import_module llds, hlds_pred, prog_data, hlds_data, trace.
 :- import_module set, map, list, std_util, bool.
 
 	%
@@ -72,11 +72,8 @@
 					% with the call event, whose stack
 					% layout says which variables were
 					% live and where on entry.
-			maybe(int),	% If the trace level is shallow,
-					% this contains the number of the
-					% stack slot containing the
-					% value of MR_trace_from_full
-					% at the time of the call.
+			trace_slot_info,% Info about the stack slots used
+					% for tracing.
 			proc_label_layout_info
 					% Info for each internal label,
 					% needed for basic_stack_layouts.
@@ -175,12 +172,14 @@
 	% Add the information for a single proc.
 	%
 	% Takes the pred_proc_id, entry label, the number of stack slots,
-	% the code model for this proc, and the stack slot of the succip
-	% in this proc (if there is one).
+	% the determinism of this proc, the number of the slot containing
+	% the saved succip (if any), the label associated with the call event
+	% (if we are tracing this proc) and info about the tracing slots
+	% of this proc.
 	%
 :- pred continuation_info__add_proc_info(pred_proc_id::in, label::in,
 	int::in, determinism::in, maybe(int)::in, maybe(label)::in,
-	maybe(int)::in, proc_label_layout_info::in, continuation_info::in,
+	trace_slot_info::in, proc_label_layout_info::in, continuation_info::in,
 	continuation_info::out) is det.
 
 	%
@@ -232,13 +231,13 @@
 	%
 continuation_info__add_proc_info(PredProcId, EntryLabel, StackSize,
 		Detism, SuccipLocation, MaybeTraceCallLabel,
-		MaybeFromFullSlot, InternalMap, ContInfo0, ContInfo) :-
+		TraceSlotInfo, InternalMap, ContInfo0, ContInfo) :-
 	( map__contains(ContInfo0, PredProcId) ->
 		error("duplicate continuation_info for proc.")
 	;
 		LayoutInfo = proc_layout_info(EntryLabel, Detism, StackSize,
 			SuccipLocation, MaybeTraceCallLabel,
-			MaybeFromFullSlot, InternalMap),
+			TraceSlotInfo, InternalMap),
 		map__det_insert(ContInfo0, PredProcId, LayoutInfo, ContInfo)
 	).
 
Index: compiler/options.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/options.m,v
retrieving revision 1.246
diff -u -u -r1.246 options.m
--- options.m	1998/10/18 07:11:37	1.246
+++ options.m	1998/10/22 08:23:36
@@ -94,6 +94,7 @@
 		;	trace_return
 		;	trace_redo
 		;	trace_optimized
+		;	trace_decl
 		;	generate_bytecode
 		;	generate_prolog
 		;	prolog_dialect
@@ -383,6 +384,7 @@
 	trace_return		-	bool(yes),
 	trace_redo		-	bool(yes),
 	trace_optimized		-	bool(no),
+	trace_decl		-	bool(no),
 	generate_bytecode	-	bool(no),
 	generate_prolog		-	bool(no),
 	prolog_dialect		-	string("default"),
@@ -718,6 +720,7 @@
 long_option("trace-redo",		trace_redo).
 long_option("trace-optimised",		trace_optimized).
 long_option("trace-optimized",		trace_optimized).
+long_option("trace-declarative",	trace_decl).
 long_option("generate-bytecode",	generate_bytecode).
 long_option("generate-prolog",		generate_prolog).
 long_option("generate-Prolog",		generate_prolog).
@@ -1407,6 +1410,10 @@
 		"\tDo not generate code to trace REDO events.",
 		"--trace-optimized",
 		"\tDo not disable optimizations that can change the trace.",
+% --trace-decl is commented out in the absence of runtime support
+%		"--trace-decl",
+%		"\tMake the generated tracing code include support for an",
+%		"\texperimental declarative debugger.",
 		"--generate-bytecode",
 		"\tOutput a bytecode form of the module for use",
 		"\tby an experimental debugger.",
Index: compiler/stack_layout.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/stack_layout.m,v
retrieving revision 1.19
diff -u -u -r1.19 stack_layout.m
--- stack_layout.m	1998/10/16 06:17:53	1.19
+++ stack_layout.m	1998/10/22 07:50:05
@@ -68,11 +68,15 @@
 % The meanings of the fields in both forms are the same as in procedure labels.
 %
 % If the option trace_stack_layout is set, i.e. if we are doing execution
-% tracing, the table will also include two extra fields:
+% tracing, the table will also include three extra fields:
 %
 %	call trace info		(Word *) - pointer to label stack layout
-%	maybe from full		(Integer) - stack slot of the from_full
-%				flag, if the procedure is shallow traced
+%	maybe from full		(Integer) - number of the stack slot of
+%				the from_full flag, if the procedure is
+%				shallow traced
+%	maybe decl debug	(Integer) - number of the first of two
+%				stack slots used by the declarative debugger,
+%				if --trace-decl is set
 %
 % The first will point to the per-label layout info for the label associated
 % with the call event at the entry to the procedure. The purpose of this
@@ -82,13 +86,19 @@
 % (If trace_stack_layout is not set, this field will be present,
 % but it will be set to NULL.)
 %
-% If the procedure is compiled with deep tracing, the last field will contain
+% If the procedure is compiled with deep tracing, the second field will contain
 % a negative number. If it is compiled with shallow tracing, it will contain
 % the number of the stack slot that holds the flag that says whether this
 % incarnation of the procedure was called from deeply traced code or not.
 % (The determinism of the procedure decides whether the stack slot refers
 % to a stackvar or a framevar.)
 %
+% If --trace-decl is not set, the third field will contain a negative number.
+% If it is set, it will contain the number of the first of two stack slots
+% used by the declarative debugger; the other slot is the next higher numbered
+% one. (The determinism of the procedure decides whether the stack slot refers
+% to a stackvar or a framevar.)
+%
 % If the option basic_stack_layout is set, we generate stack layout tables
 % for some labels internal to the procedure. This table will be stored in the
 % global variable whose name is
@@ -173,7 +183,7 @@
 
 :- implementation.
 
-:- import_module globals, options, continuation_info, llds_out.
+:- import_module globals, options, continuation_info, llds_out, trace.
 :- import_module hlds_data, hlds_pred, base_type_layout, prog_data, prog_out.
 :- import_module assoc_list, bool, string, int, require.
 :- import_module map, std_util, term, set.
@@ -231,10 +241,10 @@
 
 stack_layout__construct_layouts(ProcLayoutInfo) -->
 	{ ProcLayoutInfo = proc_layout_info(EntryLabel, Detism,
-		StackSlots, SuccipLoc, MaybeCallLabel, MaybeFromFullSlot,
+		StackSlots, SuccipLoc, MaybeCallLabel, TraceSlotInfo,
 		InternalMap) },
 	stack_layout__construct_proc_layout(EntryLabel, Detism,
-		StackSlots, SuccipLoc, MaybeCallLabel, MaybeFromFullSlot),
+		StackSlots, SuccipLoc, MaybeCallLabel, TraceSlotInfo),
 	{ map__to_assoc_list(InternalMap, Internals) },
 	list__foldl(stack_layout__construct_internal_layout(EntryLabel),
 		Internals).
@@ -245,10 +255,11 @@
 
 :- pred stack_layout__construct_proc_layout(label::in,
 	determinism::in, int::in, maybe(int)::in, maybe(label)::in,
-	maybe(int)::in, stack_layout_info::in, stack_layout_info::out) is det.
+	trace_slot_info::in, stack_layout_info::in, stack_layout_info::out)
+	is det.
 
 stack_layout__construct_proc_layout(EntryLabel, Detism, StackSlots,
-		MaybeSuccipLoc, MaybeCallLabel, MaybeFromFullSlot) -->
+		MaybeSuccipLoc, MaybeCallLabel, TraceSlotInfo) -->
 	{
 		MaybeSuccipLoc = yes(Location0)
 	->
@@ -318,12 +329,19 @@
 		;
 			error("stack_layout__construct_proc_layout: call label not present")
 		),
+		TraceSlotInfo = trace_slot_info(MaybeFromFullSlot,
+			MaybeDeclSlots),
 		( MaybeFromFullSlot = yes(FromFullSlot) ->
 			FromFullRval = yes(const(int_const(FromFullSlot)))
 		;
 			FromFullRval = yes(const(int_const(-1)))
+		),
+		( MaybeDeclSlots = yes(DeclSlot) ->
+			DeclRval = yes(const(int_const(DeclSlot)))
+		;
+			DeclRval = yes(const(int_const(-1)))
 		),
-		list__append(MaybeRvals1, [CallRval, FromFullRval],
+		list__append(MaybeRvals1, [CallRval, FromFullRval, DeclRval],
 			MaybeRvals)
 	;
 		NoCallRval = yes(const(int_const(0))),
Index: compiler/trace.m
===================================================================
RCS file: /home/mercury1/repository/mercury/compiler/trace.m,v
retrieving revision 1.12
diff -u -u -r1.12 trace.m
--- trace.m	1998/10/16 06:17:59	1.12
+++ trace.m	1998/10/22 06:51:04
@@ -64,6 +64,19 @@
 
 :- type trace_info.
 
+:- type trace_slot_info
+	--->	trace_slot_info(
+			maybe(int),	% If the procedure is shallow traced,
+					% this will be yes(N), where stack
+					% slot N is the slot that holds the
+					% value of the from-full flag at call.
+					% Otherwise, it will be no.
+
+			maybe(int)	% If --trace-decl is set, this will
+					% be yes(M), where stack slots M
+					% and M+1 hold the 
+		).
+
 	% Return the set of input variables whose values should be preserved
 	% until the exit and fail ports. This will be all the input variables,
 	% except those that can be totally clobbered during the evaluation
@@ -76,18 +89,12 @@
 	% If there are N slots, the reserved slots will be 1 through N.
 :- pred trace__reserved_slots(proc_info::in, globals::in, int::out) is det.
 
-	% Reserve the non-fixed stack slots needed for tracing.
-	% The fixed slots for the event number, call number, call depth and
-	% (for trace levels that specify redo events) the stack layout of
-	% the redo event are reserved in live_vars.m; this predicate reserves
-	% only the slots that do not need to be in fixed slots. At the moment
-	% the only such slot is the flag that says whether this call should be
-	% traced, which is required only for shallow tracing.
-	%
-	% The predicate returns the number of this slot if it is used,
-	% and an abstract struct that represents the tracing-specific part
-	% of the code generator state.
-:- pred trace__setup(globals::in, maybe(int)::out, trace_info::out,
+	% Construct and return an abstract struct that represents the
+	% tracing-specific part of the code generator state. Return also
+	% info about the non-fixed slots used by the tracing system,
+	% for eventual use in the constructing the procedure's layout
+	% structure.
+:- pred trace__setup(globals::in, trace_slot_info::out, trace_info::out,
 	code_info::in, code_info::out) is det.
 
 	% Generate code to fill in the reserevd stack slots.
@@ -198,6 +205,26 @@
 		error("length mismatch in trace__fail_vars")
 	).
 
+	% trace__reserved_slots and trace__setup cooperate in the allocation
+	% of stack slots for tracing purposes. The allocation is done in four
+	% stages.
+	%
+	% stage 1:	Allocate the fixed slots, slots 1, 2 and 3, to hold
+	%		the event number of call, the call sequence number
+	%		and the call depth respectively.
+	%
+	% stage 2:	If the procedure is model_non and --trace-redo is set,
+	%		allocate the next available slot (which must be slot 4)
+	%		to hold the address of the redo layout structure.
+	%
+	% stage 3:	If the procedure is shallow traced, allocate the
+	%		next available slot to the saved copy of the
+	%		from-full flag.
+	%
+	% stage 4:	If --trace-decl is given, allocate the next two
+	%		available slots to hold the pointers to the proof tree
+	%		node of the parent and of this call respectively.
+
 trace__reserved_slots(ProcInfo, Globals, ReservedSlots) :-
 	globals__get_trace_level(Globals, TraceLevel),
 	(
@@ -205,28 +232,30 @@
 	->
 		ReservedSlots = 0
 	;
-		globals__lookup_bool_option(Globals, trace_redo, yes),
-		proc_info_interface_code_model(ProcInfo, model_non)
-	->
-		( TraceLevel = deep ->
-			% event#, call#, call depth, redo layout
-			ReservedSlots = 4
+		Fixed = 3, % event#, call#, call depth
+		(
+			globals__lookup_bool_option(Globals, trace_redo, yes),
+			proc_info_interface_code_model(ProcInfo, model_non)
+		->
+			RedoLayout = 1
 		;
-			% event#, call#, call depth, redo layout, from full
-			ReservedSlots = 5
-		)
-	;
+			RedoLayout = 0
+		),
 		( TraceLevel = deep ->
-			% event#, call#, call depth
-			ReservedSlots = 3
+			FromFull = 0
 		;
-			% event#, call#, call depth, from full
-			ReservedSlots = 4
-		)
+			FromFull = 1
+		),
+		globals__lookup_bool_option(Globals, trace_decl, TraceDecl),
+		( TraceDecl = yes ->
+			DeclDebug = 2
+		;
+			DeclDebug = 0
+		),
+		ReservedSlots is Fixed + RedoLayout + FromFull + DeclDebug
 	).
 
-trace__setup(Globals, MaybeFromFullSlot, TraceInfo) -->
-	% These slots were reserved by allocate_stack_slots in live_vars.m.
+trace__setup(Globals, TraceSlotInfo, TraceInfo) -->
 	code_info__get_proc_model(CodeModel),
 	{ globals__lookup_bool_option(Globals, trace_return, TraceReturn) },
 	{ globals__lookup_bool_option(Globals, trace_redo, TraceRedo) },
@@ -235,42 +264,44 @@
 		{ CodeModel = model_non }
 	->
 		code_info__get_next_label(RedoLayoutLabel),
-		{ MaybeRedoLayoutSlot = yes(RedoLayoutLabel) }
+		{ MaybeRedoLayout = yes(RedoLayoutLabel) },
+		{ NextSlotAfterRedoLayout = 5 }
 	;
-		{ MaybeRedoLayoutSlot = no }
+		{ MaybeRedoLayout = no },
+		{ NextSlotAfterRedoLayout = 4 }
 	),
 	{ globals__get_trace_level(Globals, deep) ->
 		TraceType = deep_trace,
+		MaybeFromFullSlot = no,
+		NextSlotAfterFromFull = NextSlotAfterRedoLayout,
 		globals__lookup_bool_option(Globals, trace_internal,
-			TraceInternal),
-		MaybeFromFullSlot = no
+			TraceInternal)
 	;
 		% Trace level must be shallow.
 		%
-		% Debugger code in the runtime is not interested in the
-		% call-from-full flag, so does not have to be in a fixed slot.
-		% Even if we put in a fixed slot, the runtime won't know
-		% whether a procedure has interface or full tracing, and so it
-		% wouldn't know whether the slot was used for this purpose
-		% or not.
+		% Debugger code in the runtime cannot know whether a procedure
+		% has shallow or deep tracing, and therefore whether the
+		% stack frame has a slot holding the from-full flag.
+		% We must therefore tell
+		MaybeFromFullSlot = yes(NextSlotAfterRedoLayout),
 		( CodeModel = model_non ->
-			( TraceRedo = yes ->
-				CallFromFullSlot = framevar(5),
-				MaybeFromFullSlot = yes(4)
-			;
-				CallFromFullSlot = framevar(4),
-				MaybeFromFullSlot = yes(4)
-			)
+			CallFromFullSlot = framevar(NextSlotAfterRedoLayout)
 		;
-			CallFromFullSlot = stackvar(4),
-			MaybeFromFullSlot = yes(4)
+			CallFromFullSlot = stackvar(NextSlotAfterRedoLayout)
 		),
 		TraceType = shallow_trace(CallFromFullSlot),
+		NextSlotAfterFromFull is NextSlotAfterRedoLayout + 1,
 		% Shallow traced procs never generate internal events.
 		TraceInternal = no
 	},
+	{ globals__lookup_bool_option(Globals, trace_decl, yes) ->
+		MaybeDeclSlots = yes(NextSlotAfterFromFull)
+	;
+		MaybeDeclSlots = no
+	},
+	{ TraceSlotInfo = trace_slot_info(MaybeFromFullSlot, MaybeDeclSlots) },
 	{ TraceInfo = trace_info(TraceType, TraceInternal, TraceReturn,
-		MaybeRedoLayoutSlot) }.
+		MaybeRedoLayout) }.
 
 trace__generate_slot_fill_code(TraceInfo, TraceCode) -->
 	code_info__get_proc_model(CodeModel),
cvs diff: Diffing compiler/notes
cvs diff: Diffing doc
Index: doc/user_guide.texi
===================================================================
RCS file: /home/mercury1/repository/mercury/doc/user_guide.texi,v
retrieving revision 1.138
diff -u -u -r1.138 user_guide.texi
--- user_guide.texi	1998/10/16 06:18:20	1.138
+++ user_guide.texi	1998/10/22 08:26:51
@@ -1786,6 +1786,10 @@
 @item --trace-optimized
 Do not disable optimizations that can change the trace.
 
+ at c @item --trace-decl
+ at c Make the generated tracing code include support for an
+ at c experimental declarative debugger.
+
 @item --generate-bytecode
 @c Output a bytecode version of the module
 @c into the @file{@var{module}.bytecode} file,
cvs diff: Diffing extras
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/exceptions
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/odbc
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing library
cvs diff: Diffing lp_solve
cvs diff: Diffing lp_solve/lp_examples
cvs diff: Diffing profiler
cvs diff: Diffing runtime
Index: runtime/mercury_stack_layout.h
===================================================================
RCS file: /home/mercury1/repository/mercury/runtime/mercury_stack_layout.h,v
retrieving revision 1.9
diff -u -u -r1.9 mercury_stack_layout.h
--- mercury_stack_layout.h	1998/10/16 06:18:56	1.9
+++ mercury_stack_layout.h	1998/10/22 07:51:23
@@ -255,6 +255,7 @@
 	struct MR_Stack_Layout_Label_Struct
 				*MR_sle_call_label;
 	int			MR_sle_maybe_from_full;
+	int			MR_sle_maybe_decl_debug;
 } MR_Stack_Layout_Entry;
 
 #define	MR_ENTRY_LAYOUT_HAS_PROC_ID(entry)			\
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 scripts
cvs diff: Diffing tests
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/general
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing trial
cvs diff: Diffing util