mercurylang/mercury
1
0
Fork 0
mirror of https://github.com/Mercury-Language/mercury.git synced 2025-12-18 15:26:31 +00:00
Code Issues Projects Releases Wiki Activity
Files
d69ba1a1f0596e7f740b1a788350b5dcb343c276
mercury/compiler/stack_layout.m
Zoltan Somogyi 53286dd4bf Implement a new compiler option, --exec-trace-tail-rec, that preserves direct 
Estimated hours taken: 30
Branches: main

Implement a new compiler option, --exec-trace-tail-rec, that preserves direct
tail recursion in det and semidet procedures even when debugging is enabled.
This should allow the debugging of programs that previously ran out of stack.

The problem arose because even a directly tail-recursive call had some code
after it: the code for the EXIT event, like this:

	p:
		incr_sp
		fill in the usual debug slots
		CALL EVENT
		...
		/* tail call */
		move arguments to registers as usual
		call p, return to p_ret
	p_ret:
		/* code to move output arguments to right registers is empty */
		EXIT EVENT
		decr_sp
		return

If the new option is enabled, the compiler will now generate code like this:

	p:
		incr_sp
		fill in the usual debug slots
		fill in new "stack frame reuse count" slot with 0
		CALL EVENT
	p_1:
		...
		/* tail call */
		move arguments to registers as usual
		update the usual debug slots
		increment the "stack frame reuse count" slot
		TAILCALL EVENT
		goto p_1

The new TAIL event takes place in the caller's stack frame, so that the local
variables of the caller are available. This includes the arguments of the
recursive call (though if they are unnamed variables, the debugger will not
show them). The TAIL event serves as a replacement for the CALL event
of the recursive invocation.

compiler/options.m:
	Add the new option.

compiler/handle_options.m:
	Handle an implication of the new option: the declarative debugger
	does not (yet) understand TAIL events.

compiler/mark_tail_calls.m:
	New module to mark directly tail recursive calls and the procedures
	containing them as such.

compiler/hlds.m:
compiler/notes/compiler_design.html:
	Mention the new module.

compiler/mercury_compile.m:
	Invoke the new module when the new option asks us to.

compiler/hlds_goal.m:
	Add the feature used to mark tail recursive calls for the debugger.
	Rename an existing feature with a similar but not identical purpose
	to avoid possible confusion.

compiler/hlds_pred.m:
	Add a field to proc_infos that says whether the procedure contains
	tail recursive calls.

	Minor style improvements.

compiler/passes_aux.m:
	Minor change to accommodate the needs of the new module.

compiler/code_info.m:
	Transmit the information from mark_tail_calls to the code generator.

compiler/call_gen.m:
	Implement the new option.

compiler/trace_gen.m:
	Reserve the extra slot needed for the new option.

	Switch to state variable notation in the code that does the slot
	allocation, since this is less error-prone than the previous approach.

compiler/layout.m:
compiler/layout_out.m:
compiler/stack_layout.m:
	Remember what stack slot holds the stack frame reuse counter,
	for transmission to the runtime system.

compiler/proc_gen.m:
	Add the new label needed for tail recursion.

	Put the arguments of some procedures into a more logical order.

compiler/deep_profiling.m:
compiler/deforest.m:
compiler/saved_vars.m:
compiler/table_gen.m:
	Conform to the changes above.

compiler/trace_params.m:
mdbcomp/prim_data.m:
runtime/mercury_trace_base.[ch]:
	Add the new event type.

	Convert mercury_trace_base.h to four-space indentation.

runtime/mercury_stack_layout.h:
	Add a field to the execution trace information we have for each
	procedure that gives the number of the stack slot (if any) that holds
	the stack frame reuse counter. Add a macro to get the value in the
	counter.

	Convert this header file to four-space indentation.

runtime/mercury_stack_trace.[ch]:
	When walking the stack, we now have to be prepared to encounter stack
	frames that have been reused. Modify the algorithms in this module
	accordingly, and modify the interfaces of the exported functions
	to allow the functions' callers to behave accordingly as well.

	Group the information we gather about stack frame for printing into
	one structure, and document it.

	Convert the header to four-space indentation.

library/exception.m:
mdbcomp/trace_counts.m:
	Conform to the changes above.

	In trace_counts.m, fix an apparent cut-and-paste error (that hasn't
	caused any test case failures yet).

trace/mercury_trace.c:
	Modify the implementation of the "next" and "finish" commands
	to accommodate the possibility that the procedure at the selected
	depth may have had its stack frame reused. In such cases

tests/debugger/tailrec1.{m,inp,exp,data}:
	A new test case to check the handling of tail recursive procedures.
2008-11-25 07:46:57 +00:00

2004 lines
79 KiB
Mathematica
Raw Blame History

