mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-19 15:54:18 +00:00
477ecb18f6
Estimated hours taken: 60 Implement pragma foreign_code for Managed C++. Currently you can only write MC++ code if your backend is capable of generating use MC++ as its "native" foreign language. The IL backend is the only backend that does this at the moment (the other backends have C as their "native" foreign language). Most of the machinery is in place to call from C to (normal) C++ but there is little work done on actually spitting out the C++ code into a separate file. The IL backend does this step already with managed C++. The intention is to turn foreign_code for C++ into a pragma import (which imports the C++ function from a separate file) and foreign_code for C (which calls the imported function). The C++ code will be inserted into a separate file that is compiled using C linkage. The important improvement this change gives is that you can write a module with a C and a MC++ implementations side-by-side. The target backend will select the most appropriate foreign language to use. You can override its choice using --use-foreign-language. Later on we will probably want more flexibility than just a single language selection option). This change also implements :- pragma foreign_decl, which allows header file style declarations to be written in languages other than C. compiler/code_gen.m: Reject code that is not C when generating LLDS. compiler/export.m: Start renaming C as foreign. Reject code that is not C when generating exports. compiler/foreign.m: A new module to handle foreign language interfacing. The bulk of the code for pragma import has been moved here from make_hlds. compiler/globals.m: Convert foreign language names to foreign_language. This code has been moved closer to the similar conversion we do for target language names. Add globals__io_lookup_foreign_language_option to make it easier to deterministically lookup the options relating to foreign languages. compiler/hlds_module.m: Move module_add_foreign_decl and module_add_foreign_body_code from make_hlds.m (where they were called module_add_c_header and module_add_c_code). compiler/hlds_out.m: Write the foreign language out in HLDS dumps. compiler/llds.m: Change foreign_header_info to foreign_decl_info. Change definitions of foreign_decl_code and foreign_body_code to include the language. compiler/llds_out.m: Reject code that is not C when writing out LLDS. compiler/make_hlds.m: Add foreign language information to the bodys and decls when creating them. Update error messages to refer to foreign code instead of C code. Use foreign.m to generate interfaces from the backend language to the foreign language. Hardcode C as the language for fact tables. compiler/mercury_compile.m: Collect the appropriate foreign language code together for output to the backend. compiler/intermod.m: compiler/mercury_to_mercury.m: Output the foreign language string. Change a few names to foreign_code instead of c_code. compiler/ml_code_gen.m: Filter the foreign language bodys and decls so that we only get the ones we are in (given by the use-foreign-language option). compiler/mlds_to_c.m: Abort if we are given non C foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/mlds_to_ilasm.m: Abort if we are given non MC++ foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/options.m: compiler/handle_options.m: Add --use-foreign-language as a user option to control the preferred foreign language to use as the implementation of this module. Add backend_foreign_language as an internal option which stores the foreign language that the compiler will use as a default (e.g. the natural foreign language for the backend to use). Set the preferred backend foreign language depending on the target. compiler/prog_data.m: Add managedcplusplus as a new alternative for the foreign_language type. Make c_header_code into foreign_decl. Give the foreign language for foreign_code as an attribute of the code. Write code to turn attributes into a list of strings (suitable for writing out by mercury_to_mercury). This fixes what appears to be a bug in tabled_for_io -- the tabled_for_io attribute was not being written out. Structure the code so this bug is difficult to repeat in future. compiler/prog_io_pragma.m: Parse foreign_decl. Turn c_header_code into a special case of foreign_decl. compiler/*.m: Remove the language field from pragma_foreign_code, it is now an attribute of the code. Various type and variable renamings. tests/invalid/pragma_c_code_and_clauses1.err_exp: tests/invalid/pragma_c_code_dup_var.err_exp: tests/warnings/singleton_test.exp: Update the tests to reflect the new error messages talking about :- pragma foreign_code rather than :- pragma c_code.
447 lines
16 KiB
Mathematica
447 lines
16 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1994-2000 The 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.
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Original author: conway.
|
|
% Extensive modification by zs.
|
|
|
|
% Allocates the storage location for each live variable at the end of
|
|
% each branched structure, so that the code generator will generate code
|
|
% which puts the variable in the same place in each branch.
|
|
|
|
% This module requires arg_infos and livenesses to have already been computed,
|
|
% and stack slots allocated.
|
|
|
|
% If the appropriate option is set, the code calls the follow_vars module
|
|
% to help guide its decisions.
|
|
|
|
% See compiler/notes/allocation.html for a description of the framework that
|
|
% this pass operates within.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module store_alloc.
|
|
|
|
:- interface.
|
|
|
|
:- import_module hlds_module, hlds_pred.
|
|
|
|
:- pred store_alloc_in_proc(proc_info, pred_id, module_info, proc_info).
|
|
:- mode store_alloc_in_proc(in, in, in, out) is det.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module follow_vars, liveness, hlds_goal, llds, prog_data.
|
|
:- import_module options, globals, trace_params, trace.
|
|
:- import_module goal_util, mode_util, instmap.
|
|
:- import_module list, map, set, std_util, assoc_list.
|
|
:- import_module bool, int, require.
|
|
|
|
:- type stack_slot_info
|
|
---> stack_slot_info(
|
|
bool, % was follow_vars run?
|
|
int, % the number of real r regs
|
|
stack_slots % maps each var to its stack slot
|
|
% (if it has one)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
store_alloc_in_proc(ProcInfo0, PredId, ModuleInfo, ProcInfo) :-
|
|
module_info_globals(ModuleInfo, Globals),
|
|
globals__lookup_bool_option(Globals, follow_vars, ApplyFollowVars),
|
|
( ApplyFollowVars = yes ->
|
|
proc_info_goal(ProcInfo0, Goal0),
|
|
|
|
find_final_follow_vars(ProcInfo0,
|
|
FollowVarsMap0, NextNonReserved0),
|
|
proc_info_vartypes(ProcInfo0, VarTypes),
|
|
find_follow_vars_in_goal(Goal0, VarTypes, ModuleInfo,
|
|
FollowVarsMap0, NextNonReserved0,
|
|
Goal1, FollowVarsMap, NextNonReserved),
|
|
Goal1 = GoalExpr1 - GoalInfo1,
|
|
FollowVars = follow_vars(FollowVarsMap, NextNonReserved),
|
|
goal_info_set_follow_vars(GoalInfo1, yes(FollowVars),
|
|
GoalInfo2),
|
|
Goal2 = GoalExpr1 - GoalInfo2
|
|
;
|
|
proc_info_goal(ProcInfo0, Goal2)
|
|
),
|
|
initial_liveness(ProcInfo0, PredId, ModuleInfo, Liveness0),
|
|
globals__get_trace_level(Globals, TraceLevel),
|
|
( trace_level_is_none(TraceLevel) = no ->
|
|
trace__fail_vars(ModuleInfo, ProcInfo0, ResumeVars0)
|
|
;
|
|
set__init(ResumeVars0)
|
|
),
|
|
globals__lookup_int_option(Globals, num_real_r_regs, NumRealRRegs),
|
|
proc_info_stack_slots(ProcInfo0, StackSlots),
|
|
StackSlotsInfo = stack_slot_info(ApplyFollowVars, NumRealRRegs,
|
|
StackSlots),
|
|
store_alloc_in_goal(Goal2, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotsInfo, Goal, _),
|
|
proc_info_set_goal(ProcInfo0, Goal, ProcInfo).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred store_alloc_in_goal(hlds_goal, liveness_info, set(prog_var),
|
|
module_info, stack_slot_info, hlds_goal, liveness_info).
|
|
:- mode store_alloc_in_goal(in, in, in, in, in, out, out) is det.
|
|
|
|
store_alloc_in_goal(Goal0 - GoalInfo0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal - GoalInfo0, Liveness) :-
|
|
% note: we must be careful to apply deaths before births
|
|
goal_info_get_pre_deaths(GoalInfo0, PreDeaths),
|
|
goal_info_get_pre_births(GoalInfo0, PreBirths),
|
|
goal_info_get_post_deaths(GoalInfo0, PostDeaths),
|
|
goal_info_get_post_births(GoalInfo0, PostBirths),
|
|
|
|
set__difference(Liveness0, PreDeaths, Liveness1),
|
|
set__union(Liveness1, PreBirths, Liveness2),
|
|
store_alloc_in_goal_2(Goal0, Liveness2, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal1, Liveness3),
|
|
set__difference(Liveness3, PostDeaths, Liveness4),
|
|
% If any variables magically become live in the PostBirths,
|
|
% then they have to mundanely become live in a parallel goal,
|
|
% so we don't need to allocate anything for them here.
|
|
%
|
|
% Any variables that become magically live at the end of the goal
|
|
% should not be included in the store map.
|
|
set__union(Liveness4, PostBirths, Liveness),
|
|
(
|
|
Goal1 = switch(Var, CanFail, Cases, AdvisoryStoreMap)
|
|
->
|
|
set__union(Liveness4, ResumeVars0, MappedSet),
|
|
set__to_sorted_list(MappedSet, MappedVars),
|
|
store_alloc_allocate_storage(MappedVars, AdvisoryStoreMap,
|
|
StackSlotInfo, StoreMap),
|
|
Goal = switch(Var, CanFail, Cases, StoreMap)
|
|
;
|
|
Goal1 = if_then_else(Vars, Cond, Then, Else, AdvisoryStoreMap)
|
|
->
|
|
set__union(Liveness4, ResumeVars0, MappedSet),
|
|
set__to_sorted_list(MappedSet, MappedVars),
|
|
store_alloc_allocate_storage(MappedVars, AdvisoryStoreMap,
|
|
StackSlotInfo, StoreMap),
|
|
Goal = if_then_else(Vars, Cond, Then, Else, StoreMap)
|
|
;
|
|
Goal1 = disj(Disjuncts, AdvisoryStoreMap)
|
|
->
|
|
set__union(Liveness4, ResumeVars0, MappedSet),
|
|
set__to_sorted_list(MappedSet, MappedVars),
|
|
store_alloc_allocate_storage(MappedVars, AdvisoryStoreMap,
|
|
StackSlotInfo, StoreMap),
|
|
Goal = disj(Disjuncts, StoreMap)
|
|
;
|
|
Goal = Goal1
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Here we process each of the different sorts of goals.
|
|
|
|
:- pred store_alloc_in_goal_2(hlds_goal_expr, liveness_info,
|
|
set(prog_var), module_info, stack_slot_info, hlds_goal_expr,
|
|
liveness_info).
|
|
:- mode store_alloc_in_goal_2(in, in, in, in, in, out, out) is det.
|
|
|
|
store_alloc_in_goal_2(conj(Goals0), Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, conj(Goals), Liveness) :-
|
|
store_alloc_in_conj(Goals0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, Liveness).
|
|
|
|
store_alloc_in_goal_2(par_conj(Goals0, SM), Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, par_conj(Goals, SM), Liveness) :-
|
|
store_alloc_in_par_conj(Goals0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, Liveness).
|
|
|
|
store_alloc_in_goal_2(disj(Goals0, FV), Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, disj(Goals, FV), Liveness) :-
|
|
store_alloc_in_disj(Goals0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, Liveness).
|
|
|
|
store_alloc_in_goal_2(not(Goal0), Liveness0, _ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, not(Goal), Liveness) :-
|
|
Goal0 = _ - GoalInfo0,
|
|
goal_info_get_resume_point(GoalInfo0, ResumeNot),
|
|
goal_info_resume_vars_and_loc(ResumeNot, ResumeNotVars, _),
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeNotVars, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness).
|
|
|
|
store_alloc_in_goal_2(switch(Var, Det, Cases0, FV), Liveness0, ResumeVars0,
|
|
ModuleInfo, StackSlotInfo,
|
|
switch(Var, Det, Cases, FV), Liveness) :-
|
|
store_alloc_in_cases(Cases0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Cases, Liveness).
|
|
|
|
store_alloc_in_goal_2(if_then_else(Vars, Cond0, Then0, Else0, FV),
|
|
Liveness0, ResumeVars0, ModuleInfo, StackSlotInfo,
|
|
if_then_else(Vars, Cond, Then, Else, FV), Liveness) :-
|
|
Cond0 = _ - CondGoalInfo0,
|
|
goal_info_get_resume_point(CondGoalInfo0, ResumeCond),
|
|
goal_info_resume_vars_and_loc(ResumeCond, ResumeCondVars, _),
|
|
store_alloc_in_goal(Cond0, Liveness0, ResumeCondVars, ModuleInfo,
|
|
StackSlotInfo, Cond, Liveness1),
|
|
store_alloc_in_goal(Then0, Liveness1, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Then, Liveness),
|
|
store_alloc_in_goal(Else0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Else, _Liveness2).
|
|
|
|
store_alloc_in_goal_2(some(Vars, CanRemove, Goal0), Liveness0, ResumeVars0,
|
|
ModuleInfo,
|
|
StackSlotInfo, some(Vars, CanRemove, Goal), Liveness) :-
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness).
|
|
|
|
store_alloc_in_goal_2(generic_call(A, B, C, D), Liveness, _, _,
|
|
_, generic_call(A, B, C, D), Liveness).
|
|
|
|
store_alloc_in_goal_2(call(A, B, C, D, E, F), Liveness, _, _,
|
|
_, call(A, B, C, D, E, F), Liveness).
|
|
|
|
store_alloc_in_goal_2(unify(A,B,C,D,E), Liveness, _, _,
|
|
_, unify(A,B,C,D,E), Liveness).
|
|
|
|
store_alloc_in_goal_2(pragma_foreign_code(A, B, C, D, E, F, G), Liveness,
|
|
_, _, _, pragma_foreign_code(A, B, C, D, E, F, G), Liveness).
|
|
|
|
store_alloc_in_goal_2(bi_implication(_, _), _, _, _, _, _, _) :-
|
|
% these should have been expanded out by now
|
|
error("store_alloc_in_goal_2: unexpected bi_implication").
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred store_alloc_in_conj(list(hlds_goal), liveness_info, set(prog_var),
|
|
module_info, stack_slot_info, list(hlds_goal), liveness_info).
|
|
:- mode store_alloc_in_conj(in, in, in, in, in, out, out) is det.
|
|
|
|
store_alloc_in_conj([], Liveness, _, _, _, [], Liveness).
|
|
store_alloc_in_conj([Goal0 | Goals0], Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, [Goal | Goals], Liveness) :-
|
|
(
|
|
% XXX should be threading the instmap
|
|
Goal0 = _ - GoalInfo,
|
|
goal_info_get_instmap_delta(GoalInfo, InstMapDelta),
|
|
instmap_delta_is_unreachable(InstMapDelta)
|
|
->
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness),
|
|
Goals = Goals0
|
|
;
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness1),
|
|
store_alloc_in_conj(Goals0, Liveness1, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, Liveness)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred store_alloc_in_par_conj(list(hlds_goal), liveness_info, set(prog_var),
|
|
module_info, stack_slot_info, list(hlds_goal), liveness_info).
|
|
:- mode store_alloc_in_par_conj(in, in, in, in, in, out, out) is det.
|
|
|
|
store_alloc_in_par_conj([], Liveness, _, _, _, [], Liveness).
|
|
store_alloc_in_par_conj([Goal0 | Goals0], Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, [Goal | Goals], Liveness) :-
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness),
|
|
store_alloc_in_par_conj(Goals0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, _Liveness1).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred store_alloc_in_disj(list(hlds_goal), liveness_info, set(prog_var),
|
|
module_info, stack_slot_info, list(hlds_goal), liveness_info).
|
|
:- mode store_alloc_in_disj(in, in, in, in, in, out, out) is det.
|
|
|
|
store_alloc_in_disj([], Liveness, _, _, _, [], Liveness).
|
|
store_alloc_in_disj([Goal0 | Goals0], Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, [Goal | Goals], Liveness) :-
|
|
Goal0 = _ - GoalInfo0,
|
|
goal_info_get_resume_point(GoalInfo0, ResumeGoal),
|
|
(
|
|
ResumeGoal = no_resume_point,
|
|
ResumeGoalVars = ResumeVars0
|
|
;
|
|
ResumeGoal = resume_point(ResumeGoalVars, _)
|
|
),
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeGoalVars, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness),
|
|
store_alloc_in_disj(Goals0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, _Liveness1).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred store_alloc_in_cases(list(case), liveness_info, set(prog_var),
|
|
module_info, stack_slot_info, list(case), liveness_info).
|
|
:- mode store_alloc_in_cases(in, in, in, in, in, out, out) is det.
|
|
|
|
store_alloc_in_cases([], Liveness, _, _, _, [], Liveness).
|
|
store_alloc_in_cases([case(Cons, Goal0) | Goals0], Liveness0, ResumeVars0,
|
|
ModuleInfo, StackSlotInfo,
|
|
[case(Cons, Goal) | Goals], Liveness) :-
|
|
store_alloc_in_goal(Goal0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goal, Liveness),
|
|
store_alloc_in_cases(Goals0, Liveness0, ResumeVars0, ModuleInfo,
|
|
StackSlotInfo, Goals, _Liveness1).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Given a follow_map which
|
|
%
|
|
% 1 may contain entries for non-live variables,
|
|
%
|
|
% 2 may contain no entry for a live variable,
|
|
%
|
|
% 3 which may map two live variables to one lval, and/or
|
|
%
|
|
% 4 map an lval to the artificial location reg(r(-1)),
|
|
%
|
|
% generate a store map that maps every live variable to its own
|
|
% real location.
|
|
|
|
:- pred store_alloc_allocate_storage(list(prog_var), store_map,
|
|
stack_slot_info, store_map).
|
|
:- mode store_alloc_allocate_storage(in, in, in, out) is det.
|
|
|
|
store_alloc_allocate_storage(LiveVars, FollowVars, StackSlotInfo, StoreMap) :-
|
|
|
|
% This addresses point 1
|
|
map__keys(FollowVars, FollowKeys),
|
|
store_alloc_remove_nonlive(FollowKeys, LiveVars, FollowVars, StoreMap0),
|
|
|
|
% This addresses points 3 and 4
|
|
map__keys(StoreMap0, StoreVars),
|
|
set__init(SeenLvals0),
|
|
store_alloc_handle_conflicts_and_nonreal(StoreVars, 1, N,
|
|
SeenLvals0, SeenLvals, StoreMap0, StoreMap1),
|
|
|
|
% This addresses point 2
|
|
store_alloc_allocate_extras(LiveVars, N, SeenLvals, StackSlotInfo,
|
|
StoreMap1, StoreMap).
|
|
|
|
:- pred store_alloc_remove_nonlive(list(prog_var), list(prog_var),
|
|
store_map, store_map).
|
|
:- mode store_alloc_remove_nonlive(in, in, in, out) is det.
|
|
|
|
store_alloc_remove_nonlive([], _LiveVars, StoreMap, StoreMap).
|
|
store_alloc_remove_nonlive([Var | Vars], LiveVars, StoreMap0, StoreMap) :-
|
|
( list__member(Var, LiveVars) ->
|
|
StoreMap1 = StoreMap0
|
|
;
|
|
map__delete(StoreMap0, Var, StoreMap1)
|
|
),
|
|
store_alloc_remove_nonlive(Vars, LiveVars, StoreMap1, StoreMap).
|
|
|
|
:- pred store_alloc_handle_conflicts_and_nonreal(list(prog_var),
|
|
int, int, set(lval), set(lval), store_map, store_map).
|
|
:- mode store_alloc_handle_conflicts_and_nonreal(in, in, out, in, out, in, out)
|
|
is det.
|
|
|
|
store_alloc_handle_conflicts_and_nonreal([], N, N, SeenLvals, SeenLvals,
|
|
StoreMap, StoreMap).
|
|
store_alloc_handle_conflicts_and_nonreal([Var | Vars], N0, N,
|
|
SeenLvals0, SeenLvals, StoreMap0, StoreMap) :-
|
|
map__lookup(StoreMap0, Var, Lval),
|
|
(
|
|
( artificial_lval(Lval)
|
|
; set__member(Lval, SeenLvals0)
|
|
)
|
|
->
|
|
next_free_reg(N0, SeenLvals0, N1),
|
|
FinalLval = reg(r, N1),
|
|
map__det_update(StoreMap0, Var, FinalLval, StoreMap1)
|
|
;
|
|
N1 = N0,
|
|
FinalLval = Lval,
|
|
StoreMap1 = StoreMap0
|
|
),
|
|
set__insert(SeenLvals0, FinalLval, SeenLvals1),
|
|
store_alloc_handle_conflicts_and_nonreal(Vars, N1, N,
|
|
SeenLvals1, SeenLvals, StoreMap1, StoreMap).
|
|
|
|
:- pred store_alloc_allocate_extras(list(prog_var), int, set(lval),
|
|
stack_slot_info, store_map, store_map).
|
|
:- mode store_alloc_allocate_extras(in, in, in, in, in, out) is det.
|
|
|
|
store_alloc_allocate_extras([], _, _, _, StoreMap, StoreMap).
|
|
store_alloc_allocate_extras([Var | Vars], N0, SeenLvals0, StackSlotInfo,
|
|
StoreMap0, StoreMap) :-
|
|
(
|
|
map__contains(StoreMap0, Var)
|
|
->
|
|
% We have already allocated a slot for this variable.
|
|
N1 = N0,
|
|
StoreMap1 = StoreMap0,
|
|
SeenLvals1 = SeenLvals0
|
|
;
|
|
% We have not yet allocated a slot for this variable,
|
|
% which means it is not in the follow vars (if any).
|
|
StackSlotInfo = stack_slot_info(FollowVars, NumRealRRegs,
|
|
StackSlots),
|
|
(
|
|
map__search(StackSlots, Var, StackSlot),
|
|
\+ set__member(StackSlot, SeenLvals0),
|
|
(
|
|
FollowVars = yes
|
|
% If follow_vars was run, then the only
|
|
% reason why a var would not be in the
|
|
% follow_vars set is if it was supposed to
|
|
% be in its stack slot.
|
|
;
|
|
FollowVars = no,
|
|
% If follow_vars was not run, then we
|
|
% prefer to put the variable in a register,
|
|
% provided it is a real register.
|
|
next_free_reg(N0, SeenLvals0, TentativeReg),
|
|
TentativeReg =< NumRealRRegs
|
|
)
|
|
->
|
|
Locn = StackSlot,
|
|
N1 = N0
|
|
;
|
|
next_free_reg(N0, SeenLvals0, N1),
|
|
Locn = reg(r, N1)
|
|
),
|
|
map__det_insert(StoreMap0, Var, Locn, StoreMap1),
|
|
set__insert(SeenLvals0, Locn, SeenLvals1)
|
|
),
|
|
store_alloc_allocate_extras(Vars, N1, SeenLvals1, StackSlotInfo,
|
|
StoreMap1, StoreMap).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% The follow_vars pass maps some variables r(-1) as a hint to the
|
|
% code generator to put them in any free register. Since store maps
|
|
% require real locations, we can't use such hints directly.
|
|
|
|
% For robustness, we check for N < 1 instead of N = -1.
|
|
|
|
:- pred artificial_lval(lval).
|
|
:- mode artificial_lval(in) is semidet.
|
|
|
|
artificial_lval(reg(_Type, Num)) :-
|
|
Num < 1.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- pred next_free_reg(int, set(lval), int).
|
|
:- mode next_free_reg(in, in, out) is det.
|
|
|
|
next_free_reg(N0, Values, N) :-
|
|
( set__member(reg(r, N0), Values) ->
|
|
N1 is N0 + 1,
|
|
next_free_reg(N1, Values, N)
|
|
;
|
|
N = N0
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|