mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-10 03:13:46 +00:00
a2bf36e49a
Estimated hours taken: 4 Branches: main This diff contains no changes in algorithms whatsoever. browser/*.m: compiler/*.m: library/*.m: Replace old-style lambdas with new-style lambdas or with named procedures.
1094 lines
35 KiB
Mathematica
1094 lines
35 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1994-2000,2002-2003 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.
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% tag_switch.m - generate switches based on primary and secondary tags.
|
|
|
|
% Author: zs.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module ll_backend__tag_switch.
|
|
|
|
:- interface.
|
|
|
|
:- import_module backend_libs__code_model.
|
|
:- import_module backend_libs__switch_util.
|
|
:- import_module hlds__hlds_data.
|
|
:- import_module hlds__hlds_goal.
|
|
:- import_module ll_backend__code_info.
|
|
:- import_module ll_backend__llds.
|
|
:- import_module parse_tree__prog_data.
|
|
|
|
:- import_module list.
|
|
|
|
% Generate intelligent indexing code for tag based switches.
|
|
|
|
:- pred tag_switch__generate(list(extended_case)::in, prog_var::in,
|
|
code_model::in, can_fail::in, hlds_goal_info::in, label::in,
|
|
branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
:- implementation.
|
|
|
|
:- import_module backend_libs__builtin_ops.
|
|
:- import_module check_hlds__type_util.
|
|
:- import_module hlds__hlds_llds.
|
|
:- import_module hlds__hlds_module.
|
|
:- import_module hlds__hlds_pred.
|
|
:- import_module libs__globals.
|
|
:- import_module libs__options.
|
|
:- import_module libs__tree.
|
|
:- import_module ll_backend__code_gen.
|
|
:- import_module ll_backend__trace.
|
|
:- import_module parse_tree__prog_data.
|
|
|
|
:- import_module bool, int, string, assoc_list, map.
|
|
:- import_module require, std_util.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% The idea is to generate two-level switches, first on the primary
|
|
% tag and then on the secondary tag. Since more than one function
|
|
% symbol can be eliminated by a failed primary tag test, this reduces
|
|
% the expected the number of comparisons required before finding the
|
|
% code corresponding to the actual value of the switch variable.
|
|
% We also get a speedup compared to non-tag switches by extracting
|
|
% the primary and secondary tags once instead of repeatedly for
|
|
% each functor test.
|
|
%
|
|
% We have four methods we can use for generating the code for the
|
|
% switches on both primary and secondary tags.
|
|
%
|
|
% 1. try-me-else chains have the form
|
|
%
|
|
% if (tag(var) != tag1) goto L1
|
|
% code for tag1
|
|
% goto end
|
|
% L1: if (tag(var) != tag2) goto L2
|
|
% code for tag2
|
|
% goto end
|
|
% L2: ...
|
|
% Ln: code for last possible tag value (or failure)
|
|
% goto end
|
|
%
|
|
% 2. try chains have the form
|
|
%
|
|
% if (tag(var) == tag1) goto L1
|
|
% if (tag(var) == tag2) goto L2
|
|
% ...
|
|
% code for last possible tag value (or failure)
|
|
% goto end
|
|
% L1: code for tag1
|
|
% goto end
|
|
% L2: code for tag2
|
|
% goto end
|
|
% ...
|
|
%
|
|
% 3. jump tables have the form
|
|
%
|
|
% goto tag(var) of L1, L2, ...
|
|
% L1: code for tag1
|
|
% goto end
|
|
% L2: code for tag2
|
|
% goto end
|
|
% ...
|
|
%
|
|
% 4. binary search switches have the form
|
|
%
|
|
% if (tag(var)) > 1) goto L23
|
|
% if (tag(var)) != 0) goto L1
|
|
% code for tag 0
|
|
% goto end
|
|
% L1: code for tag 1
|
|
% goto end
|
|
% L23: if (tag(var)) != 2) goto L3
|
|
% code for tag 2
|
|
% goto end
|
|
% L3: code for tag 3
|
|
% goto end
|
|
%
|
|
% Note that for a det switch with two tag values, try-me-else chains
|
|
% and try chains are equivalent.
|
|
|
|
% Which method is best depends on the number of possible tag values,
|
|
% on the costs of taken/untaken branches and table lookups on the given
|
|
% architecture, and on the frequency with which the various
|
|
% alternatives are taken.
|
|
%
|
|
% While the first two are in principle known at compile time,
|
|
% the third is not. Nevertheless, for switches on primary tags
|
|
% we can use the heuristic that the more secondary tags assigned to
|
|
% a primary tag, the more likely that the switch variable will have
|
|
% that primary tag at runtime.
|
|
%
|
|
% Try chains are good for switches with small numbers of alternatives
|
|
% on architectures where untaken branches are cheaper than taken
|
|
% branches.
|
|
%
|
|
% Try-me-else chains are good for switches with very small numbers of
|
|
% alternatives on architectures where taken branches are cheaper than
|
|
% untaken branches (which are rare these days).
|
|
%
|
|
% Jump tables are good for switches with large numbers of alternatives.
|
|
% The cost of jumping through a jump table is relatively high, since
|
|
% it involves a memory access and an indirect branch (which most
|
|
% current architectures do not handle well), but this cost is
|
|
% independent of the number of alternatives.
|
|
%
|
|
% Binary search switches are good for switches where the number of
|
|
% alternatives is large enough for the reduced expected number of
|
|
% branches executed to overcome the extra overhead of the subtraction
|
|
% required for some conditional branches (compared to try chains
|
|
% and try-me-else chains), but not large enough to make the
|
|
% expected cost of the expected number of comparisons exceed the
|
|
% expected cost of a jump table lookup and dispatch.
|
|
|
|
% For try-me-else chains, we want tag1 to be the most frequent case,
|
|
% tag 2 the next most frequent case, etc.
|
|
%
|
|
% For det try chains, we want the last tag value to be the most
|
|
% frequent case, since it can be reached without taken jumps.
|
|
% We want tag1 to be the next most frequent, tag2 the next most
|
|
% frequent after that, etc.
|
|
%
|
|
% For semidet try chains, there is no last possible tag value (the
|
|
% code for failure occupies its position), so we want tag1 to be
|
|
% the most frequent case, tag 2 the next most frequent case, etc.
|
|
%
|
|
% For jump tables, the position of the labels in the computed goto
|
|
% must conform to their numerical value. The order of the code
|
|
% fragments does not really matter, although the last has a slight
|
|
% edge in that no goto is needed to reach the code following the
|
|
% switch. If there is no code following the switch (which happens
|
|
% very frequently), then even this advantage is nullified.
|
|
%
|
|
% For binary search switches, we want the case of the most frequently
|
|
% occurring tag to be the first, since this code is reached with no
|
|
% taken branches and ends with an unconditional branch, whereas
|
|
% reaching the code of the other cases requires at least one taken
|
|
% *conditional* branch. In general, at each binary decision we
|
|
% want the more frequently reached cases to be in the half that
|
|
% immediately follows the if statement implementing the decision.
|
|
|
|
:- type switch_method ---> try_me_else_chain
|
|
; try_chain
|
|
; jump_table
|
|
; binary_search.
|
|
|
|
tag_switch__generate(Cases, Var, CodeModel, CanFail, SwitchGoalInfo, EndLabel,
|
|
!MaybeEnd, Code, !CI) :-
|
|
% group the cases based on primary tag value
|
|
% and find out how many constructors share each primary tag value
|
|
|
|
code_info__get_module_info(!.CI, ModuleInfo),
|
|
code_info__get_proc_info(!.CI, ProcInfo),
|
|
proc_info_vartypes(ProcInfo, VarTypes),
|
|
map__lookup(VarTypes, Var, Type),
|
|
switch_util__get_ptag_counts(Type, ModuleInfo,
|
|
MaxPrimary, PtagCountMap),
|
|
map__to_assoc_list(PtagCountMap, PtagCountList),
|
|
map__init(PtagCaseMap0),
|
|
switch_util__group_cases_by_ptag(Cases, PtagCaseMap0, PtagCaseMap),
|
|
|
|
map__count(PtagCaseMap, PtagsUsed),
|
|
code_info__get_globals(!.CI, Globals),
|
|
globals__lookup_int_option(Globals, dense_switch_size,
|
|
DenseSwitchSize),
|
|
globals__lookup_int_option(Globals, try_switch_size,
|
|
TrySwitchSize),
|
|
globals__lookup_int_option(Globals, binary_switch_size,
|
|
BinarySwitchSize),
|
|
( PtagsUsed >= DenseSwitchSize ->
|
|
PrimaryMethod = jump_table
|
|
; PtagsUsed >= BinarySwitchSize ->
|
|
PrimaryMethod = binary_search
|
|
; PtagsUsed >= TrySwitchSize ->
|
|
PrimaryMethod = try_chain
|
|
;
|
|
PrimaryMethod = try_me_else_chain
|
|
),
|
|
|
|
% We get a register for holding the tag. The tag is needed only
|
|
% by the switch, and no other code gets control between producing
|
|
% the tag value and all uses of it, so we can release the register
|
|
% for use by the code of the various cases.
|
|
|
|
% We forgo using the register if the primary tag is needed only once,
|
|
% or if the "register" we get is likely to be slower than
|
|
% recomputing the tag from scratch.
|
|
|
|
code_info__produce_variable_in_reg(Var, VarCode, VarLval, !CI),
|
|
VarRval = lval(VarLval),
|
|
code_info__acquire_reg(r, PtagReg, !CI),
|
|
code_info__release_reg(PtagReg, !CI),
|
|
(
|
|
PrimaryMethod \= jump_table,
|
|
PtagsUsed >= 2,
|
|
globals__lookup_int_option(Globals, num_real_r_regs,
|
|
NumRealRegs),
|
|
(
|
|
NumRealRegs = 0
|
|
;
|
|
( PtagReg = reg(r, PtagRegNo) ->
|
|
PtagRegNo =< NumRealRegs
|
|
;
|
|
error("improper reg in tag switch")
|
|
)
|
|
)
|
|
->
|
|
PtagCode = node([
|
|
assign(PtagReg, unop(tag, VarRval))
|
|
- "compute tag to switch on"
|
|
]),
|
|
PtagRval = lval(PtagReg)
|
|
;
|
|
PtagCode = empty,
|
|
PtagRval = unop(tag, VarRval)
|
|
),
|
|
|
|
% We generate FailCode and EndCode here because the last case within
|
|
% a primary tag may not be the last case overall.
|
|
|
|
code_info__get_next_label(FailLabel, !CI),
|
|
FailLabelCode = node([
|
|
label(FailLabel) -
|
|
"switch has failed"
|
|
]),
|
|
(
|
|
CanFail = cannot_fail,
|
|
FailCode = node([
|
|
goto(do_not_reached) - "oh-oh, det switch failed"
|
|
])
|
|
;
|
|
CanFail = can_fail,
|
|
code_info__generate_failure(FailCode, !CI)
|
|
),
|
|
LabelledFailCode = tree(FailLabelCode, FailCode),
|
|
|
|
EndCode = node([label(EndLabel) - "end of tag switch"]),
|
|
|
|
(
|
|
PrimaryMethod = binary_search,
|
|
switch_util__order_ptags_by_value(0, MaxPrimary, PtagCaseMap,
|
|
PtagCaseList),
|
|
tag_switch__generate_primary_binary_search(PtagCaseList,
|
|
0, MaxPrimary, PtagRval, VarRval, CodeModel, CanFail,
|
|
SwitchGoalInfo, EndLabel, FailLabel, PtagCountMap,
|
|
!MaybeEnd, CasesCode, !CI)
|
|
;
|
|
PrimaryMethod = jump_table,
|
|
switch_util__order_ptags_by_value(0, MaxPrimary, PtagCaseMap,
|
|
PtagCaseList),
|
|
tag_switch__generate_primary_jump_table(PtagCaseList,
|
|
0, MaxPrimary, VarRval, CodeModel, SwitchGoalInfo,
|
|
EndLabel, FailLabel, PtagCountMap, !MaybeEnd,
|
|
Labels, TableCode, !CI),
|
|
SwitchCode = node([
|
|
computed_goto(PtagRval, Labels) -
|
|
"switch on primary tag"
|
|
]),
|
|
CasesCode = tree(SwitchCode, TableCode)
|
|
;
|
|
PrimaryMethod = try_chain,
|
|
switch_util__order_ptags_by_count(PtagCountList, PtagCaseMap,
|
|
PtagCaseList0),
|
|
(
|
|
CanFail = cannot_fail,
|
|
PtagCaseList0 = [MostFreqCase | OtherCases]
|
|
->
|
|
list__append(OtherCases, [MostFreqCase], PtagCaseList)
|
|
;
|
|
PtagCaseList = PtagCaseList0
|
|
),
|
|
tag_switch__generate_primary_try_chain(PtagCaseList,
|
|
PtagRval, VarRval, CodeModel, CanFail, SwitchGoalInfo,
|
|
EndLabel, FailLabel, PtagCountMap, empty, empty,
|
|
!MaybeEnd, CasesCode, !CI)
|
|
;
|
|
PrimaryMethod = try_me_else_chain,
|
|
switch_util__order_ptags_by_count(PtagCountList, PtagCaseMap,
|
|
PtagCaseList),
|
|
tag_switch__generate_primary_try_me_else_chain(PtagCaseList,
|
|
PtagRval, VarRval, CodeModel, CanFail, SwitchGoalInfo,
|
|
EndLabel, FailLabel, PtagCountMap, !MaybeEnd,
|
|
CasesCode, !CI)
|
|
),
|
|
Code =
|
|
tree(VarCode,
|
|
tree(PtagCode,
|
|
tree(CasesCode,
|
|
tree(LabelledFailCode,
|
|
EndCode)))).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate a switch on a primary tag value using a try-me-else chain.
|
|
|
|
:- pred tag_switch__generate_primary_try_me_else_chain(ptag_case_list::in,
|
|
rval::in, rval::in, code_model::in, can_fail::in, hlds_goal_info::in,
|
|
label::in, label::in, ptag_count_map::in,
|
|
branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_primary_try_me_else_chain([], _, _, _, _, _, _, _, _, _,
|
|
_, _, !CI) :-
|
|
error("generate_primary_try_me_else_chain: empty switch").
|
|
tag_switch__generate_primary_try_me_else_chain([PtagGroup | PtagGroups],
|
|
TagRval, VarRval, CodeModel, CanFail, SwitchGoalInfo,
|
|
EndLabel, FailLabel, PtagCountMap, !MaybeEnd, Code, !CI) :-
|
|
PtagGroup = Primary - (StagLoc - StagGoalMap),
|
|
map__lookup(PtagCountMap, Primary, CountInfo),
|
|
CountInfo = StagLoc1 - MaxSecondary,
|
|
( StagLoc = StagLoc1 ->
|
|
true
|
|
;
|
|
error("secondary tag locations differ in generate_primary_try_me_else_chain")
|
|
),
|
|
( ( PtagGroups = [_|_] ; CanFail = can_fail ) ->
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
code_info__get_next_label(ElseLabel, !CI),
|
|
TestRval = binop(ne, TagRval,
|
|
unop(mktag, const(int_const(Primary)))),
|
|
TestCode = node([
|
|
if_val(TestRval, label(ElseLabel)) -
|
|
"test primary tag only"
|
|
]),
|
|
tag_switch__generate_primary_tag_code(StagGoalMap,
|
|
Primary, MaxSecondary, StagLoc, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel, !MaybeEnd,
|
|
TagCode, !CI),
|
|
ElseCode = node([
|
|
label(ElseLabel) -
|
|
"handle next primary tag"
|
|
]),
|
|
ThisTagCode =
|
|
tree(TestCode,
|
|
tree(TagCode,
|
|
ElseCode)),
|
|
( PtagGroups = [_|_] ->
|
|
code_info__reset_to_position(BranchStart, !CI),
|
|
tag_switch__generate_primary_try_me_else_chain(
|
|
PtagGroups, TagRval, VarRval, CodeModel,
|
|
CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, !MaybeEnd, OtherTagsCode, !CI),
|
|
Code = tree(ThisTagCode, OtherTagsCode)
|
|
;
|
|
% FailLabel ought to be the next label anyway,
|
|
% so this goto will be optimized away (unless the
|
|
% layout of the failcode in the caller changes).
|
|
FailCode = node([
|
|
goto(label(FailLabel)) -
|
|
"primary tag with no code to handle it"
|
|
]),
|
|
Code = tree(ThisTagCode, FailCode)
|
|
)
|
|
;
|
|
tag_switch__generate_primary_tag_code(StagGoalMap,
|
|
Primary, MaxSecondary, StagLoc, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel, !MaybeEnd, Code,
|
|
!CI)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate a switch on a primary tag value using a try chain.
|
|
|
|
:- pred tag_switch__generate_primary_try_chain(ptag_case_list::in,
|
|
rval::in, rval::in, code_model::in, can_fail::in, hlds_goal_info::in,
|
|
label::in, label::in, ptag_count_map::in, code_tree::in, code_tree::in,
|
|
branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_primary_try_chain([], _, _, _, _, _, _, _, _, _, _, _,
|
|
_, _, !CI) :-
|
|
error("empty list in generate_primary_try_chain").
|
|
tag_switch__generate_primary_try_chain([PtagGroup | PtagGroups],
|
|
TagRval, VarRval, CodeModel, CanFail, SwitchGoalInfo, EndLabel,
|
|
FailLabel, PtagCountMap, PrevTests0, PrevCases0,
|
|
!MaybeEnd, Code, !CI) :-
|
|
PtagGroup = Primary - (StagLoc - StagGoalMap),
|
|
map__lookup(PtagCountMap, Primary, CountInfo),
|
|
CountInfo = StagLoc1 - MaxSecondary,
|
|
( StagLoc = StagLoc1 ->
|
|
true
|
|
;
|
|
error("secondary tag locations differ in generate_primary_try_chain")
|
|
),
|
|
( ( PtagGroups = [_|_] ; CanFail = can_fail ) ->
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
code_info__get_next_label(ThisPtagLabel, !CI),
|
|
TestRval = binop(eq, TagRval,
|
|
unop(mktag, const(int_const(Primary)))),
|
|
TestCode = node([
|
|
if_val(TestRval, label(ThisPtagLabel)) -
|
|
"test primary tag only"
|
|
]),
|
|
LabelCode = node([
|
|
label(ThisPtagLabel) -
|
|
"this primary tag"
|
|
]),
|
|
tag_switch__generate_primary_tag_code(StagGoalMap,
|
|
Primary, MaxSecondary, StagLoc, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, TagCode, !CI),
|
|
PrevTests = tree(PrevTests0, TestCode),
|
|
PrevCases = tree(tree(LabelCode, TagCode), PrevCases0),
|
|
( PtagGroups = [_|_] ->
|
|
code_info__reset_to_position(BranchStart, !CI),
|
|
tag_switch__generate_primary_try_chain(PtagGroups,
|
|
TagRval, VarRval, CodeModel, CanFail,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, PrevTests, PrevCases,
|
|
!MaybeEnd, Code, !CI)
|
|
;
|
|
FailCode = node([
|
|
goto(label(FailLabel)) -
|
|
"primary tag with no code to handle it"
|
|
]),
|
|
Code = tree(PrevTests, tree(FailCode, PrevCases))
|
|
)
|
|
;
|
|
Comment = node([
|
|
comment("fallthrough to last tag value") - ""
|
|
]),
|
|
tag_switch__generate_primary_tag_code(StagGoalMap,
|
|
Primary, MaxSecondary, StagLoc, VarRval,
|
|
CodeModel, SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, TagCode, !CI),
|
|
Code =
|
|
tree(PrevTests0,
|
|
tree(Comment,
|
|
tree(TagCode,
|
|
PrevCases0)))
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate the cases for a primary tag using a dense jump table
|
|
% that has an entry for all possible primary tag values.
|
|
|
|
:- pred tag_switch__generate_primary_jump_table(ptag_case_list::in, int::in,
|
|
int::in, rval::in, code_model::in, hlds_goal_info::in,
|
|
label::in, label::in, ptag_count_map::in,
|
|
branch_end::in, branch_end::out, list(label)::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_primary_jump_table(PtagGroups, CurPrimary, MaxPrimary,
|
|
VarRval, CodeModel, SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, !MaybeEnd, Labels, Code, !CI) :-
|
|
( CurPrimary > MaxPrimary ->
|
|
( PtagGroups = [] ->
|
|
true
|
|
;
|
|
error("tag_switch__generate_primary_jump_table: " ++
|
|
"caselist not empty " ++
|
|
"when reaching limiting primary tag")
|
|
),
|
|
Labels = [],
|
|
Code = empty
|
|
;
|
|
NextPrimary = CurPrimary + 1,
|
|
( PtagGroups = [CurPrimary - PrimaryInfo | PtagGroups1] ->
|
|
PrimaryInfo = StagLoc - StagGoalMap,
|
|
map__lookup(PtagCountMap, CurPrimary, CountInfo),
|
|
CountInfo = StagLoc1 - MaxSecondary,
|
|
( StagLoc = StagLoc1 ->
|
|
true
|
|
;
|
|
error("secondary tag locations differ " ++
|
|
"in generate_primary_jump_table")
|
|
),
|
|
code_info__get_next_label(NewLabel, !CI),
|
|
LabelCode = node([
|
|
label(NewLabel) -
|
|
"start of a case in primary tag switch"
|
|
]),
|
|
( PtagGroups1 = [] ->
|
|
tag_switch__generate_primary_tag_code(
|
|
StagGoalMap, CurPrimary, MaxSecondary,
|
|
StagLoc, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, ThisTagCode, !CI)
|
|
;
|
|
code_info__remember_position(!.CI,
|
|
BranchStart),
|
|
tag_switch__generate_primary_tag_code(
|
|
StagGoalMap, CurPrimary, MaxSecondary,
|
|
StagLoc, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, ThisTagCode, !CI),
|
|
code_info__reset_to_position(BranchStart, !CI)
|
|
),
|
|
tag_switch__generate_primary_jump_table(PtagGroups1,
|
|
NextPrimary, MaxPrimary, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, !MaybeEnd, OtherLabels,
|
|
OtherCode, !CI),
|
|
Labels = [NewLabel | OtherLabels],
|
|
Code =
|
|
tree(LabelCode,
|
|
tree(ThisTagCode,
|
|
OtherCode))
|
|
;
|
|
tag_switch__generate_primary_jump_table(PtagGroups,
|
|
NextPrimary, MaxPrimary, VarRval, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, !MaybeEnd, OtherLabels, Code,
|
|
!CI),
|
|
Labels = [FailLabel | OtherLabels]
|
|
)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate the cases for a primary tag using a binary search.
|
|
% This invocation looks after primary tag values in the range
|
|
% MinPtag to MaxPtag (including both boundary values).
|
|
|
|
:- pred tag_switch__generate_primary_binary_search(ptag_case_list::in, int::in,
|
|
int::in, rval::in, rval::in, code_model::in, can_fail::in,
|
|
hlds_goal_info::in, label::in, label::in, ptag_count_map::in,
|
|
branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_primary_binary_search(PtagGroups, MinPtag, MaxPtag,
|
|
PtagRval, VarRval, CodeModel, CanFail, SwitchGoalInfo,
|
|
EndLabel, FailLabel, PtagCountMap, !MaybeEnd, Code, !CI) :-
|
|
( MinPtag = MaxPtag ->
|
|
CurPrimary = MinPtag,
|
|
( PtagGroups = [] ->
|
|
% there is no code for this tag
|
|
(
|
|
CanFail = can_fail,
|
|
string__int_to_string(CurPrimary, PtagStr),
|
|
string__append("no code for ptag ", PtagStr,
|
|
Comment),
|
|
Code = node([
|
|
goto(label(FailLabel)) -
|
|
Comment
|
|
])
|
|
;
|
|
CanFail = cannot_fail,
|
|
Code = empty
|
|
)
|
|
; PtagGroups = [CurPrimary - PrimaryInfo] ->
|
|
PrimaryInfo = StagLoc - StagGoalMap,
|
|
map__lookup(PtagCountMap, CurPrimary, CountInfo),
|
|
CountInfo = StagLoc1 - MaxSecondary,
|
|
( StagLoc = StagLoc1 ->
|
|
true
|
|
;
|
|
error("secondary tag locations differ " ++
|
|
"in generate_primary_jump_table")
|
|
),
|
|
tag_switch__generate_primary_tag_code(
|
|
StagGoalMap, CurPrimary, MaxSecondary, StagLoc,
|
|
VarRval, CodeModel, SwitchGoalInfo, EndLabel,
|
|
FailLabel, !MaybeEnd, Code, !CI)
|
|
;
|
|
error("caselist not singleton or empty " ++
|
|
"when binary search ends")
|
|
)
|
|
;
|
|
LowRangeEnd = (MinPtag + MaxPtag) // 2,
|
|
HighRangeStart = LowRangeEnd + 1,
|
|
InLowGroup = (pred(PtagGroup::in) is semidet :-
|
|
PtagGroup = Ptag - _,
|
|
Ptag =< LowRangeEnd
|
|
),
|
|
list__filter(InLowGroup, PtagGroups, LowGroups, HighGroups),
|
|
code_info__get_next_label(NewLabel, !CI),
|
|
string__int_to_string(MinPtag, LowStartStr),
|
|
string__int_to_string(LowRangeEnd, LowEndStr),
|
|
string__int_to_string(HighRangeStart, HighStartStr),
|
|
string__int_to_string(MaxPtag, HighEndStr),
|
|
string__append_list(["fallthrough for ptags ",
|
|
LowStartStr, " to ", LowEndStr], IfComment),
|
|
string__append_list(["code for ptags ", HighStartStr,
|
|
" to ", HighEndStr], LabelComment),
|
|
LowRangeEndConst = const(int_const(LowRangeEnd)),
|
|
TestRval = binop(>, PtagRval, LowRangeEndConst),
|
|
IfCode = node([
|
|
if_val(TestRval, label(NewLabel)) -
|
|
IfComment
|
|
]),
|
|
LabelCode = node([
|
|
label(NewLabel) -
|
|
LabelComment
|
|
]),
|
|
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
tag_switch__generate_primary_binary_search(LowGroups,
|
|
MinPtag, LowRangeEnd, PtagRval, VarRval, CodeModel,
|
|
CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, !MaybeEnd, LowRangeCode, !CI),
|
|
code_info__reset_to_position(BranchStart, !CI),
|
|
tag_switch__generate_primary_binary_search(HighGroups,
|
|
HighRangeStart, MaxPtag, PtagRval, VarRval, CodeModel,
|
|
CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
PtagCountMap, !MaybeEnd, HighRangeCode, !CI),
|
|
|
|
Code =
|
|
tree(IfCode,
|
|
tree(LowRangeCode,
|
|
tree(LabelCode,
|
|
HighRangeCode)))
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate the code corresponding to a primary tag.
|
|
% If this primary tag has secondary tags, decide whether we should
|
|
% use a jump table to implement the secondary switch.
|
|
|
|
:- pred tag_switch__generate_primary_tag_code(stag_goal_map::in, tag_bits::in,
|
|
int::in, stag_loc::in, rval::in, code_model::in, hlds_goal_info::in,
|
|
label::in, label::in, branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_primary_tag_code(GoalMap, Primary, MaxSecondary, StagLoc,
|
|
Rval, CodeModel, SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, Code, !CI) :-
|
|
map__to_assoc_list(GoalMap, GoalList),
|
|
(
|
|
StagLoc = none
|
|
->
|
|
% There is no secondary tag, so there is no switch on it
|
|
( GoalList = [-1 - Goal] ->
|
|
trace__maybe_generate_internal_event_code(Goal,
|
|
SwitchGoalInfo, TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode,
|
|
!CI),
|
|
goal_info_get_store_map(SwitchGoalInfo, StoreMap),
|
|
code_info__generate_branch_end(StoreMap, !MaybeEnd,
|
|
SaveCode, !CI),
|
|
GotoCode = node([
|
|
goto(label(EndLabel)) -
|
|
"skip to end of primary tag switch"
|
|
]),
|
|
Code =
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
tree(SaveCode,
|
|
GotoCode)))
|
|
; GoalList = [] ->
|
|
error("no goal for non-shared tag")
|
|
;
|
|
error("more than one goal for non-shared tag")
|
|
)
|
|
;
|
|
% There is a secondary tag, so figure out how to switch on it
|
|
code_info__get_globals(!.CI, Globals),
|
|
globals__lookup_int_option(Globals, dense_switch_size,
|
|
DenseSwitchSize),
|
|
globals__lookup_int_option(Globals, binary_switch_size,
|
|
BinarySwitchSize),
|
|
globals__lookup_int_option(Globals, try_switch_size,
|
|
TrySwitchSize),
|
|
( MaxSecondary >= DenseSwitchSize ->
|
|
SecondaryMethod = jump_table
|
|
; MaxSecondary >= BinarySwitchSize ->
|
|
SecondaryMethod = binary_search
|
|
; MaxSecondary >= TrySwitchSize ->
|
|
SecondaryMethod = try_chain
|
|
;
|
|
SecondaryMethod = try_me_else_chain
|
|
),
|
|
|
|
( StagLoc = remote ->
|
|
OrigStagRval = lval(field(yes(Primary), Rval,
|
|
const(int_const(0)))),
|
|
Comment = "compute remote sec tag to switch on"
|
|
;
|
|
OrigStagRval = unop(unmkbody, Rval),
|
|
Comment = "compute local sec tag to switch on"
|
|
),
|
|
|
|
code_info__acquire_reg(r, StagReg, !CI),
|
|
code_info__release_reg(StagReg, !CI),
|
|
(
|
|
SecondaryMethod \= jump_table,
|
|
MaxSecondary >= 2,
|
|
globals__lookup_int_option(Globals, num_real_r_regs,
|
|
NumRealRegs),
|
|
(
|
|
NumRealRegs = 0
|
|
;
|
|
( StagReg = reg(r, StagRegNo) ->
|
|
StagRegNo =< NumRealRegs
|
|
;
|
|
error("improper reg in tag switch")
|
|
)
|
|
)
|
|
->
|
|
StagCode = node([
|
|
assign(StagReg, OrigStagRval) -
|
|
Comment
|
|
]),
|
|
StagRval = lval(StagReg)
|
|
;
|
|
StagCode = empty,
|
|
StagRval = OrigStagRval
|
|
),
|
|
(
|
|
list__length(GoalList, GoalCount),
|
|
FullGoalCount = MaxSecondary + 1,
|
|
FullGoalCount = GoalCount
|
|
->
|
|
CanFail = cannot_fail
|
|
;
|
|
CanFail = can_fail
|
|
),
|
|
|
|
(
|
|
SecondaryMethod = jump_table,
|
|
tag_switch__generate_secondary_jump_table(GoalList,
|
|
0, MaxSecondary, CodeModel, SwitchGoalInfo,
|
|
EndLabel, FailLabel, !MaybeEnd, Labels,
|
|
CasesCode, !CI),
|
|
SwitchCode = node([
|
|
computed_goto(StagRval, Labels) -
|
|
"switch on secondary tag"
|
|
]),
|
|
Code = tree(SwitchCode, CasesCode)
|
|
;
|
|
SecondaryMethod = binary_search,
|
|
tag_switch__generate_secondary_binary_search(GoalList,
|
|
0, MaxSecondary, StagRval, CodeModel, CanFail,
|
|
SwitchGoalInfo, EndLabel, FailLabel, !MaybeEnd,
|
|
Code, !CI)
|
|
;
|
|
SecondaryMethod = try_chain,
|
|
tag_switch__generate_secondary_try_chain(GoalList,
|
|
StagRval, CodeModel, CanFail, SwitchGoalInfo,
|
|
EndLabel, FailLabel, empty, empty,
|
|
!MaybeEnd, Codes, !CI),
|
|
Code = tree(StagCode, Codes)
|
|
;
|
|
SecondaryMethod = try_me_else_chain,
|
|
tag_switch__generate_secondary_try_me_else_chain(
|
|
GoalList, StagRval, CodeModel, CanFail,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, Codes, !CI),
|
|
Code = tree(StagCode, Codes)
|
|
)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate a switch on a secondary tag value using a try-me-else chain.
|
|
|
|
:- pred tag_switch__generate_secondary_try_me_else_chain(stag_goal_list::in,
|
|
rval::in, code_model::in, can_fail::in, hlds_goal_info::in,
|
|
label::in, label::in, branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_secondary_try_me_else_chain([], _, _, _, _, _, _, _, _, _,
|
|
!CI) :-
|
|
error("generate_secondary_try_me_else_chain: empty switch").
|
|
tag_switch__generate_secondary_try_me_else_chain([Case0 | Cases0], StagRval,
|
|
CodeModel, CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, Code, !CI) :-
|
|
Case0 = Secondary - Goal,
|
|
goal_info_get_store_map(SwitchGoalInfo, StoreMap),
|
|
( ( Cases0 = [_|_] ; CanFail = can_fail ) ->
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
code_info__get_next_label(ElseLabel, !CI),
|
|
TestCode = node([
|
|
if_val(binop(ne, StagRval,
|
|
const(int_const(Secondary))),
|
|
label(ElseLabel))
|
|
- "test remote sec tag only"
|
|
]),
|
|
trace__maybe_generate_internal_event_code(Goal, SwitchGoalInfo,
|
|
TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode, !CI),
|
|
code_info__generate_branch_end(StoreMap, !MaybeEnd,
|
|
SaveCode, !CI),
|
|
GotoLabelCode = node([
|
|
goto(label(EndLabel)) -
|
|
"skip to end of secondary tag switch",
|
|
label(ElseLabel) -
|
|
"handle next secondary tag"
|
|
]),
|
|
ThisCode =
|
|
tree(TestCode,
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
tree(SaveCode,
|
|
GotoLabelCode)))),
|
|
( Cases0 = [_|_] ->
|
|
code_info__reset_to_position(BranchStart, !CI),
|
|
tag_switch__generate_secondary_try_me_else_chain(
|
|
Cases0, StagRval, CodeModel, CanFail,
|
|
SwitchGoalInfo, EndLabel, FailLabel, !MaybeEnd,
|
|
OtherCode, !CI),
|
|
Code = tree(ThisCode, OtherCode)
|
|
;
|
|
FailCode = node([
|
|
goto(label(FailLabel)) -
|
|
"secondary tag does not match"
|
|
]),
|
|
Code = tree(ThisCode, FailCode)
|
|
)
|
|
;
|
|
trace__maybe_generate_internal_event_code(Goal, SwitchGoalInfo,
|
|
TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode, !CI),
|
|
code_info__generate_branch_end(StoreMap, !MaybeEnd, SaveCode,
|
|
!CI),
|
|
GotoCode = node([
|
|
goto(label(EndLabel)) -
|
|
"skip to end of secondary tag switch"
|
|
]),
|
|
Code =
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
tree(SaveCode,
|
|
GotoCode)))
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate a switch on a secondary tag value using a try chain.
|
|
|
|
:- pred tag_switch__generate_secondary_try_chain(stag_goal_list::in, rval::in,
|
|
code_model::in, can_fail::in, hlds_goal_info::in, label::in, label::in,
|
|
code_tree::in, code_tree::in, branch_end::in, branch_end::out,
|
|
code_tree::out, code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_secondary_try_chain([], _, _, _, _, _, _, _, _, _, _, _,
|
|
!CI) :-
|
|
error("generate_secondary_try_chain: empty switch").
|
|
tag_switch__generate_secondary_try_chain([Case0 | Cases0], StagRval,
|
|
CodeModel, CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
PrevTests0, PrevCases0, !MaybeEnd, Code, !CI) :-
|
|
Case0 = Secondary - Goal,
|
|
goal_info_get_store_map(SwitchGoalInfo, StoreMap),
|
|
( ( Cases0 = [_|_] ; CanFail = can_fail ) ->
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
code_info__get_next_label(ThisStagLabel, !CI),
|
|
TestCode = node([
|
|
if_val(binop(eq, StagRval,
|
|
const(int_const(Secondary))),
|
|
label(ThisStagLabel))
|
|
- "test remote sec tag only"
|
|
]),
|
|
LabelCode = node([
|
|
label(ThisStagLabel) -
|
|
"handle next secondary tag"
|
|
]),
|
|
trace__maybe_generate_internal_event_code(Goal, SwitchGoalInfo,
|
|
TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode, !CI),
|
|
code_info__generate_branch_end(StoreMap, !MaybeEnd, SaveCode,
|
|
!CI),
|
|
GotoCode = node([
|
|
goto(label(EndLabel)) -
|
|
"skip to end of secondary tag switch"
|
|
]),
|
|
ThisCode =
|
|
tree(LabelCode,
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
tree(SaveCode,
|
|
GotoCode)))),
|
|
PrevTests = tree(PrevTests0, TestCode),
|
|
PrevCases = tree(ThisCode, PrevCases0),
|
|
( Cases0 = [_|_] ->
|
|
code_info__reset_to_position(BranchStart, !CI),
|
|
tag_switch__generate_secondary_try_chain(Cases0,
|
|
StagRval, CodeModel, CanFail, SwitchGoalInfo,
|
|
EndLabel, FailLabel, PrevTests, PrevCases,
|
|
!MaybeEnd, Code, !CI)
|
|
;
|
|
FailCode = node([
|
|
goto(label(FailLabel)) -
|
|
"secondary tag with no code to handle it"
|
|
]),
|
|
Code = tree(PrevTests, tree(FailCode, PrevCases))
|
|
)
|
|
;
|
|
trace__maybe_generate_internal_event_code(Goal, SwitchGoalInfo,
|
|
TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode, !CI),
|
|
code_info__generate_branch_end(StoreMap, !MaybeEnd, SaveCode,
|
|
!CI),
|
|
GotoCode = node([
|
|
goto(label(EndLabel)) -
|
|
"skip to end of secondary tag switch"
|
|
]),
|
|
Code =
|
|
tree(PrevTests0,
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
tree(SaveCode,
|
|
tree(GotoCode,
|
|
PrevCases0)))))
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate the cases for a primary tag using a dense jump table
|
|
% that has an entry for all possible secondary tag values.
|
|
|
|
:- pred tag_switch__generate_secondary_jump_table(stag_goal_list::in, int::in,
|
|
int::in, code_model::in, hlds_goal_info::in, label::in, label::in,
|
|
branch_end::in, branch_end::out, list(label)::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_secondary_jump_table(CaseList, CurSecondary, MaxSecondary,
|
|
CodeModel, SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, Labels, Code, !CI) :-
|
|
( CurSecondary > MaxSecondary ->
|
|
( CaseList = [] ->
|
|
true
|
|
;
|
|
error("caselist not empty when reaching " ++
|
|
"limiting secondary tag")
|
|
),
|
|
Labels = [],
|
|
Code = empty
|
|
;
|
|
NextSecondary = CurSecondary + 1,
|
|
( CaseList = [CurSecondary - Goal | CaseList1] ->
|
|
code_info__get_next_label(NewLabel, !CI),
|
|
LabelCode = node([
|
|
label(NewLabel) -
|
|
"start of case in secondary tag switch"
|
|
]),
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
trace__maybe_generate_internal_event_code(Goal,
|
|
SwitchGoalInfo, TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode, !CI),
|
|
goal_info_get_store_map(SwitchGoalInfo, StoreMap),
|
|
code_info__generate_branch_end(StoreMap,
|
|
!MaybeEnd, SaveCode, !CI),
|
|
( CaseList1 = [] ->
|
|
true
|
|
;
|
|
code_info__reset_to_position(BranchStart, !CI)
|
|
),
|
|
GotoCode = node([
|
|
goto(label(EndLabel)) -
|
|
"branch to end of tag switch"
|
|
]),
|
|
tag_switch__generate_secondary_jump_table(CaseList1,
|
|
NextSecondary, MaxSecondary, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, OtherLabels, OtherCode, !CI),
|
|
Labels = [NewLabel | OtherLabels],
|
|
Code =
|
|
tree(LabelCode,
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
tree(SaveCode,
|
|
tree(GotoCode,
|
|
OtherCode)))))
|
|
;
|
|
tag_switch__generate_secondary_jump_table(CaseList,
|
|
NextSecondary, MaxSecondary, CodeModel,
|
|
SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, OtherLabels, Code, !CI),
|
|
Labels = [FailLabel | OtherLabels]
|
|
)
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
% Generate the cases for a secondary tag using a binary search.
|
|
% This invocation looks after secondary tag values in the range
|
|
% MinPtag to MaxPtag (including both boundary values).
|
|
|
|
:- pred tag_switch__generate_secondary_binary_search(stag_goal_list::in,
|
|
int::in, int::in, rval::in, code_model::in, can_fail::in,
|
|
hlds_goal_info::in, label::in, label::in,
|
|
branch_end::in, branch_end::out, code_tree::out,
|
|
code_info::in, code_info::out) is det.
|
|
|
|
tag_switch__generate_secondary_binary_search(StagGoals, MinStag, MaxStag,
|
|
StagRval, CodeModel, CanFail, SwitchGoalInfo, EndLabel,
|
|
FailLabel, !MaybeEnd, Code, !CI) :-
|
|
( MinStag = MaxStag ->
|
|
CurSec = MinStag,
|
|
( StagGoals = [] ->
|
|
% there is no code for this tag
|
|
(
|
|
CanFail = can_fail,
|
|
string__int_to_string(CurSec, StagStr),
|
|
string__append("no code for ptag ", StagStr,
|
|
Comment),
|
|
Code = node([
|
|
goto(label(FailLabel)) -
|
|
Comment
|
|
])
|
|
;
|
|
CanFail = cannot_fail,
|
|
Code = empty
|
|
)
|
|
; StagGoals = [CurSec - Goal] ->
|
|
trace__maybe_generate_internal_event_code(Goal,
|
|
SwitchGoalInfo, TraceCode, !CI),
|
|
code_gen__generate_goal(CodeModel, Goal, GoalCode,
|
|
!CI),
|
|
goal_info_get_store_map(SwitchGoalInfo, StoreMap),
|
|
code_info__generate_branch_end(StoreMap, !MaybeEnd,
|
|
SaveCode, !CI),
|
|
Code =
|
|
tree(TraceCode,
|
|
tree(GoalCode,
|
|
SaveCode))
|
|
;
|
|
error("goallist not singleton or empty when binary search ends")
|
|
)
|
|
;
|
|
LowRangeEnd = (MinStag + MaxStag) // 2,
|
|
HighRangeStart = LowRangeEnd + 1,
|
|
InLowGroup = (pred(StagGoal::in) is semidet :-
|
|
StagGoal = Stag - _,
|
|
Stag =< LowRangeEnd
|
|
),
|
|
list__filter(InLowGroup, StagGoals, LowGoals, HighGoals),
|
|
code_info__get_next_label(NewLabel, !CI),
|
|
string__int_to_string(MinStag, LowStartStr),
|
|
string__int_to_string(LowRangeEnd, LowEndStr),
|
|
string__int_to_string(HighRangeStart, HighStartStr),
|
|
string__int_to_string(MaxStag, HighEndStr),
|
|
string__append_list(["fallthrough for stags ",
|
|
LowStartStr, " to ", LowEndStr], IfComment),
|
|
string__append_list(["code for stags ", HighStartStr,
|
|
" to ", HighEndStr], LabelComment),
|
|
LowRangeEndConst = const(int_const(LowRangeEnd)),
|
|
TestRval = binop(>, StagRval, LowRangeEndConst),
|
|
IfCode = node([
|
|
if_val(TestRval, label(NewLabel)) -
|
|
IfComment
|
|
]),
|
|
LabelCode = node([
|
|
label(NewLabel) -
|
|
LabelComment
|
|
]),
|
|
|
|
code_info__remember_position(!.CI, BranchStart),
|
|
tag_switch__generate_secondary_binary_search(LowGoals,
|
|
MinStag, LowRangeEnd, StagRval, CodeModel,
|
|
CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, LowRangeCode, !CI),
|
|
code_info__reset_to_position(BranchStart, !CI),
|
|
tag_switch__generate_secondary_binary_search(HighGoals,
|
|
HighRangeStart, MaxStag, StagRval, CodeModel,
|
|
CanFail, SwitchGoalInfo, EndLabel, FailLabel,
|
|
!MaybeEnd, HighRangeCode, !CI),
|
|
|
|
Code =
|
|
tree(IfCode,
|
|
tree(LowRangeCode,
|
|
tree(LabelCode,
|
|
HighRangeCode)))
|
|
).
|
|
|
|
%-----------------------------------------------------------------------------%
|