%---------------------------------------------------------------------------%
% vim: ft=mercury ts=4 sw=4 et
%---------------------------------------------------------------------------%
% Copyright (C) 1997-2008 University of Melbourne.
% This file may only be copied under the terms of the GNU General
% Public License - see the file COPYING in the Mercury distribution.
%---------------------------------------------------------------------------%
%
% File: stack_layout.m.
% Main authors: trd, zs.
%
% This module generates label, procedure, module and closure layout structures
% for code in the current module for the LLDS backend. Layout structures are
% used by the parts of the runtime system that need to look at the stacks
% (and sometimes the registers) and make sense of their contents. The parts
% of the runtime system that need to do this include exception handling,
% the debugger, and (eventually) the accurate garbage collector.
%
% The tables we generate are mostly of (Mercury) types defined in layout.m,
% which are turned into C code (global variable declarations and
% initializations) by layout_out.m.
%
% The C types of the structures we generate are defined and documented in
% runtime/mercury_stack_layout.h.
%
% TODO: Handle the parent_sp register and parent stack variables.
%
%---------------------------------------------------------------------------%
:- module ll_backend.stack_layout.
:- interface.
:- import_module hlds.hlds_module.
:- import_module hlds.hlds_pred.
:- import_module ll_backend.continuation_info.
:- import_module ll_backend.global_data.
:- import_module ll_backend.layout.
:- import_module ll_backend.llds.
:- import_module mdbcomp.prim_data.
:- import_module parse_tree.prog_data.
:- import_module assoc_list.
:- import_module list.
:- import_module map.
%---------------------------------------------------------------------------%
% Process all the continuation information stored in the HLDS,
% converting it into LLDS data structures.
%
:- pred generate_llds(module_info::in, global_data::in, global_data::out,
list(layout_data)::out, map(label, data_addr)::out) is det.
:- pred construct_closure_layout(proc_label::in, int::in,
closure_layout_info::in, proc_label::in, module_name::in,
string::in, int::in, pred_origin::in, string::in,
static_cell_info::in, static_cell_info::out,
assoc_list(rval, llds_type)::out, layout_data::out) is det.
:- pred convert_table_arg_info(table_arg_infos::in, int::out,
rval::out, rval::out, static_cell_info::in, static_cell_info::out) is det.
% Construct a representation of a variable location as a 32-bit
% integer.
%
:- pred represent_locn_as_int(layout_locn::in, int::out) is det.
% Construct a representation of the interface determinism of a procedure.
%
:- pred represent_determinism_rval(determinism::in, rval::out) is det.
:- type stack_layout_info.
:- pred lookup_string_in_table(string::in, int::out,
stack_layout_info::in, stack_layout_info::out) is det.
%---------------------------------------------------------------------------%
%---------------------------------------------------------------------------%
:- implementation.
:- import_module backend_libs.proc_label.
:- import_module backend_libs.rtti.
:- import_module check_hlds.type_util.
:- import_module hlds.code_model.
:- import_module hlds.goal_util.
:- import_module hlds.hlds_goal.
:- import_module hlds.hlds_pred.
:- import_module hlds.hlds_rtti.
:- import_module hlds.instmap.
:- import_module libs.compiler_util.
:- import_module libs.globals.
:- import_module libs.options.
:- import_module libs.trace_params.
:- import_module ll_backend.layout.
:- import_module ll_backend.layout_out.
:- import_module ll_backend.ll_pseudo_type_info.
:- import_module ll_backend.prog_rep.
:- import_module ll_backend.trace_gen.
:- import_module mdbcomp.program_representation.
:- import_module parse_tree.prog_event.
:- import_module bool.
:- import_module counter.
:- import_module int.
:- import_module map.
:- import_module maybe.
:- import_module pair.
:- import_module set.
:- import_module string.
:- import_module svmap.
:- import_module term.
:- import_module varset.
%---------------------------------------------------------------------------%
generate_llds(ModuleInfo, !GlobalData, Layouts, LayoutLabels) :-
global_data_get_all_proc_layouts(!.GlobalData, ProcLayoutList),
module_info_get_globals(ModuleInfo, Globals),
globals.lookup_bool_option(Globals, agc_stack_layout, AgcLayout),
globals.lookup_bool_option(Globals, trace_stack_layout, TraceLayout),
globals.lookup_bool_option(Globals, procid_stack_layout, ProcIdLayout),
globals.lookup_bool_option(Globals, profile_deep, DeepProfiling),
globals.lookup_bool_option(Globals, static_code_addresses, StaticCodeAddr),
globals.lookup_bool_option(Globals, unboxed_float, OptUnboxedFloat),
(
OptUnboxedFloat = yes,
UnboxedFloat = have_unboxed_floats
;
OptUnboxedFloat = no,
UnboxedFloat = do_not_have_unboxed_floats
),
globals.get_trace_level(Globals, TraceLevel),
globals.get_trace_suppress(Globals, TraceSuppress),
map.init(LayoutLabels0),
map.init(StringMap0),
map.init(LabelTables0),
StringTable0 = string_table(StringMap0, [], 0),
global_data_get_static_cell_info(!.GlobalData, StaticCellInfo0),
counter.init(1, LabelCounter0),
LayoutInfo0 = stack_layout_info(ModuleInfo,
AgcLayout, TraceLayout, ProcIdLayout, StaticCodeAddr, UnboxedFloat,
LabelCounter0, [], [], [], LayoutLabels0, [],
StringTable0, LabelTables0, StaticCellInfo0, no),
lookup_string_in_table("", _, LayoutInfo0, LayoutInfo1),
lookup_string_in_table("<too many variables>", _,
LayoutInfo1, LayoutInfo2),
list.foldl(construct_layouts(DeepProfiling), ProcLayoutList,
LayoutInfo2, LayoutInfo),
LabelsCounter = LayoutInfo ^ label_counter,
counter.allocate(NumLabels, LabelsCounter, _),
TableIoDecls = LayoutInfo ^ table_infos,
ProcLayouts = LayoutInfo ^ proc_layouts,
InternalLayouts = LayoutInfo ^ internal_layouts,
LayoutLabels = LayoutInfo ^ label_set,
ProcLayoutNames = LayoutInfo ^ proc_layout_name_list,
StringTable = LayoutInfo ^ string_table,
LabelTables = LayoutInfo ^ label_tables,
StaticCellInfo1 = LayoutInfo ^ static_cell_info,
StringTable = string_table(_, RevStringList, StringOffset),
list.reverse(RevStringList, StringList),
ConcatStrings = string_with_0s(StringList),
list.condense([TableIoDecls, ProcLayouts, InternalLayouts], Layouts0),
(
TraceLayout = yes,
module_info_get_name(ModuleInfo, ModuleName),
globals.lookup_bool_option(Globals, rtti_line_numbers, LineNumbers),
(
LineNumbers = yes,
EffLabelTables = LabelTables
;
LineNumbers = no,
map.init(EffLabelTables)
),
format_label_tables(EffLabelTables, SourceFileLayouts),
SuppressedEvents = encode_suppressed_events(TraceSuppress),
HasUserEvent = LayoutInfo ^ has_user_event,
(
HasUserEvent = no,
MaybeEventSet = no,
StaticCellInfo = StaticCellInfo1
;
HasUserEvent = yes,
module_info_get_event_set(ModuleInfo, EventSet),
EventSetData = derive_event_set_data(EventSet),
list.foldl2(build_event_arg_type_info_map,
EventSetData ^ event_set_data_specs,
map.init, EventArgTypeInfoMap,
StaticCellInfo1, StaticCellInfo),
EventSetLayoutData = event_set_layout_data(EventSetData,
EventArgTypeInfoMap),
MaybeEventSet = yes(EventSetLayoutData)
),
ModuleCommonLayout = module_layout_common_data(ModuleName,
StringOffset, ConcatStrings),
ModuleCommonLayoutName = module_common_layout(ModuleName),
ModuleLayout = module_layout_data(ModuleName,
ModuleCommonLayoutName, ProcLayoutNames, SourceFileLayouts,
TraceLevel, SuppressedEvents, NumLabels, MaybeEventSet),
Layouts = [ModuleCommonLayout, ModuleLayout | Layouts0]
;
TraceLayout = no,
DeepProfiling = yes,
module_info_get_name(ModuleInfo, ModuleName),
ModuleCommonLayout = module_layout_common_data(ModuleName,
StringOffset, ConcatStrings),
Layouts = [ModuleCommonLayout | Layouts0],
StaticCellInfo = StaticCellInfo1
;
TraceLayout = no,
DeepProfiling = no,
Layouts = Layouts0,
StaticCellInfo = StaticCellInfo1
),
global_data_set_static_cell_info(StaticCellInfo, !GlobalData).
:- pred valid_proc_layout(proc_layout_info::in) is semidet.
valid_proc_layout(ProcLayoutInfo) :-
EntryLabel = ProcLayoutInfo ^ pli_entry_label,
ProcLabel = get_proc_label(EntryLabel),
(
ProcLabel = ordinary_proc_label(_, _, DeclModule, Name, Arity, _),
\+ no_type_info_builtin(DeclModule, Name, Arity)
;
ProcLabel = special_proc_label(_, _, _, _, _, _)
).
:- pred build_event_arg_type_info_map(event_spec::in,
map(int, rval)::in, map(int, rval)::out,
static_cell_info::in, static_cell_info::out) is det.
build_event_arg_type_info_map(EventSpec, !EventArgTypeInfoMap,
!StaticCellInfo) :-
EventNumber = EventSpec ^ event_spec_num,
Attrs = EventSpec ^ event_spec_attrs,
list.map_foldl(build_event_arg_type_info, Attrs, RvalsAndTypes,
!StaticCellInfo),
add_scalar_static_cell(RvalsAndTypes, TypesDataAddr, !StaticCellInfo),
Rval = const(llconst_data_addr(TypesDataAddr, no)),
svmap.det_insert(EventNumber, Rval, !EventArgTypeInfoMap).
:- pred build_event_arg_type_info(event_attribute::in,
pair(rval, llds_type)::out,
static_cell_info::in, static_cell_info::out) is det.
build_event_arg_type_info(Attr, TypeRvalAndType, !StaticCellInfo) :-
Type = Attr ^ attr_type,
ExistQTvars = [],
NumUnivQTvars = -1,
ll_pseudo_type_info.construct_typed_llds_pseudo_type_info(Type,
NumUnivQTvars, ExistQTvars, !StaticCellInfo, TypeRval, TypeRvalType),
TypeRvalAndType = TypeRval - TypeRvalType.
%---------------------------------------------------------------------------%
:- pred format_label_tables(map(string, label_table)::in,
list(file_layout_data)::out) is det.
format_label_tables(LabelTableMap, SourceFileLayouts) :-
map.to_assoc_list(LabelTableMap, LabelTableList),
list.map(format_label_table, LabelTableList, SourceFileLayouts).
:- pred format_label_table(pair(string, label_table)::in,
file_layout_data::out) is det.
format_label_table(FileName - LineNoMap,
file_layout_data(FileName, FilteredList)) :-
% This step should produce a list ordered on line numbers.
map.to_assoc_list(LineNoMap, LineNoList),
% And this step should preserve that order.
flatten_label_table(LineNoList, [], FlatLineNoList),
Filter = (pred(LineNoInfo::in, FilteredLineNoInfo::out) is det :-
LineNoInfo = LineNo - (Label - _IsReturn),
FilteredLineNoInfo = LineNo - Label
),
list.map(Filter, FlatLineNoList, FilteredList).
:- pred flatten_label_table(assoc_list(int, list(line_no_info))::in,
assoc_list(int, line_no_info)::in,
assoc_list(int, line_no_info)::out) is det.
flatten_label_table([], RevList, List) :-
list.reverse(RevList, List).
flatten_label_table([LineNo - LinesInfos | Lines], RevList0, List) :-
list.foldl(add_line_no(LineNo), LinesInfos, RevList0, RevList1),
flatten_label_table(Lines, RevList1, List).
:- pred add_line_no(int::in, line_no_info::in,
assoc_list(int, line_no_info)::in,
assoc_list(int, line_no_info)::out) is det.
add_line_no(LineNo, LineInfo, RevList0, RevList) :-
RevList = [LineNo - LineInfo | RevList0].
%---------------------------------------------------------------------------%
% Construct the layouts that concern a single procedure: the procedure
% layout and the layouts of the labels inside that procedure. Also update
% the module-wide label table with the labels defined in this procedure.
%
:- pred construct_layouts(bool::in, proc_layout_info::in,
stack_layout_info::in, stack_layout_info::out) is det.
construct_layouts(DeepProfiling, ProcLayoutInfo, !Info) :-
ProcLayoutInfo = proc_layout_info(RttiProcLabel,
EntryLabel,
_Detism,
_StackSlots,
_SuccipLoc,
_EvalMethod,
_EffTraceLevel,
_MaybeCallLabel,
_MaxTraceReg,
HeadVars,
_ArgModes,
Goal,
_NeedGoalRep,
_InstMap,
_TraceSlotInfo,
ForceProcIdLayout,
VarSet,
_VarTypes,
InternalMap,
MaybeTableIoDecl,
_NeedsAllNames,
_MaybeDeepProfInfo),
map.to_assoc_list(InternalMap, Internals),
compute_var_number_map(HeadVars, VarSet, Internals, Goal, VarNumMap),
ProcLabel = get_proc_label(EntryLabel),
get_procid_stack_layout(!.Info, ProcIdLayout0),
bool.or(ProcIdLayout0, ForceProcIdLayout, ProcIdLayout),
(
( ProcIdLayout = yes
; MaybeTableIoDecl = yes(_)
)
->
Kind = proc_layout_proc_id(proc_label_user_or_uci(ProcLabel))
;
Kind = proc_layout_traversal
),
ProcLayoutName = proc_layout(RttiProcLabel, Kind),
(
( !.Info ^ agc_stack_layout = yes
; !.Info ^ trace_stack_layout = yes
),
valid_proc_layout(ProcLayoutInfo)
->
list.map_foldl(
construct_internal_layout(ProcLabel, ProcLayoutName, VarNumMap),
Internals, InternalLabelInfos, !Info)
;
InternalLabelInfos = []
),
get_label_tables(!.Info, LabelTables0),
list.foldl(update_label_table, InternalLabelInfos,
LabelTables0, LabelTables),
set_label_tables(LabelTables, !Info),
construct_proc_layout(ProcLayoutInfo, InternalLabelInfos, Kind, VarNumMap,
DeepProfiling, !Info).
%---------------------------------------------------------------------------%
:- type internal_label_info
---> internal_label_info(
containing_proc :: proc_label,
label_num_in_proc :: int,
maybe_has_var_info :: label_vars,
internal_layout_info :: internal_layout_info
).
% Add the given label layout to the module-wide label tables.
%
:- pred update_label_table(internal_label_info::in,
map(string, label_table)::in, map(string, label_table)::out) is det.
update_label_table(InternalLabelInfo, !LabelTables) :-
InternalLabelInfo = internal_label_info(ProcLabel, LabelNum, LabelVars,
InternalInfo),
InternalInfo = internal_layout_info(Port, _, Return),
(
Return = yes(return_layout_info(TargetsContexts, _)),
find_valid_return_context(TargetsContexts, Target, Context, _GoalPath)
->
( Target = code_label(TargetLabel) ->
IsReturn = known_callee(TargetLabel)
;
IsReturn = unknown_callee
),
update_label_table_2(ProcLabel, LabelNum, LabelVars, Context,
IsReturn, !LabelTables)
;
Port = yes(trace_port_layout_info(Context, _, _, _, _, _)),
context_is_valid(Context)
->
update_label_table_2(ProcLabel, LabelNum, LabelVars, Context,
not_a_return, !LabelTables)
;
true
).
:- pred update_label_table_2(proc_label::in, int::in,
label_vars::in, context::in, is_label_return::in,
map(string, label_table)::in, map(string, label_table)::out) is det.
update_label_table_2(ProcLabel, LabelNum, LabelVars, Context,
IsReturn, !LabelTables) :-
term.context_file(Context, File),
term.context_line(Context, Line),
( map.search(!.LabelTables, File, LabelTable0) ->
LabelLayout = label_layout(ProcLabel, LabelNum, LabelVars),
( map.search(LabelTable0, Line, LineInfo0) ->
LineInfo = [LabelLayout - IsReturn | LineInfo0],
map.det_update(LabelTable0, Line, LineInfo, LabelTable),
svmap.det_update(File, LabelTable, !LabelTables)
;
LineInfo = [LabelLayout - IsReturn],
map.det_insert(LabelTable0, Line, LineInfo, LabelTable),
svmap.det_update(File, LabelTable, !LabelTables)
)
; context_is_valid(Context) ->
map.init(LabelTable0),
LabelLayout = label_layout(ProcLabel, LabelNum, LabelVars),
LineInfo = [LabelLayout - IsReturn],
map.det_insert(LabelTable0, Line, LineInfo, LabelTable),
svmap.det_insert(File, LabelTable, !LabelTables)
;
% We don't have a valid context for this label,
% so we don't enter it into any tables.
true
).
:- pred find_valid_return_context(
assoc_list(code_addr, pair(prog_context, goal_path))::in,
code_addr::out, prog_context::out, goal_path::out) is semidet.
find_valid_return_context([TargetContext | TargetContexts],
ValidTarget, ValidContext, ValidGoalPath) :-
TargetContext = Target - (Context - GoalPath),
( context_is_valid(Context) ->
ValidTarget = Target,
ValidContext = Context,
ValidGoalPath = GoalPath
;
find_valid_return_context(TargetContexts, ValidTarget, ValidContext,
ValidGoalPath)
).
:- pred context_is_valid(prog_context::in) is semidet.
context_is_valid(Context) :-
term.context_file(Context, File),
term.context_line(Context, Line),
File \= "",
Line > 0.
%---------------------------------------------------------------------------%
:- pred construct_proc_traversal(label::in, determinism::in,
int::in, maybe(int)::in, proc_layout_stack_traversal::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_proc_traversal(EntryLabel, Detism, NumStackSlots,
MaybeSuccipLoc, Traversal, !Info) :-
(
MaybeSuccipLoc = yes(Location),
( determinism_components(Detism, _, at_most_many) ->
SuccipLval = framevar(Location)
;
SuccipLval = stackvar(Location)
),
represent_locn_as_int(locn_direct(SuccipLval), SuccipInt),
MaybeSuccipInt = yes(SuccipInt)
;
MaybeSuccipLoc = no,
% Use a dummy location if there is no succip slot on the stack.
%
% This case can arise in two circumstances. First, procedures that
% use the nondet stack have a special slot for the succip, so the
% succip is not stored in a general purpose slot. Second, procedures
% that use the det stack but which do not call other procedures
% do not save the succip on the stack.
%
% The tracing system does not care about the location of the saved
% succip. The accurate garbage collector does. It should know from
% the determinism that the procedure uses the nondet stack, which
% takes care of the first possibility above. Procedures that do not
% call other procedures do not establish resumption points and thus
% agc is not interested in them. As far as stack dumps go, calling
% error counts as a call, so any procedure that may call error
% (directly or indirectly) will have its saved succip location
% recorded, so the stack dump will work.
%
% Future uses of stack layouts will have to have similar constraints.
MaybeSuccipInt = no
),
get_static_code_addresses(!.Info, StaticCodeAddr),
(
StaticCodeAddr = yes,
MaybeEntryLabel = yes(EntryLabel)
;
StaticCodeAddr = no,
MaybeEntryLabel = no
),
Traversal = proc_layout_stack_traversal(MaybeEntryLabel,
MaybeSuccipInt, NumStackSlots, Detism).
% Construct a procedure-specific layout.
%
:- pred construct_proc_layout(proc_layout_info::in,
list(internal_label_info)::in, proc_layout_kind::in, var_num_map::in,
bool::in, stack_layout_info::in, stack_layout_info::out) is det.
construct_proc_layout(ProcLayoutInfo, InternalLabelInfos, Kind, VarNumMap,
DeepProfiling, !Info) :-
ProcLayoutInfo = proc_layout_info(RttiProcLabel,
EntryLabel,
Detism,
StackSlots,
SuccipLoc,
EvalMethod,
EffTraceLevel,
MaybeCallLabel,
MaxTraceReg,
HeadVars,
ArgModes,
Goal,
NeedGoalRep,
InstMap,
TraceSlotInfo,
_ForceProcIdLayout,
VarSet,
VarTypes,
InternalMap,
MaybeTableInfo,
NeedsAllNames,
MaybeProcStatic),
construct_proc_traversal(EntryLabel, Detism, StackSlots,
SuccipLoc, Traversal, !Info),
(
Kind = proc_layout_traversal,
More = no_proc_id_and_more
;
Kind = proc_layout_proc_id(_),
get_trace_stack_layout(!.Info, TraceStackLayout),
(
TraceStackLayout = yes,
not map.is_empty(InternalMap),
valid_proc_layout(ProcLayoutInfo)
->
construct_trace_layout(RttiProcLabel, EvalMethod, EffTraceLevel,
MaybeCallLabel, MaxTraceReg, HeadVars, ArgModes, TraceSlotInfo,
VarSet, VarTypes, MaybeTableInfo, NeedsAllNames, VarNumMap,
InternalLabelInfos, ExecTrace, !Info),
MaybeExecTrace = yes(ExecTrace)
;
MaybeExecTrace = no
),
ModuleInfo = !.Info ^ module_info,
(
( NeedGoalRep = trace_needs_body_rep
; DeepProfiling = yes
)
->
(
DeepProfiling = yes,
IncludeVarTable = include_variable_table
;
DeepProfiling = no,
IncludeVarTable = do_not_include_variable_table
),
% When the proc static is availiable (used with deep profiling) use
% the version of the procedure saved before the deep profiling
% transformation as the program representation.
(
MaybeProcStatic = yes(ProcStatic),
DeepOriginalBody = ProcStatic ^ deep_original_body,
DeepOriginalBody = deep_original_body(BytecodeBody,
BytecodeHeadVars, BytecodeInstMap, BytecodeVarTypes,
BytecodeDetism),
some [!VarNumMap, !Counter] (
!:VarNumMap = map.init,
!:Counter = counter.init(1),
goal_util.goal_vars(BytecodeBody, BodyVarSet),
set.to_sorted_list(BodyVarSet, BodyVars),
list.foldl2(add_var_to_var_number_map(VarSet),
BodyVars, !VarNumMap, !Counter),
list.foldl2(add_var_to_var_number_map(VarSet),
BytecodeHeadVars, !VarNumMap, !.Counter, _),
BytecodeVarNumMap = !.VarNumMap
)
;
MaybeProcStatic = no,
BytecodeHeadVars = HeadVars,
BytecodeBody = Goal,
BytecodeInstMap = InstMap,
BytecodeVarTypes = VarTypes,
BytecodeDetism = Detism,
BytecodeVarNumMap = VarNumMap
),
represent_proc_as_bytecodes(BytecodeHeadVars, BytecodeBody,
BytecodeInstMap, BytecodeVarTypes, BytecodeVarNumMap,
ModuleInfo, IncludeVarTable, BytecodeDetism, !Info, ProcBytes)
;
ProcBytes = []
),
module_info_get_name(ModuleInfo, ModuleName),
ModuleCommonLayout = module_common_layout(ModuleName),
More = proc_id_and_more(MaybeProcStatic, MaybeExecTrace,
ProcBytes, ModuleCommonLayout)
),
ProcLayout = proc_layout_data(RttiProcLabel, Traversal, More),
LayoutName = proc_layout(RttiProcLabel, Kind),
add_proc_layout_data(ProcLayout, LayoutName, EntryLabel, !Info),
(
MaybeTableInfo = no
;
MaybeTableInfo = yes(TableInfo),
get_layout_static_cell_info(!.Info, StaticCellInfo0),
make_table_data(RttiProcLabel, Kind, TableInfo, MaybeTableData,
StaticCellInfo0, StaticCellInfo),
set_layout_static_cell_info(StaticCellInfo, !Info),
add_table_data(MaybeTableData, !Info)
).
:- pred construct_trace_layout(rtti_proc_label::in,
eval_method::in, trace_level::in, maybe(label)::in, int::in,
list(prog_var)::in, list(mer_mode)::in,
trace_slot_info::in, prog_varset::in, vartypes::in,
maybe(proc_layout_table_info)::in, bool::in, var_num_map::in,
list(internal_label_info)::in, proc_layout_exec_trace::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_trace_layout(RttiProcLabel, EvalMethod, EffTraceLevel,
MaybeCallLabel, MaxTraceReg, HeadVars, ArgModes, TraceSlotInfo,
_VarSet, VarTypes, MaybeTableInfo, NeedsAllNames, VarNumMap,
InternalLabelInfos, ExecTrace, !Info) :-
collect_event_data_addrs(InternalLabelInfos,
[], RevInterfaceEventDataAddrs, [], RevInternalEventDataAddrs),
list.reverse(RevInterfaceEventDataAddrs, InterfaceEventDataAddrs),
list.reverse(RevInternalEventDataAddrs, InternalEventDataAddrs),
EventDataAddrs = InterfaceEventDataAddrs ++ InternalEventDataAddrs,
construct_var_name_vector(VarNumMap,
NeedsAllNames, MaxVarNum, VarNameVector, !Info),
list.map(convert_var_to_int(VarNumMap), HeadVars, HeadVarNumVector),
TraceSlotInfo = trace_slot_info(MaybeFromFullSlot, MaybeIoSeqSlot,
MaybeTrailSlots, MaybeMaxfrSlot, MaybeCallTableSlot, MaybeTailRecSlot),
ModuleInfo = !.Info ^ module_info,
(
MaybeCallLabel = yes(CallLabel),
% The label associated with an event must have variable info.
(
CallLabel = internal_label(CallLabelNum, CallProcLabel)
;
CallLabel = entry_label(_, _),
unexpected(this_file,
"construct_trace_layout: entry call label")
),
CallLabelDetails = label_layout_details(CallProcLabel, CallLabelNum,
label_has_var_info),
MaybeCallLabelDetails = yes(CallLabelDetails)
;
MaybeCallLabel = no,
MaybeCallLabelDetails = no
),
(
MaybeTableInfo = no,
MaybeTableDataAddr = no
;
MaybeTableInfo = yes(TableInfo),
(
TableInfo = proc_table_io_decl(_),
MaybeTableDataAddr = yes(layout_addr(table_io_decl(RttiProcLabel)))
;
TableInfo = proc_table_struct(_),
module_info_get_name(ModuleInfo, ModuleName),
ProcLabel = make_proc_label_from_rtti(RttiProcLabel),
MaybeTableDataAddr = yes(data_addr(ModuleName,
proc_tabling_ref(ProcLabel, tabling_info)))
)
),
encode_exec_trace_flags(ModuleInfo, HeadVars, ArgModes, VarTypes,
0, Flags),
ExecTrace = proc_layout_exec_trace(MaybeCallLabelDetails,
EventDataAddrs, MaybeTableDataAddr, HeadVarNumVector, VarNameVector,
MaxVarNum, MaxTraceReg, MaybeFromFullSlot, MaybeIoSeqSlot,
MaybeTrailSlots, MaybeMaxfrSlot, EvalMethod,
MaybeCallTableSlot, MaybeTailRecSlot, EffTraceLevel, Flags).
:- pred collect_event_data_addrs(list(internal_label_info)::in,
list(data_addr)::in, list(data_addr)::out,
list(data_addr)::in, list(data_addr)::out) is det.
collect_event_data_addrs([], !RevInterfaces, !RevInternals).
collect_event_data_addrs([Info | Infos], !RevInterfaces, !RevInternals) :-
Info = internal_label_info(ProcLabel, LabelNum, LabelVars, InternalInfo),
InternalInfo = internal_layout_info(MaybePortInfo, _, _),
(
MaybePortInfo = no
;
MaybePortInfo = yes(PortInfo),
Port = PortInfo ^ port_type,
(
( Port = port_call
; Port = port_exit
; Port = port_redo
; Port = port_fail
; Port = port_tailrec_call
),
LayoutName = label_layout(ProcLabel, LabelNum, LabelVars),
DataAddr = layout_addr(LayoutName),
!:RevInterfaces = [DataAddr | !.RevInterfaces]
;
( Port = port_ite_cond
; Port = port_ite_then
; Port = port_ite_else
; Port = port_neg_enter
; Port = port_neg_success
; Port = port_neg_failure
; Port = port_disj_first
; Port = port_disj_later
; Port = port_switch
; Port = port_nondet_foreign_proc_first
; Port = port_nondet_foreign_proc_later
; Port = port_user
),
LayoutName = label_layout(ProcLabel, LabelNum, LabelVars),
DataAddr = layout_addr(LayoutName),
!:RevInternals = [DataAddr | !.RevInternals]
;
Port = port_exception
% This port is attached to call sites, so there is no event here.
)
),
collect_event_data_addrs(Infos, !RevInterfaces, !RevInternals).
:- pred encode_exec_trace_flags(module_info::in, list(prog_var)::in,
list(mer_mode)::in, vartypes::in, int::in, int::out) is det.
encode_exec_trace_flags(ModuleInfo, HeadVars, ArgModes, VarTypes, !Flags) :-
(
proc_info_has_io_state_pair_from_details(ModuleInfo, HeadVars,
ArgModes, VarTypes, _, _)
->
!:Flags = !.Flags + 1
;
true
).
:- pred construct_var_name_vector(var_num_map::in,
bool::in, int::out, list(int)::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_var_name_vector(VarNumMap, NeedsAllNames, MaxVarNum, Offsets,
!Info) :-
map.values(VarNumMap, VarNames0),
(
NeedsAllNames = yes,
VarNames = VarNames0
;
NeedsAllNames = no,
list.filter(var_has_name, VarNames0, VarNames)
),
list.sort(VarNames, SortedVarNames),
( SortedVarNames = [FirstVarNum - _ | _] ->
MaxVarNum0 = FirstVarNum,
construct_var_name_rvals(SortedVarNames, 1, MaxVarNum0, MaxVarNum,
Offsets, !Info)
;
% Since variable numbers start at 1, MaxVarNum = 0 implies
% an empty array.
MaxVarNum = 0,
Offsets = []
).
:- pred var_has_name(pair(int, string)::in) is semidet.
var_has_name(_VarNum - VarName) :-
VarName \= "".
:- pred construct_var_name_rvals(assoc_list(int, string)::in,
int::in, int::in, int::out, list(int)::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_var_name_rvals([], _CurNum, MaxNum, MaxNum, [], !Info).
construct_var_name_rvals([Var - Name | VarNamesTail], CurNum,
!MaxNum, [Offset | OffsetsTail], !Info) :-
( Var = CurNum ->
lookup_string_in_table(Name, Offset, !Info),
!:MaxNum = Var,
VarNames = VarNamesTail
;
Offset = 0,
VarNames = [Var - Name | VarNamesTail]
),
construct_var_name_rvals(VarNames, CurNum + 1,
!MaxNum, OffsetsTail, !Info).
%---------------------------------------------------------------------------%
:- pred compute_var_number_map(list(prog_var)::in, prog_varset::in,
assoc_list(int, internal_layout_info)::in, hlds_goal::in,
var_num_map::out) is det.
compute_var_number_map(HeadVars, VarSet, Internals, Goal, VarNumMap) :-
some [!VarNumMap, !Counter] (
!:VarNumMap = map.init,
!:Counter = counter.init(1), % to match term.var_supply_init
goal_util.goal_vars(Goal, GoalVarSet),
set.to_sorted_list(GoalVarSet, GoalVars),
list.foldl2(add_var_to_var_number_map(VarSet), GoalVars,
!VarNumMap, !Counter),
list.foldl2(add_var_to_var_number_map(VarSet), HeadVars,
!VarNumMap, !Counter),
list.foldl2(internal_var_number_map(VarSet), Internals, !VarNumMap,
!.Counter, _),
VarNumMap = !.VarNumMap
).
:- pred internal_var_number_map(prog_varset::in,
pair(int, internal_layout_info)::in,
var_num_map::in, var_num_map::out, counter::in, counter::out) is det.
internal_var_number_map(VarSet, _Label - Internal, !VarNumMap, !Counter) :-
Internal = internal_layout_info(MaybeTrace, MaybeResume, MaybeReturn),
(
MaybeTrace = yes(Trace),
Trace = trace_port_layout_info(_, _, _, _, MaybeUser, TraceLayout),
label_layout_var_number_map(TraceLayout, !VarNumMap, !Counter),
(
MaybeUser = no
;
MaybeUser = yes(UserEvent),
UserEvent = user_event_info(_UserEventNumber, Attributes),
list.foldl2(user_attribute_var_num_map(VarSet), Attributes,
!VarNumMap, !Counter)
)
;
MaybeTrace = no
),
(
MaybeResume = yes(ResumeLayout),
label_layout_var_number_map(ResumeLayout, !VarNumMap, !Counter)
;
MaybeResume = no
),
(
MaybeReturn = yes(Return),
Return = return_layout_info(_, ReturnLayout),
label_layout_var_number_map(ReturnLayout, !VarNumMap, !Counter)
;
MaybeReturn = no
).
:- pred label_layout_var_number_map(layout_label_info::in,
var_num_map::in, var_num_map::out, counter::in, counter::out) is det.
label_layout_var_number_map(LabelLayout, !VarNumMap, !Counter) :-
LabelLayout = layout_label_info(VarInfoSet, _),
VarInfos = set.to_sorted_list(VarInfoSet),
FindVar = (pred(VarInfo::in, Var - Name::out) is semidet :-
VarInfo = layout_var_info(_, LiveValueType, _),
LiveValueType = live_value_var(Var, Name, _, _)
),
list.filter_map(FindVar, VarInfos, VarsNames),
list.foldl2(add_named_var_to_var_number_map, VarsNames,
!VarNumMap, !Counter).
:- pred user_attribute_var_num_map(prog_varset::in, maybe(user_attribute)::in,
var_num_map::in, var_num_map::out, counter::in, counter::out) is det.
user_attribute_var_num_map(VarSet, MaybeAttribute, !VarNumMap, !Counter) :-
(
MaybeAttribute = yes(Attribute),
Attribute = user_attribute(_Locn, Var),
add_var_to_var_number_map(VarSet, Var, !VarNumMap, !Counter)
;
MaybeAttribute = no
).
:- pred add_var_to_var_number_map(prog_varset::in, prog_var::in,
var_num_map::in, var_num_map::out, counter::in, counter::out) is det.
add_var_to_var_number_map(VarSet, Var, !VarNumMap, !Counter) :-
( varset.search_name(VarSet, Var, VarName) ->
Name = VarName
;
Name = ""
),
add_named_var_to_var_number_map(Var - Name, !VarNumMap, !Counter).
:- pred add_named_var_to_var_number_map(pair(prog_var, string)::in,
var_num_map::in, var_num_map::out, counter::in, counter::out) is det.
add_named_var_to_var_number_map(Var - Name, !VarNumMap, !Counter) :-
( map.search(!.VarNumMap, Var, _) ->
% Name shouldn't differ from the name recorded in !.VarNumMap.
true
;
counter.allocate(VarNum, !Counter),
map.det_insert(!.VarNumMap, Var, VarNum - Name, !:VarNumMap)
).
%---------------------------------------------------------------------------%
% Construct the layout describing a single internal label
% for accurate GC and/or execution tracing.
%
:- pred construct_internal_layout(proc_label::in,
layout_name::in, var_num_map::in, pair(int, internal_layout_info)::in,
internal_label_info::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_internal_layout(ProcLabel, ProcLayoutName, VarNumMap,
LabelNum - Internal, LabelLayout, !Info) :-
Internal = internal_layout_info(Trace, Resume, Return),
(
Trace = no,
set.init(TraceLiveVarSet),
map.init(TraceTypeVarMap),
MaybeUserInfo = no
;
Trace = yes(trace_port_layout_info(_,_,_,_, MaybeUserInfo,
TraceLayout)),
TraceLayout = layout_label_info(TraceLiveVarSet, TraceTypeVarMap)
),
(
Resume = no,
set.init(ResumeLiveVarSet),
map.init(ResumeTypeVarMap)
;
Resume = yes(ResumeLayout),
ResumeLayout = layout_label_info(ResumeLiveVarSet, ResumeTypeVarMap)
),
(
Trace = yes(trace_port_layout_info(_, Port, IsHidden, GoalPath, _, _)),
Return = no,
MaybePort = yes(Port),
MaybeIsHidden = yes(IsHidden),
GoalPathStr = goal_path_to_string(GoalPath),
lookup_string_in_table(GoalPathStr, GoalPathNum, !Info),
MaybeGoalPath = yes(GoalPathNum)
;
Trace = no,
Return = yes(ReturnInfo),
% We only ever use the port fields of these layout structures
% when we process exception events. (Since exception events are
% interface events, the goal path field is not meaningful then.)
MaybePort = yes(port_exception),
MaybeIsHidden = yes(no),
% We only ever use the goal path fields of these layout structures
% when we process "fail" commands in the debugger.
ReturnInfo = return_layout_info(TargetsContexts, _),
( find_valid_return_context(TargetsContexts, _, _, GoalPath) ->
GoalPathStr = goal_path_to_string(GoalPath),
lookup_string_in_table(GoalPathStr, GoalPathNum, !Info),
MaybeGoalPath = yes(GoalPathNum)
;
% If tracing is enabled, then exactly one of the calls for which
% this label is a return site would have had a valid context.
% If none do, then tracing is not enabled, and therefore the goal
% path of this label will not be accessed.
MaybeGoalPath = no
)
;
Trace = no,
Return = no,
MaybePort = no,
MaybeIsHidden = no,
MaybeGoalPath = no
;
Trace = yes(_),
Return = yes(_),
unexpected(this_file, "label has both trace and return layout info")
),
get_agc_stack_layout(!.Info, AgcStackLayout),
(
Return = no,
set.init(ReturnLiveVarSet),
map.init(ReturnTypeVarMap)
;
Return = yes(return_layout_info(_, ReturnLayout)),
ReturnLayout = layout_label_info(ReturnLiveVarSet0, ReturnTypeVarMap0),
(
AgcStackLayout = yes,
ReturnLiveVarSet = ReturnLiveVarSet0,
ReturnTypeVarMap = ReturnTypeVarMap0
;
AgcStackLayout = no,
% This set of variables must be for uplevel printing in execution
% tracing, so we are interested only in (a) variables, not
% temporaries, (b) only named variables, and (c) only those
% on the stack, not the return values.
set.to_sorted_list(ReturnLiveVarSet0, ReturnLiveVarList0),
select_trace_return(
ReturnLiveVarList0, ReturnTypeVarMap0,
ReturnLiveVarList, ReturnTypeVarMap),
set.list_to_set(ReturnLiveVarList, ReturnLiveVarSet)
)
),
(
Trace = no,
Resume = no,
Return = no
->
MaybeVarInfo = no,
LabelVars = label_has_no_var_info
;
% XXX Ignore differences in insts inside layout_var_infos.
set.union(TraceLiveVarSet, ResumeLiveVarSet, LiveVarSet0),
set.union(LiveVarSet0, ReturnLiveVarSet, LiveVarSet),
map.union(set.intersect, TraceTypeVarMap, ResumeTypeVarMap,
TypeVarMap0),
map.union(set.intersect, TypeVarMap0, ReturnTypeVarMap, TypeVarMap),
construct_livelval_rvals(LiveVarSet, VarNumMap, TypeVarMap,
EncodedLength, LiveValRval, NamesRval, TypeParamRval, !Info),
VarInfo = label_var_info(EncodedLength, LiveValRval, NamesRval,
TypeParamRval),
MaybeVarInfo = yes(VarInfo),
LabelVars = label_has_var_info
),
(
MaybeUserInfo = no,
MaybeUserData = no
;
MaybeUserInfo = yes(UserInfo),
set_has_user_event(yes, !Info),
UserInfo = user_event_info(UserEventNumber, Attributes),
construct_user_data_array(VarNumMap, Attributes,
UserLocnsArray, UserAttrVarNums, !Info),
get_layout_static_cell_info(!.Info, StaticCellInfo0),
add_scalar_static_cell(UserLocnsArray, UserLocnsDataAddr,
StaticCellInfo0, StaticCellInfo),
set_layout_static_cell_info(StaticCellInfo, !Info),
UserLocnsRval = const(llconst_data_addr(UserLocnsDataAddr, no)),
UserData = user_event_data(UserEventNumber, UserLocnsRval,
UserAttrVarNums),
MaybeUserData = yes(UserData)
),
(
Trace = yes(_),
allocate_label_number(LabelNumber0, !Info),
% MR_ml_label_exec_count[0] is never written out; it is reserved for
% cases like this, for labels without events, and for handwritten
% labels.
( LabelNumber0 < (1 << 16) ->
LabelNumber = LabelNumber0
;
LabelNumber = 0
)
;
Trace = no,
LabelNumber = 0
),
LayoutData = label_layout_data(ProcLabel, LabelNum, ProcLayoutName,
MaybePort, MaybeIsHidden, LabelNumber, MaybeGoalPath, MaybeUserData,
MaybeVarInfo),
LayoutName = label_layout(ProcLabel, LabelNum, LabelVars),
Label = internal_label(LabelNum, ProcLabel),
add_internal_layout_data(LayoutData, Label, LayoutName, !Info),
LabelLayout = internal_label_info(ProcLabel, LabelNum, LabelVars,
Internal).
:- pred construct_user_data_array(var_num_map::in,
list(maybe(user_attribute))::in,
assoc_list(rval, llds_type)::out, list(maybe(int))::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_user_data_array(_, [], [], [], !Info).
construct_user_data_array(VarNumMap, [MaybeAttr | MaybeAttrs],
[LocnRvalAndType | LocnRvalAndTypes], [MaybeVarNum | MaybeVarNums],
!Info) :-
(
MaybeAttr = yes(Attr),
Attr = user_attribute(Locn, Var),
represent_locn_or_const_as_int_rval(Locn, LocnRval, LocnRvalType,
!Info),
LocnRvalAndType = LocnRval - LocnRvalType,
convert_var_to_int(VarNumMap, Var, VarNum),
MaybeVarNum = yes(VarNum)
;
MaybeAttr = no,
LocnRvalAndType = const(llconst_int(0)) - unsigned,
MaybeVarNum = no
),
construct_user_data_array(VarNumMap, MaybeAttrs, LocnRvalAndTypes,
MaybeVarNums, !Info).
%---------------------------------------------------------------------------%
:- pred construct_livelval_rvals(set(layout_var_info)::in,
var_num_map::in, map(tvar, set(layout_locn))::in, int::out,
rval::out, rval::out, rval::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_livelval_rvals(LiveLvalSet, VarNumMap, TVarLocnMap,
EncodedLength, LiveValRval, NamesRval, TypeParamRval, !Info) :-
set.to_sorted_list(LiveLvalSet, LiveLvals),
sort_livevals(LiveLvals, SortedLiveLvals),
construct_liveval_arrays(SortedLiveLvals, VarNumMap,
EncodedLength, LiveValRval, NamesRval, !Info),
StaticCellInfo0 = !.Info ^ static_cell_info,
construct_tvar_vector(TVarLocnMap, TypeParamRval,
StaticCellInfo0, StaticCellInfo),
!:Info = !.Info ^ static_cell_info := StaticCellInfo.
:- pred construct_tvar_vector(map(tvar, set(layout_locn))::in,
rval::out, static_cell_info::in, static_cell_info::out) is det.
construct_tvar_vector(TVarLocnMap, TypeParamRval, !StaticCellInfo) :-
( map.is_empty(TVarLocnMap) ->
TypeParamRval = const(llconst_int(0))
;
construct_tvar_rvals(TVarLocnMap, Vector),
add_scalar_static_cell(Vector, DataAddr, !StaticCellInfo),
TypeParamRval = const(llconst_data_addr(DataAddr, no))
).
:- pred construct_tvar_rvals(map(tvar, set(layout_locn))::in,
assoc_list(rval, llds_type)::out) is det.
construct_tvar_rvals(TVarLocnMap, Vector) :-
map.to_assoc_list(TVarLocnMap, TVarLocns),
construct_type_param_locn_vector(TVarLocns, 1, TypeParamLocs),
list.length(TypeParamLocs, TypeParamsLength),
LengthRval = const(llconst_int(TypeParamsLength)),
Vector = [LengthRval - unsigned | TypeParamLocs].
%---------------------------------------------------------------------------%
% Given a list of layout_var_infos and the type variables that occur
% in them, select only the layout_var_infos that may be required
% by up-level printing in the trace-based debugger. At the moment
% the typeinfo list we return may be bigger than necessary, but this
% does not compromise correctness; we do this to avoid having to
% scan the types of all the selected layout_var_infos.
%
:- pred select_trace_return(
list(layout_var_info)::in, map(tvar, set(layout_locn))::in,
list(layout_var_info)::out, map(tvar, set(layout_locn))::out) is det.
select_trace_return(Infos, TVars, TraceReturnInfos, TVars) :-
IsNamedReturnVar = (pred(LocnInfo::in) is semidet :-
LocnInfo = layout_var_info(Locn, LvalType, _),
LvalType = live_value_var(_, Name, _, _),
Name \= "",
( Locn = locn_direct(Lval) ; Locn = locn_indirect(Lval, _)),
( Lval = stackvar(_) ; Lval = framevar(_) )
),
list.filter(IsNamedReturnVar, Infos, TraceReturnInfos).
% Given a list of layout_var_infos, put the ones that tracing can be
% interested in (whether at an internal port or for uplevel printing)
% in a block at the start, and both this block and the remaining
% block. The division into two blocks can make the job of the
% debugger somewhat easier, the sorting of the named var block makes
% the output of the debugger look nicer, and the sorting of the both
% blocks makes it more likely that different labels' layout structures
% will have common parts (e.g. name vectors).
%
:- pred sort_livevals(list(layout_var_info)::in, list(layout_var_info)::out)
is det.
sort_livevals(OrigInfos, FinalInfos) :-
IsNamedVar = (pred(LvalInfo::in) is semidet :-
LvalInfo = layout_var_info(_Lval, LvalType, _),
LvalType = live_value_var(_, Name, _, _),
Name \= ""
),
list.filter(IsNamedVar, OrigInfos, NamedVarInfos0, OtherInfos0),
CompareVarInfos = (pred(Var1::in, Var2::in, Result::out) is det :-
Var1 = layout_var_info(Lval1, LiveType1, _),
Var2 = layout_var_info(Lval2, LiveType2, _),
get_name_from_live_value_type(LiveType1, Name1),
get_name_from_live_value_type(LiveType2, Name2),
compare(NameResult, Name1, Name2),
(
NameResult = (=),
compare(Result, Lval1, Lval2)
;
( NameResult = (<)
; NameResult = (>)
),
Result = NameResult
)
),
list.sort(CompareVarInfos, NamedVarInfos0, NamedVarInfos),
list.sort(CompareVarInfos, OtherInfos0, OtherInfos),
list.append(NamedVarInfos, OtherInfos, FinalInfos).
:- pred get_name_from_live_value_type(live_value_type::in,
string::out) is det.
get_name_from_live_value_type(LiveType, Name) :-
( LiveType = live_value_var(_, NamePrime, _, _) ->
Name = NamePrime
;
Name = ""
).
%---------------------------------------------------------------------------%
% Given a association list of type variables and their locations
% sorted on the type variables, represent them in an array of
% location descriptions indexed by the type variable. The next
% slot to fill is given by the second argument.
%
:- pred construct_type_param_locn_vector(
assoc_list(tvar, set(layout_locn))::in,
int::in, assoc_list(rval, llds_type)::out) is det.
construct_type_param_locn_vector([], _, []).
construct_type_param_locn_vector([TVar - Locns | TVarLocns], CurSlot,
Vector) :-
term.var_to_int(TVar, TVarNum),
NextSlot = CurSlot + 1,
( TVarNum = CurSlot ->
( set.remove_least(Locns, LeastLocn, _) ->
Locn = LeastLocn
;
unexpected(this_file, "tvar has empty set of locations")
),
represent_locn_as_int_rval(Locn, Rval),
construct_type_param_locn_vector(TVarLocns, NextSlot, VectorTail),
Vector = [Rval - unsigned | VectorTail]
; TVarNum > CurSlot ->
construct_type_param_locn_vector([TVar - Locns | TVarLocns], NextSlot,
VectorTail),
% This slot will never be referred to.
Vector = [const(llconst_int(0)) - unsigned | VectorTail]
;
unexpected(this_file,
"unsorted tvars in construct_type_param_locn_vector")
).
%---------------------------------------------------------------------------%
:- type liveval_array_info
---> live_array_info(
rval, % Rval describing the location of a live value.
% Always of llds type uint_least8 if the cell
% is in the byte array, and unsigned if it
% is in the int array.
rval, % Rval describing the type of a live value.
llds_type, % The llds type of the rval describing the type.
rval % Rval describing the variable number of a
% live value. Always of llds type uint_least16.
% Contains zero if the live value is not
% a variable. Contains the hightest possible
% uint_least16 value if the variable number
% does not fit in 16 bits.
).
% Construct a vector of (locn, live_value_type) pairs,
% and a corresponding vector of variable names.
%
:- pred construct_liveval_arrays(list(layout_var_info)::in,
var_num_map::in, int::out, rval::out, rval::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_liveval_arrays(VarInfos, VarNumMap, EncodedLength,
TypeLocnVector, NumVector, !Info) :-
int.pow(2, short_count_bits, BytesLimit),
construct_liveval_array_infos(VarInfos, VarNumMap,
0, BytesLimit, IntArrayInfo, ByteArrayInfo, !Info),
list.length(IntArrayInfo, IntArrayLength),
list.length(ByteArrayInfo, ByteArrayLength),
list.append(IntArrayInfo, ByteArrayInfo, AllArrayInfo),
EncodedLength = IntArrayLength << short_count_bits + ByteArrayLength,
SelectLocns = (pred(ArrayInfo::in, LocnRval::out) is det :-
ArrayInfo = live_array_info(LocnRval, _, _, _)
),
SelectTypes = (pred(ArrayInfo::in, TypeRval - TypeType::out) is det :-
ArrayInfo = live_array_info(_, TypeRval, TypeType, _)
),
AddRevNums = (pred(ArrayInfo::in, NumRvals0::in, NumRvals::out) is det :-
ArrayInfo = live_array_info(_, _, _, NumRval),
NumRvals = [NumRval | NumRvals0]
),
list.map(SelectTypes, AllArrayInfo, AllTypeRvalsTypes),
list.map(SelectLocns, IntArrayInfo, IntLocns),
list.map(associate_type(unsigned), IntLocns, IntLocnsTypes),
list.map(SelectLocns, ByteArrayInfo, ByteLocns),
list.map(associate_type(uint_least8), ByteLocns, ByteLocnsTypes),
list.append(IntLocnsTypes, ByteLocnsTypes, AllLocnsTypes),
list.append(AllTypeRvalsTypes, AllLocnsTypes, TypeLocnVectorRvalsTypes),
get_layout_static_cell_info(!.Info, StaticCellInfo0),
add_scalar_static_cell(TypeLocnVectorRvalsTypes, TypeLocnVectorAddr,
StaticCellInfo0, StaticCellInfo1),
TypeLocnVector = const(llconst_data_addr(TypeLocnVectorAddr, no)),
set_layout_static_cell_info(StaticCellInfo1, !Info),
get_trace_stack_layout(!.Info, TraceStackLayout),
(
TraceStackLayout = yes,
list.foldl(AddRevNums, AllArrayInfo, [], RevVarNumRvals),
list.reverse(RevVarNumRvals, VarNumRvals),
list.map(associate_type(uint_least16), VarNumRvals, VarNumRvalsTypes),
get_layout_static_cell_info(!.Info, StaticCellInfo2),
add_scalar_static_cell(VarNumRvalsTypes, NumVectorAddr,
StaticCellInfo2, StaticCellInfo),
set_layout_static_cell_info(StaticCellInfo, !Info),
NumVector = const(llconst_data_addr(NumVectorAddr, no))
;
TraceStackLayout = no,
NumVector = const(llconst_int(0))
).
:- pred associate_type(llds_type::in, rval::in, pair(rval, llds_type)::out)
is det.
associate_type(LldsType, Rval, Rval - LldsType).
:- pred construct_liveval_array_infos(list(layout_var_info)::in,
var_num_map::in, int::in, int::in,
list(liveval_array_info)::out, list(liveval_array_info)::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_liveval_array_infos([], _, _, _, [], [], !Info).
construct_liveval_array_infos([VarInfo | VarInfos], VarNumMap,
BytesSoFar, BytesLimit, IntVars, ByteVars, !Info) :-
VarInfo = layout_var_info(Locn, LiveValueType, _),
represent_live_value_type(LiveValueType, TypeRval, TypeRvalType, !Info),
construct_liveval_num_rval(VarNumMap, VarInfo, VarNumRval, !Info),
(
LiveValueType = live_value_var(_, _, Type, _),
get_module_info(!.Info, ModuleInfo),
check_dummy_type(ModuleInfo, Type) = is_dummy_type,
% We want to preserve I/O states in registers.
\+ (
Locn = locn_direct(reg(_, _))
)
->
unexpected(this_file, "construct_liveval_array_infos: " ++
"unexpected reference to dummy value")
;
BytesSoFar < BytesLimit,
represent_locn_as_byte(Locn, LocnByteRval)
->
Var = live_array_info(LocnByteRval, TypeRval, TypeRvalType,
VarNumRval),
construct_liveval_array_infos(VarInfos, VarNumMap,
BytesSoFar + 1, BytesLimit, IntVars, ByteVars0, !Info),
ByteVars = [Var | ByteVars0]
;
represent_locn_as_int_rval(Locn, LocnRval),
Var = live_array_info(LocnRval, TypeRval, TypeRvalType, VarNumRval),
construct_liveval_array_infos(VarInfos, VarNumMap,
BytesSoFar, BytesLimit, IntVars0, ByteVars, !Info),
IntVars = [Var | IntVars0]
).
:- pred construct_liveval_num_rval(var_num_map::in,
layout_var_info::in, rval::out,
stack_layout_info::in, stack_layout_info::out) is det.
construct_liveval_num_rval(VarNumMap,
layout_var_info(_, LiveValueType, _), VarNumRval, !Info) :-
( LiveValueType = live_value_var(Var, _, _, _) ->
convert_var_to_int(VarNumMap, Var, VarNum),
VarNumRval = const(llconst_int(VarNum))
;
VarNumRval = const(llconst_int(0))
).
:- pred convert_var_to_int(var_num_map::in, prog_var::in,
int::out) is det.
convert_var_to_int(VarNumMap, Var, VarNum) :-
map.lookup(VarNumMap, Var, VarNum0 - _),
% The variable number has to fit into two bytes. We reserve the largest
% such number (Limit) to mean that the variable number is too large
% to be represented. This ought not to happen, since compilation
% would be glacial at best for procedures with that many variables.
Limit = (1 << (2 * byte_bits)) - 1,
int.min(VarNum0, Limit, VarNum).
%---------------------------------------------------------------------------%
% The representation we build here should be kept in sync
% with runtime/mercury_ho_call.h, which contains macros to access
% the data structures we build here.
%
construct_closure_layout(CallerProcLabel, SeqNo,
ClosureLayoutInfo, ClosureProcLabel, ModuleName,
FileName, LineNumber, Origin, GoalPath, !StaticCellInfo,
RvalsTypes, Data) :-
DataAddr = layout_addr(
closure_proc_id(CallerProcLabel, SeqNo, ClosureProcLabel)),
Data = closure_proc_id_data(CallerProcLabel, SeqNo, ClosureProcLabel,
ModuleName, FileName, LineNumber, Origin, GoalPath),
ProcIdRvalType = const(llconst_data_addr(DataAddr, no)) - data_ptr,
ClosureLayoutInfo = closure_layout_info(ClosureArgs, TVarLocnMap),
construct_closure_arg_rvals(ClosureArgs,
ClosureArgRvalsTypes, !StaticCellInfo),
construct_tvar_vector(TVarLocnMap, TVarVectorRval, !StaticCellInfo),
RvalsTypes = [ProcIdRvalType, TVarVectorRval - data_ptr |
ClosureArgRvalsTypes].
:- pred construct_closure_arg_rvals(list(closure_arg_info)::in,
assoc_list(rval, llds_type)::out,
static_cell_info::in, static_cell_info::out) is det.
construct_closure_arg_rvals(ClosureArgs, ClosureArgRvalsTypes,
!StaticCellInfo) :-
list.map_foldl(construct_closure_arg_rval, ClosureArgs, ArgRvalsTypes,
!StaticCellInfo),
list.length(ArgRvalsTypes, Length),
ClosureArgRvalsTypes =
[const(llconst_int(Length)) - integer | ArgRvalsTypes].
:- pred construct_closure_arg_rval(closure_arg_info::in,
pair(rval, llds_type)::out,
static_cell_info::in, static_cell_info::out) is det.
construct_closure_arg_rval(ClosureArg, ArgRval - ArgRvalType,
!StaticCellInfo) :-
ClosureArg = closure_arg_info(Type, _Inst),
% For a stack layout, we can treat all type variables as universally
% quantified. This is not the argument of a constructor, so we do not need
% to distinguish between type variables that are and aren't in scope;
% we can take the variable number directly from the procedure's tvar set.
ExistQTvars = [],
NumUnivQTvars = -1,
ll_pseudo_type_info.construct_typed_llds_pseudo_type_info(Type,
NumUnivQTvars, ExistQTvars, !StaticCellInfo, ArgRval, ArgRvalType).
%---------------------------------------------------------------------------%
:- pred make_table_data(rtti_proc_label::in,
proc_layout_kind::in, proc_layout_table_info::in, maybe(layout_data)::out,
static_cell_info::in, static_cell_info::out) is det.
make_table_data(RttiProcLabel, Kind, TableInfo, MaybeTableData,
!StaticCellInfo) :-
(
TableInfo = proc_table_io_decl(TableIOInfo),
TableIOInfo = proc_table_io_info(TableArgInfos),
convert_table_arg_info(TableArgInfos, NumPTIs, PTIVectorRval,
TVarVectorRval, !StaticCellInfo),
TableData = table_io_decl_data(RttiProcLabel, Kind,
NumPTIs, PTIVectorRval, TVarVectorRval),
MaybeTableData = yes(TableData)
;
TableInfo = proc_table_struct(_TableStructInfo),
% This structure is generated by add_tabling_info_struct in proc_gen.m.
MaybeTableData = no
).
convert_table_arg_info(TableArgInfos, NumPTIs,
PTIVectorRval, TVarVectorRval, !StaticCellInfo) :-
TableArgInfos = table_arg_infos(Args, TVarSlotMap),
list.length(Args, NumPTIs),
list.map_foldl(construct_table_arg_pti_rval, Args, PTIRvalsTypes,
!StaticCellInfo),
add_scalar_static_cell(PTIRvalsTypes, PTIVectorAddr, !StaticCellInfo),
PTIVectorRval = const(llconst_data_addr(PTIVectorAddr, no)),
map.map_values(convert_slot_to_locn_map, TVarSlotMap, TVarLocnMap),
construct_tvar_vector(TVarLocnMap, TVarVectorRval, !StaticCellInfo).
:- pred convert_slot_to_locn_map(tvar::in, table_locn::in,
set(layout_locn)::out) is det.
convert_slot_to_locn_map(_TVar, SlotLocn, LvalLocns) :-
(
SlotLocn = table_locn_direct(SlotNum),
LvalLocn = locn_direct(reg(reg_r, SlotNum))
;
SlotLocn = table_locn_indirect(SlotNum, Offset),
LvalLocn = locn_indirect(reg(reg_r, SlotNum), Offset)
),
LvalLocns = set.make_singleton_set(LvalLocn).
:- pred construct_table_arg_pti_rval(
table_arg_info::in, pair(rval, llds_type)::out,
static_cell_info::in, static_cell_info::out) is det.
construct_table_arg_pti_rval(ClosureArg, ArgRval - ArgRvalType,
!StaticCellInfo) :-
ClosureArg = table_arg_info(_, _, _, Type),
ExistQTvars = [],
NumUnivQTvars = -1,
ll_pseudo_type_info.construct_typed_llds_pseudo_type_info(Type,
NumUnivQTvars, ExistQTvars, !StaticCellInfo, ArgRval, ArgRvalType).
%---------------------------------------------------------------------------%
% Construct a representation of the type of a value.
%
% For values representing variables, this will be a pseudo_type_info
% describing the type of the variable.
%
% For the kinds of values used internally by the compiler,
% this will be a pointer to a specific type_ctor_info (acting as a
% type_info) defined by hand in builtin.m to stand for values of
% each such kind; one for succips, one for hps, etc.
%
:- pred represent_live_value_type(live_value_type::in, rval::out,
llds_type::out, stack_layout_info::in, stack_layout_info::out) is det.
represent_live_value_type(live_value_succip, Rval, data_ptr, !Info) :-
represent_special_live_value_type("succip", Rval).
represent_live_value_type(live_value_hp, Rval, data_ptr, !Info) :-
represent_special_live_value_type("hp", Rval).
represent_live_value_type(live_value_curfr, Rval, data_ptr, !Info) :-
represent_special_live_value_type("curfr", Rval).
represent_live_value_type(live_value_maxfr, Rval, data_ptr, !Info) :-
represent_special_live_value_type("maxfr", Rval).
represent_live_value_type(live_value_redofr, Rval, data_ptr, !Info) :-
represent_special_live_value_type("redofr", Rval).
represent_live_value_type(live_value_redoip, Rval, data_ptr, !Info) :-
represent_special_live_value_type("redoip", Rval).
represent_live_value_type(live_value_trail_ptr, Rval, data_ptr, !Info) :-
represent_special_live_value_type("trail_ptr", Rval).
represent_live_value_type(live_value_ticket, Rval, data_ptr, !Info) :-
represent_special_live_value_type("ticket", Rval).
represent_live_value_type(RegionType, Rval, data_ptr, !Info) :-
( RegionType = live_value_region_ite
; RegionType = live_value_region_disj
; RegionType = live_value_region_commit
),
% Neither the garbage collector nor the debugger need info about
% regions.
represent_special_live_value_type("unwanted", Rval).
represent_live_value_type(live_value_unwanted, Rval, data_ptr, !Info) :-
represent_special_live_value_type("unwanted", Rval).
represent_live_value_type(live_value_var(_, _, Type, _), Rval, LldsType,
!Info) :-
% For a stack layout, we can treat all type variables as universally
% quantified. This is not the argument of a constructor, so we do not
% need to distinguish between type variables that are and aren't in scope;
% we can take the variable number directly from the procedure's tvar set.
ExistQTvars = [],
NumUnivQTvars = -1,
get_layout_static_cell_info(!.Info, StaticCellInfo0),
ll_pseudo_type_info.construct_typed_llds_pseudo_type_info(Type,
NumUnivQTvars, ExistQTvars, StaticCellInfo0, StaticCellInfo,
Rval, LldsType),
set_layout_static_cell_info(StaticCellInfo, !Info).
:- pred represent_special_live_value_type(string::in, rval::out) is det.
represent_special_live_value_type(SpecialTypeName, Rval) :-
RttiTypeCtor = rtti_type_ctor(unqualified(""), SpecialTypeName, 0),
DataAddr = rtti_addr(ctor_rtti_id(RttiTypeCtor, type_ctor_type_ctor_info)),
Rval = const(llconst_data_addr(DataAddr, no)).
%---------------------------------------------------------------------------%
:- pred represent_locn_or_const_as_int_rval(rval::in, rval::out,
llds_type::out, stack_layout_info::in, stack_layout_info::out) is det.
represent_locn_or_const_as_int_rval(LvalOrConst, Rval, Type, !Info) :-
(
LvalOrConst = lval(Lval),
represent_locn_as_int_rval(locn_direct(Lval), Rval),
Type = unsigned
;
LvalOrConst = const(_Const),
get_unboxed_floats(!.Info, UnboxedFloats),
LLDSType = rval_type_as_arg(UnboxedFloats, LvalOrConst),
get_layout_static_cell_info(!.Info, StaticCellInfo0),
add_scalar_static_cell([LvalOrConst - LLDSType], DataAddr,
StaticCellInfo0, StaticCellInfo),
set_layout_static_cell_info(StaticCellInfo, !Info),
Rval = const(llconst_data_addr(DataAddr, no)),
Type = data_ptr
;
LvalOrConst = mkword(Tag, LvalOrConstBase),
represent_locn_or_const_as_int_rval(LvalOrConstBase, BaseRval, Type,
!Info),
Rval = mkword(Tag, BaseRval)
;
( LvalOrConst = binop(_, _, _)
; LvalOrConst = unop(_, _)
; LvalOrConst = mem_addr(_)
; LvalOrConst = var(_)
),
unexpected(this_file, "represent_locn_or_const_as_int_rval: bad rval")
).
%---------------------------------------------------------------------------%
% Construct a representation of a variable location as a 32-bit integer.
%
% Most of the time, a layout specifies a location as an lval.
% However, a type_info variable may be hidden inside a typeclass_info,
% In this case, accessing the type_info requires indirection.
% The address of the typeclass_info is given as an lval, and
% the location of the typeinfo within the typeclass_info as an index;
% private_builtin.type_info_from_typeclass_info interprets the index.
%
% This one level of indirection is sufficient, since type_infos
% cannot be nested inside typeclass_infos any deeper than this.
% A more general representation that would allow more indirection
% would be much harder to fit into one machine word.
%
:- pred represent_locn_as_int_rval(layout_locn::in, rval::out) is det.
represent_locn_as_int_rval(Locn, Rval) :-
represent_locn_as_int(Locn, Word),
Rval = const(llconst_int(Word)).
represent_locn_as_int(locn_direct(Lval), Word) :-
represent_lval(Lval, Word).
represent_locn_as_int(locn_indirect(Lval, Offset), Word) :-
represent_lval(Lval, BaseWord),
expect((1 << long_lval_offset_bits) > Offset, this_file,
"represent_locn: offset too large to be represented"),
BaseAndOffset = (BaseWord << long_lval_offset_bits) + Offset,
make_tagged_word(lval_indirect, BaseAndOffset, Word).
% Construct a four byte representation of an lval.
%
:- pred represent_lval(lval::in, int::out) is det.
represent_lval(reg(reg_r, Num), Word) :-
make_tagged_word(lval_r_reg, Num, Word).
represent_lval(reg(reg_f, Num), Word) :-
make_tagged_word(lval_f_reg, Num, Word).
represent_lval(stackvar(Num), Word) :-
expect(Num > 0, this_file, "represent_lval: bad stackvar"),
make_tagged_word(lval_stackvar, Num, Word).
represent_lval(parent_stackvar(Num), Word) :-
expect(Num > 0, this_file, "represent_lval: bad parent_stackvar"),
make_tagged_word(lval_parent_stackvar, Num, Word).
represent_lval(framevar(Num), Word) :-
expect(Num > 0, this_file, "represent_lval: bad framevar"),
make_tagged_word(lval_framevar, Num, Word).
represent_lval(succip, Word) :-
make_tagged_word(lval_succip, 0, Word).
represent_lval(maxfr, Word) :-
make_tagged_word(lval_maxfr, 0, Word).
represent_lval(curfr, Word) :-
make_tagged_word(lval_curfr, 0, Word).
represent_lval(hp, Word) :-
make_tagged_word(lval_hp, 0, Word).
represent_lval(sp, Word) :-
make_tagged_word(lval_sp, 0, Word).
represent_lval(parent_sp, Word) :-
make_tagged_word(lval_parent_sp, 0, Word).
represent_lval(temp(_, _), _) :-
unexpected(this_file, "continuation live value stored in temp register").
represent_lval(succip_slot(_), _) :-
unexpected(this_file, "continuation live value stored in fixed slot").
represent_lval(redoip_slot(_), _) :-
unexpected(this_file, "continuation live value stored in fixed slot").
represent_lval(redofr_slot(_), _) :-
unexpected(this_file, "continuation live value stored in fixed slot").
represent_lval(succfr_slot(_), _) :-
unexpected(this_file, "continuation live value stored in fixed slot").
represent_lval(prevfr_slot(_), _) :-
unexpected(this_file, "continuation live value stored in fixed slot").
represent_lval(field(_, _, _), _) :-
unexpected(this_file, "continuation live value stored in field").
represent_lval(mem_ref(_), _) :-
unexpected(this_file, "continuation live value stored in mem_ref").
represent_lval(global_var_ref(_), _) :-
unexpected(this_file, "continuation live value stored in global_var_ref").
represent_lval(lvar(_), _) :-
unexpected(this_file, "continuation live value stored in lvar").
% Some things in this module are encoded using a low tag. This is not
% done using the normal compiler mkword, but by doing the bit shifting
% here.
%
% This allows us to use more than the usual 2 or 3 bits, but we have to
% use low tags and cannot tag pointers this way.
%
:- pred make_tagged_word(locn_type::in, int::in, int::out) is det.
make_tagged_word(Locn, Value, TaggedValue) :-
locn_type_code(Locn, Tag),
TaggedValue = (Value << long_lval_tag_bits) + Tag.
:- type locn_type
---> lval_r_reg
; lval_f_reg
; lval_stackvar
; lval_framevar
; lval_succip
; lval_maxfr
; lval_curfr
; lval_hp
; lval_sp
; lval_indirect
; lval_parent_sp
; lval_parent_stackvar.
:- pred locn_type_code(locn_type::in, int::out) is det.
% The code of this predicate should be kept in sync with the enum type
% MR_LongLvalType in runtime/mercury_stack_layout.h. Note that the values
% equal to 0 modulo 4 are reserved for representing constants.
locn_type_code(lval_r_reg, 1).
locn_type_code(lval_f_reg, 2).
locn_type_code(lval_stackvar, 3).
locn_type_code(lval_parent_stackvar, 3). % XXX placeholder only
locn_type_code(lval_framevar, 5).
locn_type_code(lval_succip, 6).
locn_type_code(lval_maxfr, 7).
locn_type_code(lval_curfr, 9).
locn_type_code(lval_hp, 10).
locn_type_code(lval_sp, 11).
locn_type_code(lval_parent_sp, 11). % XXX placeholder only
locn_type_code(lval_indirect, 13).
% This number of tag bits must be able to encode all values of
% locn_type_code.
%
:- func long_lval_tag_bits = int.
long_lval_tag_bits = 4.
% This number of tag bits must be able to encode the largest offset
% of a type_info within a typeclass_info.
%
:- func long_lval_offset_bits = int.
long_lval_offset_bits = 6.
%---------------------------------------------------------------------------%
% Construct a representation of a variable location as a byte,
% if this is possible.
%
:- pred represent_locn_as_byte(layout_locn::in, rval::out) is semidet.
represent_locn_as_byte(LayoutLocn, Rval) :-
LayoutLocn = locn_direct(Lval),
represent_lval_as_byte(Lval, Byte),
0 =< Byte,
Byte < 256,
Rval = const(llconst_int(Byte)).
% Construct a representation of an lval in a byte, if possible.
%
:- pred represent_lval_as_byte(lval::in, int::out) is semidet.
represent_lval_as_byte(reg(reg_r, Num), Byte) :-
expect(Num > 0, this_file, "represent_lval_as_byte: bad reg"),
make_tagged_byte(0, Num, Byte).
represent_lval_as_byte(stackvar(Num), Byte) :-
expect(Num > 0, this_file, "represent_lval_as_byte: bad stackvar"),
make_tagged_byte(1, Num, Byte).
represent_lval_as_byte(parent_stackvar(Num), Byte) :-
expect(Num > 0, this_file, "represent_lval_as_byte: bad parent_stackvar"),
make_tagged_byte(1, Num, Byte). % XXX placeholder only
represent_lval_as_byte(framevar(Num), Byte) :-
expect(Num > 0, this_file, "represent_lval_as_byte: bad framevar"),
make_tagged_byte(2, Num, Byte).
represent_lval_as_byte(succip, Byte) :-
locn_type_code(lval_succip, Val),
make_tagged_byte(3, Val, Byte).
represent_lval_as_byte(maxfr, Byte) :-
locn_type_code(lval_maxfr, Val),
make_tagged_byte(3, Val, Byte).
represent_lval_as_byte(curfr, Byte) :-
locn_type_code(lval_curfr, Val),
make_tagged_byte(3, Val, Byte).
represent_lval_as_byte(hp, Byte) :-
locn_type_code(lval_hp, Val),
make_tagged_byte(3, Val, Byte).
represent_lval_as_byte(sp, Byte) :-
locn_type_code(lval_sp, Val),
make_tagged_byte(3, Val, Byte).
represent_lval_as_byte(parent_sp, Byte) :-
locn_type_code(lval_parent_sp, Val),
make_tagged_byte(3, Val, Byte). % XXX placeholder only
:- pred make_tagged_byte(int::in, int::in, int::out) is det.
make_tagged_byte(Tag, Value, TaggedValue) :-
TaggedValue = unchecked_left_shift(Value, short_lval_tag_bits) + Tag.
:- func short_lval_tag_bits = int.
short_lval_tag_bits = 2.
:- func short_count_bits = int.
short_count_bits = 10.
:- func byte_bits = int.
byte_bits = 8.
%---------------------------------------------------------------------------%
represent_determinism_rval(Detism,
const(llconst_int(code_model.represent_determinism(Detism)))).
%---------------------------------------------------------------------------%
% Access to the stack_layout data structure.
% The per-sourcefile label table maps line numbers to the list of
% labels that correspond to that line. Each label is accompanied
% by a flag that says whether the label is the return site of a call
% or not, and if it is, whether the called procedure is known.
:- type is_label_return
---> known_callee(label)
; unknown_callee
; not_a_return.
:- type line_no_info == pair(layout_name, is_label_return).
:- type label_table == map(int, list(line_no_info)).
:- type stack_layout_info
---> stack_layout_info(
module_info :: module_info,
agc_stack_layout :: bool, % generate agc info?
trace_stack_layout :: bool, % generate tracing info?
procid_stack_layout :: bool, % generate proc id info?
static_code_addresses :: bool, % have static code addresses?
unboxed_floats :: have_unboxed_floats,
label_counter :: counter,
table_infos :: list(layout_data),
proc_layouts :: list(layout_data),
internal_layouts :: list(layout_data),
label_set :: map(label, data_addr),
% The set of labels (both entry
% and internal) with layouts.
proc_layout_name_list :: list(layout_name),
% The list of proc_layouts in
% the module.
string_table :: string_table,
label_tables :: map(string, label_table),
% Maps each filename that
% contributes labels to this module
% to a table describing those
% labels.
static_cell_info :: static_cell_info,
has_user_event :: bool
).
:- pred get_module_info(stack_layout_info::in, module_info::out) is det.
:- pred get_agc_stack_layout(stack_layout_info::in, bool::out) is det.
:- pred get_trace_stack_layout(stack_layout_info::in, bool::out) is det.
:- pred get_procid_stack_layout(stack_layout_info::in, bool::out) is det.
:- pred get_static_code_addresses(stack_layout_info::in, bool::out) is det.
:- pred get_unboxed_floats(stack_layout_info::in, have_unboxed_floats::out)
is det.
:- pred get_table_infos(stack_layout_info::in, list(layout_data)::out) is det.
:- pred get_proc_layout_data(stack_layout_info::in, list(layout_data)::out)
is det.
:- pred get_internal_layout_data(stack_layout_info::in, list(layout_data)::out)
is det.
:- pred get_label_set(stack_layout_info::in, map(label, data_addr)::out)
is det.
:- pred get_string_table(stack_layout_info::in, string_table::out) is det.
:- pred get_label_tables(stack_layout_info::in, map(string, label_table)::out)
is det.
:- pred get_layout_static_cell_info(stack_layout_info::in,
static_cell_info::out) is det.
:- pred get_has_user_event(stack_layout_info::in, bool::out) is det.
get_module_info(LI, LI ^ module_info).
get_agc_stack_layout(LI, LI ^ agc_stack_layout).
get_trace_stack_layout(LI, LI ^ trace_stack_layout).
get_procid_stack_layout(LI, LI ^ procid_stack_layout).
get_static_code_addresses(LI, LI ^ static_code_addresses).
get_unboxed_floats(LI, LI ^ unboxed_floats).
get_table_infos(LI, LI ^ table_infos).
get_proc_layout_data(LI, LI ^ proc_layouts).
get_internal_layout_data(LI, LI ^ internal_layouts).
get_label_set(LI, LI ^ label_set).
get_string_table(LI, LI ^ string_table).
get_label_tables(LI, LI ^ label_tables).
get_layout_static_cell_info(LI, LI ^ static_cell_info).
get_has_user_event(LI, LI ^ has_user_event).
:- pred allocate_label_number(int::out,
stack_layout_info::in, stack_layout_info::out) is det.
allocate_label_number(LabelNum, !LI) :-
Counter0 = !.LI ^ label_counter,
counter.allocate(LabelNum, Counter0, Counter),
!:LI = !.LI ^ label_counter := Counter.
:- pred add_table_data(maybe(layout_data)::in,
stack_layout_info::in, stack_layout_info::out) is det.
add_table_data(MaybeTableIoDeclData, !LI) :-
(
MaybeTableIoDeclData = yes(TableIoDeclData),
TableIoDecls0 = !.LI ^ table_infos,
TableIoDecls = [TableIoDeclData | TableIoDecls0],
!:LI = !.LI ^ table_infos := TableIoDecls
;
MaybeTableIoDeclData = no
).
:- pred add_proc_layout_data(layout_data::in, layout_name::in, label::in,
stack_layout_info::in, stack_layout_info::out) is det.
add_proc_layout_data(ProcLayout, ProcLayoutName, Label, !LI) :-
ProcLayouts0 = !.LI ^ proc_layouts,
ProcLayouts = [ProcLayout | ProcLayouts0],
LabelSet0 = !.LI ^ label_set,
map.det_insert(LabelSet0, Label, layout_addr(ProcLayoutName), LabelSet),
ProcLayoutNames0 = !.LI ^ proc_layout_name_list,
ProcLayoutNames = [ProcLayoutName | ProcLayoutNames0],
!:LI = !.LI ^ proc_layouts := ProcLayouts,
!:LI = !.LI ^ label_set := LabelSet,
!:LI = !.LI ^ proc_layout_name_list := ProcLayoutNames.
:- pred add_internal_layout_data(layout_data::in,
label::in, layout_name::in, stack_layout_info::in,
stack_layout_info::out) is det.
add_internal_layout_data(InternalLayout, Label, LayoutName, !LI) :-
InternalLayouts0 = !.LI ^ internal_layouts,
InternalLayouts = [InternalLayout | InternalLayouts0],
LabelSet0 = !.LI ^ label_set,
map.det_insert(LabelSet0, Label, layout_addr(LayoutName), LabelSet),
!:LI = !.LI ^ internal_layouts := InternalLayouts,
!:LI = !.LI ^ label_set := LabelSet.
:- pred set_string_table(string_table::in,
stack_layout_info::in, stack_layout_info::out) is det.
:- pred set_label_tables(map(string, label_table)::in,
stack_layout_info::in, stack_layout_info::out) is det.
:- pred set_layout_static_cell_info(static_cell_info::in,
stack_layout_info::in, stack_layout_info::out) is det.
:- pred set_has_user_event(bool::in,
stack_layout_info::in, stack_layout_info::out) is det.
set_string_table(ST, LI, LI ^ string_table := ST).
set_label_tables(LT, LI, LI ^ label_tables := LT).
set_layout_static_cell_info(SCI, LI, LI ^ static_cell_info := SCI).
set_has_user_event(HUE, LI, LI ^ has_user_event := HUE).
%---------------------------------------------------------------------------%
%
% Access to the string_table data structure
%
:- type string_table
---> string_table(
map(string, int), % Maps strings to their offsets.
list(string), % List of strings so far,
% in reverse order.
int % Next available offset
).
lookup_string_in_table(String, Offset, !Info) :-
StringTable0 = !.Info ^ string_table,
StringTable0 = string_table(TableMap0, TableList0, TableOffset0),
( map.search(TableMap0, String, OldOffset) ->
Offset = OldOffset
;
string.length(String, Length),
TableOffset = TableOffset0 + Length + 1,
% We use a 32 bit unsigned integer to represent the offset.
% Computing that limit exactly without getting an overflow
% or using unportable code isn't trivial. The code below
% is overly conservative, requiring the offset to be
% representable in only 30 bits. The over-conservatism
% should not be an issue; the machine will run out of
% virtual memory before the test below fails, for the
% next several years anyway. (Compiling a module that has
% a 1 Gb string table will require several tens of Gb
% of other compiler structures.)
TableOffset < (1 << ((4 * byte_bits) - 2))
->
Offset = TableOffset0,
map.det_insert(TableMap0, String, TableOffset0, TableMap),
TableList = [String | TableList0],
StringTable = string_table(TableMap, TableList, TableOffset),
set_string_table(StringTable, !Info)
;
% Says that the name of the variable is "TOO_MANY_VARIABLES".
Offset = 1
).
%---------------------------------------------------------------------------%
:- func this_file = string.
this_file = "stack_layout.m".
%---------------------------------------------------------------------------%
Reference in New Issue View Git Blame Copy Permalink