runtime/*.[ch]:
trace/*.[chyl]:
As above. In some places, improve comments, e.g. by expanding contractions
such as "we've". Add #ifndef guards against double inclusion around
the trace/*.h files that did not already have them.
tools/*:
Make the corresponding changes in shell scripts that generate .[ch] files
in the runtime.
tests/*:
Conform to a slight change in the text of a message.
Branches: main
Allow the use of Mercury abstract machine float registers for passing
double-precision float arguments in higher order calls.
In of itself this is not so useful for typical Mercury code. However, as
all non-local procedures are potentially the targets of higher order calls,
without this change first order calls to non-local procedures could not use
float registers either. That is the actual motivation for this change.
The basic mechanism is straightforward. As before, do_call_closure_* is
invoked to place the closure's hidden arguments into r1, ..., rN, and extra
input arguments shifted into rN+1, etc. With float registers, extra input
arguments may also be in f1, f2, etc. and the closure may also have hidden
float arguments. Optimising for calls, we order the closure's hidden
arguments so that all float register arguments come after all regular
register arguments in the vector. Having the arguments out of order does
complicate code which needs to deconstruct closures, but that is not so
important.
Polymorphism complicates things. A closure with type pred(float) may be
passed to a procedure expecting pred(T). Due to the `float' argument type,
the closure expects its argument in a float register. But when passed to the
procedure, the polymorphic argument type means it would be called with the
argument in a regular register.
Higher-order insts already contain information about the calling convention,
without which a higher-order term cannot be called. We extend higher-order
insts to include information about the register class required for each
argument. For example, we can distinguish between:
pred(in) is semidet /* arg regs: [reg_f] */
and
pred(in) is semidet /* arg regs: [reg_r] */
Using this information, we can create a wrapper around a higher-order
variable if it appears in a context requiring a different calling convention.
We do this in a new HLDS pass, called float_regs.m.
Note: Mercury code has a tendency to lose insts for higher-order terms, then
"recover" them by hacky means. The float_regs pass depends on higher-order
insts; it is impossible to create a wrapper for a procedure without knowing
how to call it. The float_regs pass will report errors which we otherwise
accepted, due to higher-order insts being unavailable. It should be possible
for the user to adjust the code to satisfy the pass, though the user may not
understand why it should be necessary. In most cases, it probably really
*is* unnecessary. We may be able to make the float_regs pass more tolerant
of missing higher-order insts in the future.
Class method calls do not use float registers because I didn't want to deal
with them yet.
compiler/options.m:
compiler/handle_options.m:
Always enable float registers in low-level C grades when floats are
wider than a word.
compiler/make_hlds_passes.m:
Always allow double word floats to be stored unboxed in cells on C
grades.
compiler/hlds_goal.m:
Add an extra field to `generic_call' which gives the register class
to use for each argument. This is set by the float_regs pass.
compiler/prog_data.m:
Add an extra field to `pred_inst_info' which records the register class
to use for each argument. This is set by the float_regs pass.
compiler/hlds_pred.m:
Add a field to `proc_sub_info' which lists the headvars which must be
passed via regular registers despite their types.
Add a field to `pred_sub_info' to record the original unsubstituted
argument types for instance method predicates.
compiler/check_typeclass.m:
In the pred_info of an instance method predicate, record the original
argument types before substituting the type variables for the instance.
compiler/float_regs.m:
compiler/transform_hlds.m:
Add the new HLDS pass.
compiler/mercury_compile_middle_passes.m:
Run the new pass if float registers are enabled.
compiler/lambda.m:
Export the predicate to produce a predicate from a lambda.
This is reused by float_regs.m to create wrapper closures.
Add an argument to `expand_lambda' to set the reg_r_headvars field on
the newly created procedure.
Delete some unused fields from `lambda_info'.
compiler/arg_info.m:
Make `generate_proc_arg_info' no longer always use regular registers
for calls to exported procedures. Do always use regular registers for
class methods calls.
Add a version of `make_arg_infos' which takes an explicit list of
argument registers. Rename the previous version.
Add `generic_call_arg_reg_types' to return the argument registers
for a generic call.
Add a version of `compute_in_and_out_vars' which additionally separates
arguments for float and regular registers.
compiler/call_gen.m:
Use float registers for argument passing in higher-order calls, as
directed by the new field in `generic_call'.
compiler/code_util.m:
Add a function to encode the number of regular and float register
arguments when making a higher-order call.
compiler/llds.m:
Say that the `do_call_closure_N' functions only work for zero float
register arguments.
compiler/follow_vars.m:
compiler/interval.m:
Account for the use of float registers by generic call goals in these
passes.
compiler/unify_gen.m:
Move float register arguments to the end of a closure's hidden
arguments vector, after regular register arguments.
Count hidden regular and float register arguments separately, but
encode them in the same word in the closure. This is preferable to
using two words because it reduces the differences between grades
with and without float registers present.
Disable generating code which creates a closure from an existing
closure, if float registers exist. That code does not understand the
reordered hidden arguments vector yet.
compiler/continuation_info.m:
Replace an argument's type_info in the closure layout if the argument
is a float *and* is passed via a regular register, when floats are
normally passed via float registers. Instead, give it the type_info
for `private_builtin.float_box'.
compiler/builtin_lib_types.m:
Add function to return the type of `private_builtin.float_box/0'.
compiler/hlds_out_goal.m:
compiler/hlds_out_pred.m:
compiler/mercury_to_mercury.m:
Dump the new fields added to `generic_call', `pred_inst_info' and
`proc_sub_info'.
compiler/prog_type.m:
Add helper predicate.
compiler/*.m:
Conform to changes.
library/private_builtin.m:
Add a type `float_box'.
runtime/mercury_ho_call.h:
Describe the modified closure representation.
Rename the field which counts the number of hidden arguments to prevent
it being used incorrectly, as it now encodes two numbers (potentially).
Add macros to unpack the encoded field.
runtime/mercury_ho_call.c:
Update the description of how higher-order calls work.
Update code which extracts closure arguments to take account the
arguments being reordered in the hidden arguments vector.
runtime/mercury_deep_copy.c:
runtime/mercury_deep_copy_body.h:
runtime/mercury_layout_util.c:
runtime/mercury_ml_expand_body.h:
Update code which extracts closure arguments to take account the
arguments being reordered in the hidden arguments vector.
runtime/mercury_type_info.c:
runtime/mercury_type_info.h:
Add helper function.
tools/make_spec_ho_call:
Update the generated do_call_closure_* functions to place float
register arguments.
tests/hard_coded/Mercury.options:
tests/hard_coded/Mmakefile:
tests/hard_coded/ho_float_reg.exp:
tests/hard_coded/ho_float_reg.m:
Add new test case.
tests/hard_coded/copy_pred.exp:
tests/hard_coded/copy_pred.m:
tests/hard_coded/deconstruct_arg.exp:
tests/hard_coded/deconstruct_arg.exp2:
tests/hard_coded/deconstruct_arg.m:
Extend test cases with float arguments in closures.
tests/debugger/higher_order.exp2:
Add alternative output, changed due to closure wrapping.
tests/hard_coded/ho_univ_to_type.m:
Adjust test case so that the float_regs pass does not report errors
about missing higher-order insts.
compiler/notes/compiler_design.html:
Describe the new module.
Delete a duplicated paragraph.
compiler/notes/todo.html:
TODO:
Delete one hundred billion year old todos.
Branches: main, 10.04
Fix bug #67, where mprof would abort due to multiple lines in the Prof.Decl
file having the same entry label.
The cause was the files runtime/mercury_ho_call_inits.i and
runtime/mercury_method_call_inits.i being generated with duplicate
MR_init_entry_an() lines. That could happen if parallel make is used in the
runtime directory. Due to bad makefile rules, the command which generates
the files (as side-effects) would be invoked multiple times, concurrently.
Finally, as those files weren't generated atomically, the concurrent
invocations would append duplicate lines to the files.
runtime/Mmakefile:
Don't list multiple outputs as the result of the make_spec_ho_call and
make_spec_method_call commands, which is the same as writing multiple
independent rules, one for each output.
Don't mention the *_declares.i and *_inits.i files at all.
They will be created when the *_codes.i files are created.
The downside is, if they are removed (and *_codes.i are not), then
make will not know how to generate them.
tools/make_spec_ho_call:
tools/make_spec_method_call:
Make these scripts generate the *_declares.i and *_inits.i files
atomically (not strictly necessary with the previous change).
Estimated hours taken: 3
Branches: main
Auto-generate the code for performing higher order calls and method calls.
This way, we can vary the number of explicit arguments we specialize for
independently of the number of hidden arguments we specialize for.
(Previously, we did not specialize on the number of hidden arguments at all.)
tools/make_spec_ho_call:
A new script to auto-generate the code for performing higher order
calls.
tools/make_spec_method_call:
A new script to auto-generate the code for performing method calls.
runtime/mercury_ho_call.c:
Replace the old handwritten code for performing higher order and
method calls with #includes of the auto-generated files.
runtime/Mmakefile:
Make the object files of mercury_ho_call.c depend on the auto-generated
files, and through them, on the scripts.
compiler/options.m:
Conform to the new parameters in the scripts.
