%---------------------------------------------------------------------------% % Copyright (C) 1997-1999 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. %---------------------------------------------------------------------------% % % This module generates the LLDS code that defines global constants to % hold the `stack_layout' structures of the stack frames defined by the % current module. % % The tables generated have a number of `create' rvals within them. % llds_common.m converts these into static data structures. % % We can create several types of stack layouts. Which kind we generate % depends on the values of several options. % % Main authors: trd, zs. % % NOTE: If you make changes in this file, you may also need to modify % runtime/mercury_stack_layout.h. % %---------------------------------------------------------------------------% % % Data Stucture: stack_layouts % % If the option basic_stack_layout is set, we generate a MR_Stack_Layout_Entry % for each procedure. This will be stored in the global variable whose name is % mercury_data__layout__mercury__. % This structure will always contain the following information: % % code address (Code *) - address of entry % succip stack location (uint_least32_t) actually, type MR_Live_Lval % (the location will be set to -1 % if there is no succip available). % number of stack slots (uint_least16_t) % determinism (uint_least16_t) actually, type MR_Determinism % % If the option procid_stack_layout is set, i.e. if we are doing stack % tracing, execution tracing or profiling, the structure will also include % information on the identity of the procedure. This information will take % one of two forms. Almost all procedures use the first form: % % predicate/function (Int) actually, MR_pred_func % declaring module name (String) % defining module name (String) % predicate name (String) % predicate arity (Integer) % procedure number (Integer) % % Automatically generated unification, index and comparison predicates % use the second form: % % type name (String) % type module's name (String) % defining module name (String) % predicate name (String) % predicate arity (Integer) % procedure number (Integer) % % The runtime system can figure out which form is present by testing % the value of the first slot. A value of 0 or 1 indicates the first form; % any higher value indicates the second form. The distinguished value -1 % indicates that procid_stack_layout is not set, and that the later fields % are not present. % % 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 structure will also include some extra fields: % % call trace info (MR_Stack_Layout_Label *) - points to the % layout structure of the call event % module layout (MR_Module_Layout *) - points to the layout % struct of the containing module. % maybe from full (int_least16_t) - number of the stack slot of % the from_full flag, if the procedure is % shallow traced % maybe decl debug (int_least16_t) - 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 % information is to allow the runtime debugger to find out which variables % are where on entry, so it can reexecute the procedure if asked to do so % and if the values of the required variables are still available. % (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 third 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 fourth 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 % mercury_data__layout__mercury___i. % This table has the following format: % % procedure info (Word *) - pointer to procedure stack layout % # of live data item (void *) - an encoded representation of % the number of live data items at the label % live data types locns (void *) - pointer to an area of memory % containing information about where the live % data items are and what their types are % live data names (MR_Var_Name *) - pointer to vector of % MR_Var_Name structs giving the HLDS var numbers % as well as the names of live data items. % type parameters (MR_Long_Lval *) - pointer to vector of % MR_Long_Lval giving the locations of the % typeinfos for the type parameters that may % be referred to by the types of the live data % items; the first word of the vector is an % integer giving the number of entries in the % vector; a NULL pointer means no type parameters % % The layout of the memory area containing information about the locations % and types of live data items is somewhat complicated, due to our desire % to make this information compact. We can represent a location in one of % two ways, as an 8-bit MR_Short_Lval or as a 32-bit MR_Long_Lval. % We prefer representing a location as an MR_Short_Lval, but of course % not all locations can be represented in this way, so those other locations % are represented as MR_Long_Lvals. % % The field containing the number of live data items is encoded by the % formula (#Long << short_count_bits + #Short), where #Short is the number % data items whose descriptions fit into an MR_Short_Lval and #Long is the % number of data items whose descriptions do not. (The field is not an integer % so that people who attempt to use it without going through the decoding % macros in runtime/mercury_stack_layout.h get an error from the C compiler. % The number of distinct values that fit into a uint_least_t also fits into % 8 bits, but since some locations hold the value of more than one variable % at a time, not all the values need to be distinct; this is why % short_count_bits is more than 8.) % % The memory area contains three vectors back to back. The first vector % has #Long + #Short word-sized elements, each of which is a pointer to a % MR_PseudoTypeInfo giving the type of a live data item, with a small % integer instead of a pointer representing a special kind of live data item % (e.g. a saved succip or hp). The second vector is an array of #Long % MR_Long_Lvals, and the third is an array of #Short MR_Short_Lvals, % each of which describes a location. The pseudotypeinfo pointed to by % the slot at subscript i in the first vector describes the type of % the data stored in slot i in the second vector if i < #Long, and % the type of the data stored in slot i - #Long in the third vector % otherwise. % % The live data pair vector will have an entry for each live variable. % The entry will give the location of the variable and its type. % % The live data name vector pointer may be NULL. If it is not, the vector % will have an entry consisting of two 16-bit numbers for each live data item. % The first is the live data item's HLDS variable number, or one of two % special values. Zero means that the live data item is not a variable % (e.g. it is a saved copy of succip). The largest possible 16-bit number % on the other hand means "the number of this variable does not fit into % 16 bits". With the exception of these special values, the value in this % slot uniquely identifies the variable. The second 16-bit number is an offset % into the module-wide string table; the string at that offset is the % variable's name. If the variable or data item has no name, the offset % will be zero (at which offset one will find an empty string). The string % table is restricted to be small enough to be addressed with 16 bits; % a string is reserved near the start for a string that says "too many % variables". Stack_layout.m will generate a reference to this string % instead of generating an offset that does not fit into 16 bits. % Therefore using the stored offset to index into the string table % is always safe. % % If the number of type parameters is not zero, we store the number, % so that the code that needs the type parameters can materialize % all the type parameters from their location descriptions in one go. % This is an optimization, since the type parameter vector could simply % be indexed on demand by the type variable's variable number stored within % pseudo-typeinfos inside the elements of the live data pairs vectors. % % Since we allocate type variable numbers sequentially, the type parameter % vector will usually be dense. However, after all variables whose types % include e.g. type variable 2 have gone out of scope, variables whose % types include type variable 3 may still be around. In cases like this, % the entry for type variable 2 will be zero; this signals to the code % in the internal debugger that materializes typeinfo structures that % this typeinfo structure need not be materialized. % % We need detailed information about the variables that are live at an % internal label in two kinds of circumstances. Stack layout information % will be present only for labels that fall into one or both of these % circumstances. % % - The option trace_stack_layout is set, and the label represents % a traced event at which variable info is needed (call, exit, % or entrance to one branch of a branched control structure; % fail events have no variable information). % % - The option agc_stack_layout is set or the trace level specifies % a capability for uplevel printing, and the label represents % a point where execution can resume after a procedure call or % after backtracking. % % For labels that do not fall into one of these two categories, the % "# of live vars" field will be negative to indicate the absence of % information about the variables live at this label, and the last % four fields will not be present. % % For labels that do fall into one of these two categories, the % "# of live vars" field will hold the number of live variables, which % will not be negative. If it is zero, the last four fields will not be % present. Even if it is not zero, however, the pointer to the live data % names vector will be NULL unless the label is used in execution tracing. % % XXX: Presently, inst information is ignored. We also do not yet enable % procid stack layouts for profiling, since profiling does not yet use % stack layouts. % %---------------------------------------------------------------------------% :- module stack_layout. :- interface. :- import_module continuation_info, hlds_module, llds. :- import_module std_util, list, set_bbbtree. :- pred stack_layout__generate_llds(module_info::in, module_info::out, global_data::in, list(comp_gen_c_data)::out, list(comp_gen_c_data)::out, set_bbbtree(label)::out) is det. :- pred stack_layout__construct_closure_layout(proc_label::in, maybe(closure_layout_info)::in, list(maybe(rval))::out, create_arg_types::out, int::in, int::out) is det. :- implementation. :- import_module globals, options, llds_out, trace. :- import_module hlds_data, hlds_pred, base_type_layout, prog_data, prog_out. :- import_module (inst), code_util. :- import_module assoc_list, bool, string, int, require. :- import_module map, term, set. %---------------------------------------------------------------------------% % Process all the continuation information stored in the HLDS, % converting it into LLDS data structures. stack_layout__generate_llds(ModuleInfo0, ModuleInfo, GlobalData, PossiblyDynamicLayouts, StaticLayouts, LayoutLabels) :- global_data_get_all_proc_layouts(GlobalData, ProcLayoutList), module_info_name(ModuleInfo0, ModuleName), module_info_get_cell_count(ModuleInfo0, CellCount), module_info_globals(ModuleInfo0, 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, ProcInfoLayout), globals__have_static_code_addresses(Globals, StaticCodeAddr), set_bbbtree__init(LayoutLabels0), map__init(StringMap0), StringTable0 = string_table(StringMap0, [], 0), LayoutInfo0 = stack_layout_info(ModuleName, CellCount, AgcLayout, TraceLayout, ProcInfoLayout, StaticCodeAddr, [], [], LayoutLabels0, [], StringTable0), stack_layout__lookup_string_in_table("", _, LayoutInfo0, LayoutInfo1), stack_layout__lookup_string_in_table("", _, LayoutInfo1, LayoutInfo2), list__foldl(stack_layout__construct_layouts, ProcLayoutList, LayoutInfo2, LayoutInfo3), stack_layout__get_next_cell_number(ProcVectorCellNum, LayoutInfo3, LayoutInfo), LayoutInfo = stack_layout_info(_, FinalCellCount, _, _, _, _, ProcLayouts, InternalLayouts, LayoutLabels, ProcLayoutArgs, StringTable), StringTable = string_table(_, RevStringList, StringOffset), list__reverse(RevStringList, StringList), stack_layout__concat_string_list(StringList, StringOffset, ConcatStrings), ( TraceLayout = yes -> Exported = no, % ignored; see linkage/2 in llds_out.m list__length(ProcLayoutList, NumProcLayouts), llds_out__sym_name_mangle(ModuleName, ModuleNameStr), ProcLayoutVector = create(0, ProcLayoutArgs, uniform(yes(data_ptr)), must_be_static, ProcVectorCellNum, "proc_layout_vector"), Rvals = [yes(const(string_const(ModuleNameStr))), yes(const(int_const(StringOffset))), yes(const(multi_string_const(StringOffset, ConcatStrings))), yes(const(int_const(NumProcLayouts))), yes(ProcLayoutVector)], ModuleLayouts = comp_gen_c_data(ModuleName, module_layout, Exported, Rvals, uniform(no), []), StaticLayouts = [ModuleLayouts | InternalLayouts] ; StaticLayouts = InternalLayouts ), PossiblyDynamicLayouts = ProcLayouts, module_info_set_cell_count(ModuleInfo0, FinalCellCount, ModuleInfo). %---------------------------------------------------------------------------% :- pred stack_layout__concat_string_list(list(string)::in, int::in, string::out) is det. :- pragma c_code(stack_layout__concat_string_list(StringList::in, ArenaSize::in, Arena::out), [will_not_call_mercury, thread_safe], "{ Word cur_node; Integer cur_offset; Word tmp; incr_hp_atomic(tmp, (ArenaSize + sizeof(Word)) / sizeof(Word)); Arena = (char *) tmp; cur_offset = 0; cur_node = StringList; while (! MR_list_is_empty(cur_node)) { (void) strcpy(&Arena[cur_offset], (char *) MR_list_head(cur_node)); cur_offset += strlen((char *) MR_list_head(cur_node)) + 1; cur_node = MR_list_tail(cur_node); } if (cur_offset != ArenaSize) { char msg[256]; sprintf(msg, ""internal error in creating string table;\n"" ""cur_offset = %ld, ArenaSize = %ld\n"", (long) cur_offset, (long) ArenaSize); fatal_error(msg); } }"). %---------------------------------------------------------------------------% % Construct the layouts that concern a single procedure: % the procedure-specific layout and the layouts of the labels % inside that procedure. :- pred stack_layout__construct_layouts(proc_layout_info::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_layouts(ProcLayoutInfo) --> { ProcLayoutInfo = proc_layout_info(EntryLabel, Detism, StackSlots, SuccipLoc, MaybeCallLabel, TraceSlotInfo, ForceProcIdLayout, InternalMap) }, stack_layout__construct_proc_layout(EntryLabel, Detism, StackSlots, SuccipLoc, MaybeCallLabel, TraceSlotInfo, ForceProcIdLayout), { map__to_assoc_list(InternalMap, Internals) }, list__foldl(stack_layout__construct_internal_layout(EntryLabel), Internals). %---------------------------------------------------------------------------% % Construct a procedure-specific layout. :- pred stack_layout__construct_proc_layout(label::in, determinism::in, int::in, maybe(int)::in, maybe(label)::in, trace_slot_info::in, bool::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_proc_layout(EntryLabel, Detism, StackSlots, MaybeSuccipLoc, MaybeCallLabel, TraceSlotInfo, ForceProcIdLayout) --> { MaybeSuccipLoc = yes(Location0) -> Location = Location0 ; % Use a dummy location of -1 if there is % no succip 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. Location = -1 }, stack_layout__get_static_code_addresses(StaticCodeAddr), { StaticCodeAddr = yes -> CodeAddrRval = const(code_addr_const(label(EntryLabel))) ; % This is a lie; the slot will be filled in for real % at initialization time. CodeAddrRval = const(int_const(0)) }, { determinism_components(Detism, _, at_most_many) -> SuccipLval = framevar(Location) ; SuccipLval = stackvar(Location) }, { stack_layout__represent_locn_as_int(direct(SuccipLval), SuccipRval) }, { StackSlotsRval = const(int_const(StackSlots)) }, { stack_layout__represent_determinism(Detism, DetismRval) }, { TraversalRvals = [yes(CodeAddrRval), yes(SuccipRval), yes(StackSlotsRval), yes(DetismRval)] }, { TraversalArgTypes = [1 - yes(code_ptr), 1 - yes(uint_least32), 2 - yes(uint_least16)] }, stack_layout__get_procid_stack_layout(ProcIdLayout0), { bool__or(ProcIdLayout0, ForceProcIdLayout, ProcIdLayout) }, ( { ProcIdLayout = yes } -> { code_util__extract_proc_label_from_label(EntryLabel, ProcLabel) }, { stack_layout__construct_procid_rvals(ProcLabel, IdRvals, IdArgTypes) }, stack_layout__construct_trace_layout(MaybeCallLabel, TraceSlotInfo, TraceRvals, TraceArgTypes), { list__append(IdRvals, TraceRvals, IdTraceRvals) }, { IdTraceArgTypes = initial(IdArgTypes, TraceArgTypes) } ; % Indicate the absence of the proc id and exec trace fields. { IdTraceRvals = [yes(const(int_const(-1)))] }, { IdTraceArgTypes = initial([1 - yes(integer)], none) } ), { Exported = no }, % XXX With the new profiler, we will need to % set this to `yes' if the profiling option % is given and if the procedure is exported. % Beware however that linkage/2 in llds_out.m % assumes that this is `no'. { list__append(TraversalRvals, IdTraceRvals, Rvals) }, { ArgTypes = initial(TraversalArgTypes, IdTraceArgTypes) }, stack_layout__get_module_name(ModuleName), { CDataName = proc_layout(EntryLabel) }, { CData = comp_gen_c_data(ModuleName, CDataName, Exported, Rvals, ArgTypes, []) }, stack_layout__add_proc_layout_data(CData, CDataName, EntryLabel). :- pred stack_layout__construct_trace_layout(maybe(label)::in, trace_slot_info::in, list(maybe(rval))::out, create_arg_types::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_trace_layout(MaybeCallLabel, TraceSlotInfo, Rvals, ArgTypes) --> stack_layout__get_module_name(ModuleName), stack_layout__get_trace_stack_layout(TraceLayout), { TraceLayout = yes -> ( MaybeCallLabel = yes(CallLabel) -> CallRval = yes(const(data_addr_const( data_addr(ModuleName, internal_layout(CallLabel))))) ; error("stack_layout__construct_trace_layout: call label not present") ), ModuleRval = yes(const(data_addr_const( data_addr(ModuleName, module_layout)))), 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))) ), Rvals = [CallRval, ModuleRval, FromFullRval, DeclRval], ArgTypes = initial([2 - yes(data_ptr), 2 - yes(int_least16)], none) ; % Indicate the absence of the trace layout fields. Rvals = [yes(const(int_const(0)))], ArgTypes = initial([1 - yes(integer)], none) }. %---------------------------------------------------------------------------% :- pred stack_layout__construct_procid_rvals(proc_label::in, list(maybe(rval))::out, initial_arg_types::out) is det. stack_layout__construct_procid_rvals(ProcLabel, Rvals, ArgTypes) :- ( ProcLabel = proc(DefModule, PredFunc, DeclModule, PredName, Arity, ProcId), stack_layout__represent_pred_or_func(PredFunc, PredFuncCode), prog_out__sym_name_to_string(DefModule, DefModuleString), prog_out__sym_name_to_string(DeclModule, DeclModuleString), proc_id_to_int(ProcId, Mode), Rvals = [ yes(const(int_const(PredFuncCode))), yes(const(string_const(DeclModuleString))), yes(const(string_const(DefModuleString))), yes(const(string_const(PredName))), yes(const(int_const(Arity))), yes(const(int_const(Mode))) ], ArgTypes = [6 - no] ; ProcLabel = special_proc(DefModule, PredName, TypeModule, TypeName, Arity, ProcId), prog_out__sym_name_to_string(TypeModule, TypeModuleString), prog_out__sym_name_to_string(DefModule, DefModuleString), proc_id_to_int(ProcId, Mode), Rvals = [ yes(const(string_const(TypeName))), yes(const(string_const(TypeModuleString))), yes(const(string_const(DefModuleString))), yes(const(string_const(PredName))), yes(const(int_const(Arity))), yes(const(int_const(Mode))) ], ArgTypes = [6 - no] ). :- pred stack_layout__represent_pred_or_func(pred_or_func::in, int::out) is det. stack_layout__represent_pred_or_func(predicate, 0). stack_layout__represent_pred_or_func(function, 1). %---------------------------------------------------------------------------% % Construct the layout describing a single internal label. :- pred stack_layout__construct_internal_layout(label::in, pair(label, internal_layout_info)::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_internal_layout(EntryLabel, Label - Internal) --> % generate the required rvals stack_layout__get_module_name(ModuleName), { EntryAddrRval = const(data_addr_const(data_addr(ModuleName, proc_layout(EntryLabel)))) }, stack_layout__construct_internal_rvals(Internal, VarInfoRvals, VarInfoRvalTypes), % Reenable this code if you want label numbers in label layouts. % { Label = local(_, LabelNum0) -> % LabelNum = LabelNum0 % ; % LabelNum = 0 % }, % { LabelNumRval = const(int_const(LabelNum)) }, % { LayoutRvals = [yes(EntryAddrRval), yes(LabelNumRval) % | VarInfoRvals] } { LayoutRvals = [yes(EntryAddrRval) | VarInfoRvals] }, { ArgTypes = initial([1 - no], VarInfoRvalTypes) }, { CData = comp_gen_c_data(ModuleName, internal_layout(Label), no, LayoutRvals, ArgTypes, []) }, stack_layout__add_internal_layout_data(CData, Label). % Construct the rvals required for accurate GC or for tracing. :- pred stack_layout__construct_internal_rvals(internal_layout_info::in, list(maybe(rval))::out, create_arg_types::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_internal_rvals(Internal, RvalList, ArgTypes) --> { Internal = internal_layout_info(Port, Return) }, { Port = no, set__init(PortLiveVarSet), map__init(PortTypeVarMap) ; Port = yes(layout_label_info(PortLiveVarSet, PortTypeVarMap)) }, stack_layout__get_agc_stack_layout(AgcStackLayout), { Return = no, set__init(ReturnLiveVarSet), map__init(ReturnTypeVarMap) ; Return = yes(layout_label_info(ReturnLiveVarSet0, ReturnTypeVarMap0)), ( AgcStackLayout = yes -> ReturnLiveVarSet = ReturnLiveVarSet0, ReturnTypeVarMap = ReturnTypeVarMap0 ; % 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), stack_layout__select_trace_return( ReturnLiveVarList0, ReturnTypeVarMap0, ReturnLiveVarList, ReturnTypeVarMap), set__list_to_set(ReturnLiveVarList, ReturnLiveVarSet) ) }, ( { Port = no }, { Return = no } -> % The -1 says that there is no info available % about variables at this label. (Zero would say % that there are no variables live at this label, % which may not be true.) { RvalList = [yes(const(int_const(-1)))] }, { ArgTypes = initial([1 - yes(integer)], none) } ; % XXX ignore differences in insts inside var_infos { set__union(PortLiveVarSet, ReturnLiveVarSet, LiveVarSet) }, { map__union(set__intersect, PortTypeVarMap, ReturnTypeVarMap, TypeVarMap) }, stack_layout__construct_livelval_rvals(LiveVarSet, TypeVarMap, RvalList, ArgTypes) ). %---------------------------------------------------------------------------% :- pred stack_layout__construct_livelval_rvals(set(var_info)::in, map(tvar, set(layout_locn))::in, list(maybe(rval))::out, create_arg_types::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_livelval_rvals(LiveLvalSet, TVarLocnMap, RvalList, ArgTypes) --> { set__to_sorted_list(LiveLvalSet, LiveLvals) }, { list__length(LiveLvals, Length) }, ( { Length > 0 } -> { stack_layout__sort_livevals(LiveLvals, SortedLiveLvals) }, stack_layout__construct_liveval_arrays(SortedLiveLvals, VarLengthRval, LiveValRval, NamesRval), ( { map__is_empty(TVarLocnMap) } -> { TypeParamRval = const(int_const(0)) } ; { stack_layout__construct_tvar_rvals(TVarLocnMap, Vector, VectorTypes) }, stack_layout__get_next_cell_number(CNum1), { TypeParamRval = create(0, Vector, VectorTypes, must_be_static, CNum1, "stack_layout_type_param_locn_vector") } ), { RvalList = [yes(VarLengthRval), yes(LiveValRval), yes(NamesRval), yes(TypeParamRval)] }, { ArgTypes = initial([1 - yes(integer), 3 - yes(data_ptr)], none) } ; { RvalList = [yes(const(int_const(0)))] }, { ArgTypes = initial([1 - yes(integer)], none) } ). :- pred stack_layout__construct_tvar_rvals(map(tvar, set(layout_locn))::in, list(maybe(rval))::out, create_arg_types::out) is det. stack_layout__construct_tvar_rvals(TVarLocnMap, Vector, VectorTypes) :- map__to_assoc_list(TVarLocnMap, TVarLocns), stack_layout__construct_type_param_locn_vector(TVarLocns, 1, TypeParamLocs), list__length(TypeParamLocs, TypeParamsLength), LengthRval = const(int_const(TypeParamsLength)), Vector = [yes(LengthRval) | TypeParamLocs], VectorTypes = uniform(yes(uint_least32)). %---------------------------------------------------------------------------% % Given a list of var_infos and the type variables that occur in them, % select only the 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 var_infos. :- pred stack_layout__select_trace_return( list(var_info)::in, map(tvar, set(layout_locn))::in, list(var_info)::out, map(tvar, set(layout_locn))::out) is det. stack_layout__select_trace_return(Infos, TVars, TraceReturnInfos, TVars) :- IsNamedReturnVar = lambda([LocnInfo::in] is semidet, ( LocnInfo = var_info(Locn, LvalType), LvalType = var(_, Name, _, _), Name \= "", ( Locn = direct(Lval) ; Locn = indirect(Lval, _)), ( Lval = stackvar(_) ; Lval = framevar(_) ) )), list__filter(IsNamedReturnVar, Infos, TraceReturnInfos). % Given a list of 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) that can be optimized % by llds_common.m. :- pred stack_layout__sort_livevals(list(var_info)::in, list(var_info)::out) is det. stack_layout__sort_livevals(OrigInfos, FinalInfos) :- IsNamedVar = lambda([LvalInfo::in] is semidet, ( LvalInfo = var_info(_Lval, LvalType), LvalType = var(_, Name, _, _), Name \= "" )), list__filter(IsNamedVar, OrigInfos, NamedVarInfos0, OtherInfos0), CompareVarInfos = lambda([Var1::in, Var2::in, Result::out] is det, ( Var1 = var_info(Lval1, LiveType1), Var2 = var_info(Lval2, LiveType2), stack_layout__get_name_from_live_value_type(LiveType1, Name1), stack_layout__get_name_from_live_value_type(LiveType2, Name2), compare(NameResult, Name1, Name2), ( NameResult = (=) -> compare(Result, Lval1, Lval2) ; Result = NameResult ) )), list__sort(CompareVarInfos, NamedVarInfos0, NamedVarInfos), list__sort(CompareVarInfos, OtherInfos0, OtherInfos), list__append(NamedVarInfos, OtherInfos, FinalInfos). :- pred stack_layout__get_name_from_live_value_type(live_value_type::in, string::out) is det. stack_layout__get_name_from_live_value_type(LiveType, Name) :- ( LiveType = 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 stack_layout__construct_type_param_locn_vector( assoc_list(tvar, set(layout_locn))::in, int::in, list(maybe(rval))::out) is det. stack_layout__construct_type_param_locn_vector([], _, []). stack_layout__construct_type_param_locn_vector([TVar - Locns | TVarLocns], CurSlot, Vector) :- term__var_to_int(TVar, TVarNum), NextSlot is CurSlot + 1, ( TVarNum = CurSlot -> ( set__remove_least(Locns, LeastLocn, _) -> Locn = LeastLocn ; error("tvar has empty set of locations") ), stack_layout__represent_locn_as_int(Locn, Rval), stack_layout__construct_type_param_locn_vector(TVarLocns, NextSlot, VectorTail), Vector = [yes(Rval) | VectorTail] ; TVarNum > CurSlot -> stack_layout__construct_type_param_locn_vector(TVarLocns, NextSlot, VectorTail), % This slot will never be referred to. Vector = [yes(const(int_const(0))) | VectorTail] ; error("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 uint_least32 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 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. rval % Rval describing the variable name of a % live value. Always of llds uint_least16. % Contains zero if the live value is not % a variable, or if it is a variable with % no name. ). % Construct a vector of (locn, live_value_type) pairs, % and a corresponding vector of variable names. :- pred stack_layout__construct_liveval_arrays(list(var_info)::in, rval::out, rval::out, rval::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_liveval_arrays(VarInfos, LengthRval, TypeLocnVector, NameVector) --> { int__pow(2, stack_layout__short_count_bits, BytesLimit) }, stack_layout__construct_liveval_array_infos(VarInfos, 0, BytesLimit, IntArrayInfo, ByteArrayInfo), { list__length(IntArrayInfo, IntArrayLength) }, { list__length(ByteArrayInfo, ByteArrayLength) }, { list__append(IntArrayInfo, ByteArrayInfo, AllArrayInfo) }, { EncodedLength is IntArrayLength << stack_layout__short_count_bits + ByteArrayLength }, { LengthRval = const(int_const(EncodedLength)) }, { SelectLocns = lambda([ArrayInfo::in, MaybeLocnRval::out] is det, ( ArrayInfo = live_array_info(LocnRval, _, _, _, _), MaybeLocnRval = yes(LocnRval) )) }, { SelectTypes = lambda([ArrayInfo::in, MaybeTypeRval::out] is det, ( ArrayInfo = live_array_info(_, TypeRval, _, _, _), MaybeTypeRval = yes(TypeRval) )) }, { SelectTypeTypes = lambda([ArrayInfo::in, CountTypeType::out] is det,( ArrayInfo = live_array_info(_, _, TypeType, _, _), CountTypeType = 1 - yes(TypeType) )) }, { AddRevNumsNames = lambda([ArrayInfo::in, NumNameRvals0::in, NumNameRvals::out] is det, ( ArrayInfo = live_array_info(_, _, _, NumRval, NameRval), NumNameRvals = [yes(NameRval), yes(NumRval) | NumNameRvals0] )) }, { list__map(SelectTypes, AllArrayInfo, AllTypes) }, { list__map(SelectTypeTypes, AllArrayInfo, AllTypeTypes) }, { list__map(SelectLocns, IntArrayInfo, IntLocns) }, { list__map(SelectLocns, ByteArrayInfo, ByteLocns) }, { list__append(IntLocns, ByteLocns, AllLocns) }, { list__append(AllTypes, AllLocns, TypeLocnVectorRvals) }, { LocnArgTypes = [IntArrayLength - yes(uint_least32), ByteArrayLength - yes(uint_least8)] }, { list__append(AllTypeTypes, LocnArgTypes, ArgTypes) }, stack_layout__get_next_cell_number(CNum1), { TypeLocnVector = create(0, TypeLocnVectorRvals, initial(ArgTypes, none), must_be_static, CNum1, "stack_layout_locn_vector") }, stack_layout__get_trace_stack_layout(TraceStackLayout), ( { TraceStackLayout = yes } -> { list__foldl(AddRevNumsNames, AllArrayInfo, [], RevVarNumNameRvals) }, { list__reverse(RevVarNumNameRvals, VarNumNameRvals) }, stack_layout__get_next_cell_number(CNum2), { NameVector = create(0, VarNumNameRvals, uniform(yes(uint_least16)), must_be_static, CNum2, "stack_layout_num_name_vector") } ; { NameVector = const(int_const(0)) } ). :- pred stack_layout__construct_liveval_array_infos(list(var_info)::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. stack_layout__construct_liveval_array_infos([], _, _, [], []) --> []. stack_layout__construct_liveval_array_infos([VarInfo | VarInfos], BytesSoFar, BytesLimit, IntVars, ByteVars) --> { VarInfo = var_info(Locn, LiveValueType) }, stack_layout__represent_live_value_type(LiveValueType, TypeRval, TypeRvalType), stack_layout__construct_liveval_name_rvals(VarInfo, VarNumRval, VarNameRval), ( { BytesSoFar < BytesLimit }, { stack_layout__represent_locn_as_byte(Locn, LocnByteRval) } -> { Var = live_array_info(LocnByteRval, TypeRval, TypeRvalType, VarNumRval, VarNameRval) }, stack_layout__construct_liveval_array_infos(VarInfos, BytesSoFar + 1, BytesLimit, IntVars, ByteVars0), { ByteVars = [Var | ByteVars0] } ; { stack_layout__represent_locn_as_int(Locn, LocnRval) }, { Var = live_array_info(LocnRval, TypeRval, TypeRvalType, VarNumRval, VarNameRval) }, stack_layout__construct_liveval_array_infos(VarInfos, BytesSoFar, BytesLimit, IntVars0, ByteVars), { IntVars = [Var | IntVars0] } ). :- pred stack_layout__construct_liveval_name_rvals(var_info::in, rval::out, rval::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__construct_liveval_name_rvals(var_info(_, LiveValueType), VarNumRval, VarNameRval, SLI0, SLI) :- ( LiveValueType = var(Var, Name, _, _) -> term__var_to_int(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 * stack_layout__byte_bits)) - 1, int__min(VarNum0, Limit, VarNum), VarNumRval = const(int_const(VarNum)), stack_layout__lookup_string_in_table(Name, Offset, SLI0, SLI), VarNameRval = const(int_const(Offset)) ; VarNumRval = const(int_const(0)), VarNameRval = const(int_const(0)), SLI = SLI0 ). %---------------------------------------------------------------------------% % 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. stack_layout__construct_closure_layout(ProcLabel, MaybeClosureLayoutInfo, Rvals, ArgTypes, CNum0, CNum) :- stack_layout__construct_procid_rvals(ProcLabel, ProcIdRvals, ProcIdTypes), ( MaybeClosureLayoutInfo = yes(ClosureLayoutInfo) -> ClosureLayoutInfo = closure_layout_info(ClosureArgs, TVarLocnMap), stack_layout__construct_closure_arg_rvals(ClosureArgs, ClosureArgRvals, ClosureArgTypes, CNum0, CNum), stack_layout__construct_tvar_rvals(TVarLocnMap, TVarRvals, TvarRvalTypes), list__append(ClosureArgRvals, TVarRvals, LayoutRvals), LayoutTypes = initial(ClosureArgTypes, TvarRvalTypes) ; LayoutRvals = [yes(const(int_const(-1)))], LayoutTypes = initial([1 - yes(integer)], none), CNum = CNum0 ), list__append(ProcIdRvals, LayoutRvals, Rvals), ArgTypes = initial(ProcIdTypes, LayoutTypes). :- pred stack_layout__construct_closure_arg_rvals(list(closure_arg_info)::in, list(maybe(rval))::out, initial_arg_types::out, int::in, int::out) is det. stack_layout__construct_closure_arg_rvals(ClosureArgs, ClosureArgRvals, ClosureArgTypes, CNum0, CNum) :- list__map_foldl(stack_layout__construct_closure_arg_rval, ClosureArgs, MaybeArgRvalsTypes, CNum0, CNum), assoc_list__keys(MaybeArgRvalsTypes, MaybeArgRvals), AddOne = lambda([Pair::in, CountLldsType::out] is det, ( Pair = _ - LldsType, CountLldsType = 1 - yes(LldsType) )), list__map(AddOne, MaybeArgRvalsTypes, ArgRvalTypes), list__length(MaybeArgRvals, Length), ClosureArgRvals = [yes(const(int_const(Length))) | MaybeArgRvals], ClosureArgTypes = [1 - yes(integer) | ArgRvalTypes]. :- pred stack_layout__construct_closure_arg_rval(closure_arg_info::in, pair(maybe(rval), llds_type)::out, int::in, int::out) is det. stack_layout__construct_closure_arg_rval(ClosureArg, yes(ArgRval) - ArgRvalType, CNum0, CNum) :- ClosureArg = closure_arg_info(Type, _Inst), base_type_layout__construct_typed_pseudo_type_info(Type, ArgRval, ArgRvalType, CNum0, CNum). %---------------------------------------------------------------------------% % The constants and representations here should be kept in sync % with runtime/mercury_stack_layout.h, which contains structure % definitions and macros to access the data structures we build here. % Construct a representation of a live_value_type without the name. % % Low integers for special values, a pointer for other values. % (Remember to keep the low integers below the max varint value in % runtime/mercury_type_info.h). :- pred stack_layout__represent_live_value_type(live_value_type, rval, llds_type, stack_layout_info, stack_layout_info). :- mode stack_layout__represent_live_value_type(in, out, out, in, out) is det. stack_layout__represent_live_value_type(succip, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "succip", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(hp, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "hp", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(curfr, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "curfr", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(maxfr, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "maxfr", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(redofr, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "redofr", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(redoip, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "redoip", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(unwanted, Rval, data_ptr) --> { TypeCtor = type_ctor(info, "succip", 0) }, { AddrConst = data_addr_const(data_addr(unqualified(""), TypeCtor)) }, { Rval = const(AddrConst) }. stack_layout__represent_live_value_type(var(_, _, Type, _), Rval, LldsType) --> stack_layout__get_cell_number(CNum0), { base_type_layout__construct_typed_pseudo_type_info(Type, Rval, LldsType, CNum0, CNum) }, stack_layout__set_cell_number(CNum). %---------------------------------------------------------------------------% % 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 stack_layout__represent_locn_as_int(layout_locn, rval). :- mode stack_layout__represent_locn_as_int(in, out) is det. stack_layout__represent_locn_as_int(direct(Lval), Rval) :- stack_layout__represent_lval(Lval, Word), Rval = const(int_const(Word)). stack_layout__represent_locn_as_int(indirect(Lval, Offset), Rval) :- stack_layout__represent_lval(Lval, BaseWord), require((1 << stack_layout__long_lval_offset_bits) > Offset, "stack_layout__represent_locn: offset too large to be represented"), BaseAndOffset is (BaseWord << stack_layout__long_lval_offset_bits) + Offset, stack_layout__make_tagged_word(lval_indirect, BaseAndOffset, Word), Rval = const(int_const(Word)). % Construct a four byte representation of an lval. :- pred stack_layout__represent_lval(lval, int). :- mode stack_layout__represent_lval(in, out) is det. stack_layout__represent_lval(reg(r, Num), Word) :- stack_layout__make_tagged_word(lval_r_reg, Num, Word). stack_layout__represent_lval(reg(f, Num), Word) :- stack_layout__make_tagged_word(lval_f_reg, Num, Word). stack_layout__represent_lval(stackvar(Num), Word) :- stack_layout__make_tagged_word(lval_stackvar, Num, Word). stack_layout__represent_lval(framevar(Num), Word) :- stack_layout__make_tagged_word(lval_framevar, Num, Word). stack_layout__represent_lval(succip, Word) :- stack_layout__make_tagged_word(lval_succip, 0, Word). stack_layout__represent_lval(maxfr, Word) :- stack_layout__make_tagged_word(lval_maxfr, 0, Word). stack_layout__represent_lval(curfr, Word) :- stack_layout__make_tagged_word(lval_curfr, 0, Word). stack_layout__represent_lval(hp, Word) :- stack_layout__make_tagged_word(lval_hp, 0, Word). stack_layout__represent_lval(sp, Word) :- stack_layout__make_tagged_word(lval_sp, 0, Word). stack_layout__represent_lval(temp(_, _), _) :- error("stack_layout: continuation live value stored in temp register"). stack_layout__represent_lval(succip(_), _) :- error("stack_layout: continuation live value stored in fixed slot"). stack_layout__represent_lval(redoip(_), _) :- error("stack_layout: continuation live value stored in fixed slot"). stack_layout__represent_lval(redofr(_), _) :- error("stack_layout: continuation live value stored in fixed slot"). stack_layout__represent_lval(succfr(_), _) :- error("stack_layout: continuation live value stored in fixed slot"). stack_layout__represent_lval(prevfr(_), _) :- error("stack_layout: continuation live value stored in fixed slot"). stack_layout__represent_lval(field(_, _, _), _) :- error("stack_layout: continuation live value stored in field"). stack_layout__represent_lval(mem_ref(_), _) :- error("stack_layout: continuation live value stored in mem_ref"). stack_layout__represent_lval(lvar(_), _) :- error("stack_layout: 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 stack_layout__make_tagged_word(locn_type::in, int::in, int::out) is det. stack_layout__make_tagged_word(Locn, Value, TaggedValue) :- stack_layout__locn_type_code(Locn, Tag), TaggedValue is (Value << stack_layout__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. :- pred stack_layout__locn_type_code(locn_type::in, int::out) is det. stack_layout__locn_type_code(lval_r_reg, 0). stack_layout__locn_type_code(lval_f_reg, 1). stack_layout__locn_type_code(lval_stackvar, 2). stack_layout__locn_type_code(lval_framevar, 3). stack_layout__locn_type_code(lval_succip, 4). stack_layout__locn_type_code(lval_maxfr, 5). stack_layout__locn_type_code(lval_curfr, 6). stack_layout__locn_type_code(lval_hp, 7). stack_layout__locn_type_code(lval_sp, 8). stack_layout__locn_type_code(lval_indirect, 9). :- func stack_layout__long_lval_tag_bits = int. % This number of tag bits must be able to encode all values of % stack_layout__locn_type_code. stack_layout__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 stack_layout__long_lval_offset_bits = int. stack_layout__long_lval_offset_bits = 6. %---------------------------------------------------------------------------% % Construct a representation of a variable location as a byte, % if this is possible. :- pred stack_layout__represent_locn_as_byte(layout_locn::in, rval::out) is semidet. stack_layout__represent_locn_as_byte(LayoutLocn, Rval) :- LayoutLocn = direct(Lval), stack_layout__represent_lval_as_byte(Lval, Byte), Rval = const(int_const(Byte)). % Construct a representation of an lval in a byte, if possible. :- pred stack_layout__represent_lval_as_byte(lval::in, int::out) is semidet. stack_layout__represent_lval_as_byte(reg(r, Num), Byte) :- stack_layout__make_tagged_byte(0, Num, Byte). stack_layout__represent_lval_as_byte(stackvar(Num), Byte) :- stack_layout__make_tagged_byte(1, Num, Byte). stack_layout__represent_lval_as_byte(framevar(Num), Byte) :- stack_layout__make_tagged_byte(2, Num, Byte). stack_layout__represent_lval_as_byte(succip, Byte) :- stack_layout__locn_type_code(lval_succip, Val), stack_layout__make_tagged_byte(3, Val, Byte). stack_layout__represent_lval_as_byte(maxfr, Byte) :- stack_layout__locn_type_code(lval_maxfr, Val), stack_layout__make_tagged_byte(3, Val, Byte). stack_layout__represent_lval_as_byte(curfr, Byte) :- stack_layout__locn_type_code(lval_curfr, Val), stack_layout__make_tagged_byte(3, Val, Byte). stack_layout__represent_lval_as_byte(hp, Byte) :- stack_layout__locn_type_code(lval_hp, Val), stack_layout__make_tagged_byte(3, Val, Byte). stack_layout__represent_lval_as_byte(sp, Byte) :- stack_layout__locn_type_code(lval_succip, Val), stack_layout__make_tagged_byte(3, Val, Byte). :- pred stack_layout__make_tagged_byte(int::in, int::in, int::out) is semidet. stack_layout__make_tagged_byte(Tag, Value, TaggedValue) :- Limit = 1 << (stack_layout__byte_bits - stack_layout__short_lval_tag_bits), Value < Limit, TaggedValue is unchecked_left_shift(Value, stack_layout__short_lval_tag_bits) + Tag. :- func stack_layout__short_lval_tag_bits = int. stack_layout__short_lval_tag_bits = 2. :- func stack_layout__short_count_bits = int. stack_layout__short_count_bits = 10. :- func stack_layout__byte_bits = int. stack_layout__byte_bits = 8. %---------------------------------------------------------------------------% % Construct a representation of the interface determinism of a % procedure. The code we have chosen is not sequential; instead % it encodes the various properties of each determinism. % % The 8 bit is set iff the context is first_solution. % The 4 bit is set iff the min number of solutions is more than zero. % The 2 bit is set iff the max number of solutions is more than zero. % The 1 bit is set iff the max number of solutions is more than one. :- pred stack_layout__represent_determinism(determinism::in, rval::out) is det. stack_layout__represent_determinism(Detism, const(int_const(Code))) :- ( Detism = det, Code = 6 /* 0110 */ ; Detism = semidet, /* 0010 */ Code = 2 ; Detism = nondet, Code = 3 /* 0011 */ ; Detism = multidet, Code = 7 /* 0111 */ ; Detism = erroneous, Code = 4 /* 0100 */ ; Detism = failure, Code = 0 /* 0000 */ ; Detism = cc_nondet, Code = 10 /* 1010 */ ; Detism = cc_multidet, Code = 14 /* 1110 */ ). %---------------------------------------------------------------------------% % Access to the stack_layout data structure. :- type stack_layout_info ---> stack_layout_info( module_name, % module name int, % next available cell number bool, % generate agc layout info? bool, % generate tracing layout info? bool, % generate procedure id layout info? bool, % have static code addresses? list(comp_gen_c_data), % generated proc layouts list(comp_gen_c_data), % generated label layouts set_bbbtree(label), % the set of labels (both entry and internal) % with layouts list(maybe(rval)), % the list of proc_layouts in the module, % represented as create args string_table ). :- pred stack_layout__get_module_name(module_name::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_cell_number(int::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_agc_stack_layout(bool::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_trace_stack_layout(bool::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_procid_stack_layout(bool::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_static_code_addresses(bool::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_proc_layout_data(list(comp_gen_c_data)::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_internal_layout_data(list(comp_gen_c_data)::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_label_set(set_bbbtree(label)::out, stack_layout_info::in, stack_layout_info::out) is det. :- pred stack_layout__get_string_table(string_table::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__get_module_name(A, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(A, _, _, _, _, _, _, _, _, _, _). stack_layout__get_cell_number(B, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, B, _, _, _, _, _, _, _, _, _). stack_layout__get_agc_stack_layout(C, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, C, _, _, _, _, _, _, _, _). stack_layout__get_trace_stack_layout(D, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, D, _, _, _, _, _, _, _). stack_layout__get_procid_stack_layout(E, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, _, E, _, _, _, _, _, _). stack_layout__get_static_code_addresses(F, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, _, _, F, _, _, _, _, _). stack_layout__get_proc_layout_data(G, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, _, _, _, G, _, _, _, _). stack_layout__get_internal_layout_data(H, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, _, _, _, _, H, _, _, _). stack_layout__get_label_set(I, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, _, _, _, _, _, I, _, _). stack_layout__get_string_table(K, LayoutInfo, LayoutInfo) :- LayoutInfo = stack_layout_info(_, _, _, _, _, _, _, _, _, _, K). :- pred stack_layout__add_proc_layout_data(comp_gen_c_data::in, data_name::in, label::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__add_proc_layout_data(NewG, NewJ, NewI, LayoutInfo0, LayoutInfo) :- LayoutInfo0 = stack_layout_info(A, B, C, D, E, F, G0, H, I0, J0, K), G = [NewG | G0], set_bbbtree__insert(I0, NewI, I), J = [yes(const(data_addr_const(data_addr(A, NewJ)))) | J0], LayoutInfo = stack_layout_info(A, B, C, D, E, F, G , H, I , J , K). :- pred stack_layout__add_internal_layout_data(comp_gen_c_data::in, label::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__add_internal_layout_data(NewH, NewI, LayoutInfo0, LayoutInfo) :- LayoutInfo0 = stack_layout_info(A, B, C, D, E, F, G, H0, I0, J, K), H = [NewH | H0], set_bbbtree__insert(I0, NewI, I), LayoutInfo = stack_layout_info(A, B, C, D, E, F, G, H , I , J, K). :- pred stack_layout__get_next_cell_number(int::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__get_next_cell_number(B, LayoutInfo0, LayoutInfo) :- LayoutInfo0 = stack_layout_info(A, B0, C, D, E, F, G, H, I, J, K), B is B0 + 1, LayoutInfo = stack_layout_info(A, B, C, D, E, F, G, H, I, J, K). :- pred stack_layout__set_cell_number(int::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__set_cell_number(B, LayoutInfo0, LayoutInfo) :- LayoutInfo0 = stack_layout_info(A, _, C, D, E, F, G, H, I, J, K), LayoutInfo = stack_layout_info(A, B, C, D, E, F, G, H, I, J, K). :- pred stack_layout__set_string_table(string_table::in, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__set_string_table(K, LayoutInfo0, LayoutInfo) :- LayoutInfo0 = stack_layout_info(A, B, C, D, E, F, G, H, I, J, _), LayoutInfo = stack_layout_info(A, B, C, D, E, F, G, H, I, J, K). %---------------------------------------------------------------------------% % 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 ). :- pred stack_layout__lookup_string_in_table(string::in, int::out, stack_layout_info::in, stack_layout_info::out) is det. stack_layout__lookup_string_in_table(String, Offset) --> stack_layout__get_string_table(StringTable0), { StringTable0 = string_table(TableMap0, TableList0, TableOffset0) }, ( { map__search(TableMap0, String, OldOffset) } -> { Offset = OldOffset } ; { string__length(String, Length) }, { TableOffset is TableOffset0 + Length + 1 }, { TableOffset < (1 << (2 * stack_layout__byte_bits)) } -> { Offset = TableOffset0 }, { map__det_insert(TableMap0, String, TableOffset0, TableMap) }, { TableList = [String | TableList0] }, { StringTable = string_table(TableMap, TableList, TableOffset) }, stack_layout__set_string_table(StringTable) ; % Says that the name of the variable is "TOO_MANY_VARIABLES". { Offset = 1 } ).