mirror of
https://github.com/Mercury-Language/mercury.git
synced 2026-04-23 13:23:47 +00:00
dadf30718d6084962be37dae8b94de41aaee90e2
13 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Zoltan Somogyi
|
aa2c89d12e | Update expected outputs for --debug bootchecks. | ||
|
Ian MacLarty
|
cab3c62fe7 |
Remove call depth numbers from standardized event printing.
Estimated hours taken: 2 Branches: main Remove call depth numbers from standardized event printing. This will make maintaining the debugger test cases easier since a lot of the expected outputs differ only in the call depth of their events, because of deep tracing of the standard library in the decldebug grade. Not all the debugger tests are run with standardized event printing, so printing of call depths will still be exercised. tests/debugger/breakpoints.exp tests/debugger/breakpoints.exp2 tests/debugger/browser_test.exp tests/debugger/exception_cmd.exp tests/debugger/exception_cmd.exp2 tests/debugger/exception_cmd.exp3 tests/debugger/exception_value.exp tests/debugger/exception_value.exp2 tests/debugger/exception_vars.exp tests/debugger/existential_type_classes.exp tests/debugger/existential_type_classes.exp2 tests/debugger/exported_eqv_type.exp tests/debugger/higher_order.exp tests/debugger/interpreter.exp2 tests/debugger/lambda_expr.exp tests/debugger/loopcheck.exp3 tests/debugger/loopcheck.inp2 tests/debugger/nondet_stack.exp tests/debugger/nondet_stack.exp2 tests/debugger/polymorphic_output.exp tests/debugger/polymorphic_output.exp2 tests/debugger/polymorphic_output.exp3 tests/debugger/print_goal.exp tests/debugger/print_table.exp tests/debugger/queens.exp tests/debugger/queens.exp2 tests/debugger/resume_typeinfos.exp tests/debugger/retry.exp tests/debugger/retry.exp2 tests/debugger/tabled_read.exp tests/debugger/tabled_read_decl.exp tests/debugger/tabled_read_unitize.exp tests/debugger/type_desc_test.exp tests/debugger/declarative/aadebug.exp tests/debugger/declarative/app.exp tests/debugger/declarative/args.exp tests/debugger/declarative/big.exp tests/debugger/declarative/filter.exp tests/debugger/declarative/if_then_else.exp tests/debugger/declarative/input_term_dep.exp tests/debugger/declarative/io_stream_test.exp tests/debugger/declarative/io_stream_test.exp2 tests/debugger/declarative/output_term_dep.exp tests/debugger/declarative/propositional.exp tests/debugger/declarative/remember_modes.exp tests/debugger/declarative/special_term_dep.exp tests/debugger/declarative/tabled_read_decl.exp tests/debugger/declarative/trust.exp Remove call depth numbers from output run with standardized event printing. trace/mercury_trace_internal.c Remove call depth from standardized event printing. |
||
|
Zoltan Somogyi
|
b816836f02 |
Optimize away stack slots storing dummy values; values of the io__state and
Estimated hours taken: 8
Branches: main
Optimize away stack slots storing dummy values; values of the io__state and
store__store types.
compiler/stack_alloc.m:
Allocate distinct negative stack slot numbers to values of dummy types.
We need
compiler/hlds_pred.m:
Add a predicate for testing whether a value is of a dummy type.
compiler/code_into.m:
When constructing the list of live locations after a call, do not
include the negative stack slots containing dummy values. The list
of live locations is used by the (future) native collector, which
should ignore dummy types, and by the debugger. The debugger can't
do anything with these dummy values on the stack except tell the
user about their existence, which doesn't do the debugger user any
good.
We still keep liveness information about dummy values in registers
at calls and returns, since both the procedural and declarative
debuggers need to know procedures' full argument lists.
With respect to the list of live locations before the call, which
was used only by the (now extinct) value numbering optimization,
filter out all dummy types, since their values need not be preserved.
compiler/trace.m:
Do not ask the code generator to preserve values of dummy types,
since doing so would require referring to negative stack slots.
compiler/unify_gen.m:
compiler/var_locn.m:
Fix a couple of situations in which we could refer to the negative
stack slots we now allocate to dummy values.
compiler/call_gen.m:
Reorder some code to make the source match what happens at runtime.
compiler/llds_out.m:
Fix the formatting of the sanity check for negative stack slots.
compiler/handle_options.m:
Since the --debug-opt-pred-id option is useless without --debug-opt,
make --debug-opt-pred-id option imply --debug-opt. This was useful
in debugging this diff.
trace/mercury_trace.c:
Adapt the test for whether a retry is across I/O. We used to base the
test on whether the retried predicate has any I/O state arguments,
and if so, whether the original I/O state variable is still around
on the stack. After this change, the answer to the second half of
that question would always be "no", so we now use only the first half:
whether the retried predicate has any I/O state arguments. This
requires us to consider more retries to be retries across I/O, but
from the point of view of a user who may not remember whether the I/O
predicate has done any I/O so far or not, is arguably more consistent
than our previous policy.
Allow retries even if a value of type store.store is missing, since
store.store is a dummy type just as io.state is.
trace/mercury_trace.c:
compiler/type_util.m:
Document the fact that you need to update both these files if you
want to modify the set of dummy types.
tests/debugger/retry.{inp,exp,exp2}:
Due to the change in mercury_trace.c, one retry in this test case
changes to being retry over I/O. Update the test input to force this
retry over I/O, and expect the expanded input to be echoed in the
output.
tests/debugger/nondet_stack.{exp,exp2}:
Update these expected outputs to account for the fact that we now need
fewer stack slots to hold old I/O states when debugging is enabled.
|
||
|
Ian MacLarty
|
1096808ff1 |
Fixed tests failing in grade asm_fast.gc.tr.debug.
Estimated hours taken: 1 Branches: main Fixed tests failing in grade asm_fast.gc.tr.debug. tests/debugger/print_table.exp2 Expected output when libraries compiled in debug grade. Since solutions/2 generates events in this grade, the depth of events inside a call to solutions/2 increases. tests/debugger/retry.exp2 Amended with additional tests that were added in the tabling diff on 2004/07/20. These changes were applied to retry.exp, but not retry.exp2. |
||
|
Zoltan Somogyi
|
7bf0cd03af |
Reduce the overhead of all forms of tabling by eliminating in many cases
Estimated hours taken: 32
Branches: main
Reduce the overhead of all forms of tabling by eliminating in many cases
the overhead of transferring data across the C/Mercury boundary. These
involve lots of control transfers as well as assignments to and from
Mercury abstract machine registers, which are not real machine registers
on x86 machines. Benchmarking in Uppsala revealed this overhead to be
a real problem.
The way we do that is by changing the tabling transformation so that instead
of generating sequences of calls to predicates from library/table_builtin.m,
we generate sequences of calls to C macros from runtime/mercury_tabling_pred.h,
and emit the resulting code string as the body of a foreign_proc goal.
(The old transformation is still available via a new option,
--no-tabling-via-extra-args.)
Since the number of inputs and outputs of the resulting C code sequences
are not always fixed (they can depend on the number of input or output
arguments of predicate being transformed), implementing this required
adding to foreign_procs a new field that allows the specification of extra
arguments to be passed to and from the given foreign code fragment. For now,
this mechanism is implemented only by the C backends, since it is needed
only by the C backends. (We don't support yet tabling on other backends.)
To simplify the new implementation of the field on foreign_procs, consolidate
three existing fields into one. Each of these fields was a list with one
element per argument, so turning them into a single list with a combined record
per argument should also improve reliability, since it reduces the likelyhood
of updates leaving the data structure inconsistent.
The goal paths of components of a tabled predicate depend on whether
-no-tabling-via-extra-args was specified. To enable the expected outputs
of the debugger test cases testing tabling, we add a new mdb command,
goal_paths, that controls whether goal paths are printed by the debugger
at events, and turn off the printing of events in the relevant test cases.
Also, prepare for a future change to optimize the trie structure for
user-defined types by handling type_infos (and once we support them,
typeclass_infos) specially.
compiler/table_gen.m:
Change the tabling transformation along the lines described above.
To allow us to factor out as much of the new code as possible,
we change the meaning of the call_table_tip variable for minimal
model subgoals: instead of the trie node at the end of the answer
table, it is not now the subgoal reachable from it. This change
has no effect as yet, because we use call_table_tip variables
only to perform resets across retries in the debugger, and we
don't do retries across calls to minimal model tabled predicates.
Put predicates into logical groups.
library/table_builtin.m:
runtime/mercury_tabling_preds.h:
When the new transformations in table_gen.m generate foreign_procs
with variable numbers of arguments, the interfaces of those
foreign_procs often do not match the interfaces of the existing
library predicates at their core: they frequently have one more
or one fewer argument. To prevent any possible confusion, in such
cases we add a new variant of the predicate. These predicates
have the suffix _shortcut in their name. Their implementations
are dummy macros that do nothing; they serve merely as placeholders
before or after which the macros that actually do the work are
inserted.
Move the definitions of the lookup, save and restore predicates
into mercury_tabling_preds.h. Make the naming scheme of their
arguments more regular.
runtime/mercury_minimal_model.c:
runtime/mercury_tabling_preds.h:
Move the definition of a predicate from mercury_minimal_model.c
to mercury_tabling_preds.h, since the compiler now needs to be
able to generate an inlined version of it.
compiler/hlds_goal.m:
Replace the three existing fields describing the arguments of
foreign_procs with one, and add a new field describing the extra
arguments that may be inserted by table_gen.m.
Add utility predicates for processing the arguments of foreign_procs.
Change the order of some existing groups of declarations make it
more logical.
compiler/hlds_pred.m:
runtime/mercury_stack_layout.h:
Extend the data structures recording the structure of tabling tries
to allow the representation of trie steps for type_infos and
typeclass_infos.
runtime/mercury_tabling_macros.c:
Fix a bug regarding the tabling of typeclass_infos, which is now
required for a clean compile.
compiler/pragma_c_gen.m:
compiler/ml_code_gen.m:
Modify the generation of code for foreign_procs to handle extra
arguments, and to conform to the new data structures for foreign_proc
arguments.
compiler/llds.m:
The tabling transformations can now generate significantly sized
foreign_procs bodies, which the LLDS code generator translates to
pragma_c instructions. Duplicating these by jump optimization
may lose more by worsening locality than it gains in avoiding jumps,
so we add an extra field to pragma_c instructions that tells jumpopt
not to duplicate code sequences containing such pragma_cs.
compiler/jumpopt.m:
Respect the new flag on pragma_cs.
compiler/goal_util.m:
Add a predicate to create foreign_procs with specified contents,
modelled on the existing predicate to create calls.
Change the order of the arguments of that existing predicate
to make it more logical.
compiler/polymorphism.m:
Conform to the new definition of foreign_procs. Try to simplify
the mechanism for generating the type_info and typeclass_info
arguments of foreign_proc goals, but it is not clear that this
code is even ever executed.
compiler/aditi_builtin_ops.m:
compiler/assertion.m:
compiler/bytecode_gen.m:
compiler/clause_to_proc.m:
compiler/code_gen.m:
compiler/code_info.m:
compiler/code_util.m:
compiler/constraint.m:
compiler/deep_profiling.m:
compiler/deforest.m:
compiler/delay_construct.m:
compiler/dependency_graph.m:
compiler/det_analysis.m:
compiler/det_report.m:
compiler/dnf.m:
compiler/dupelim.m:
compiler/equiv_type_hlds.m:
compiler/exprn_aux.m:
compiler/follow_code.m:
compiler/follow_vars.m:
compiler/frameopt.m:
compiler/goal_form.m:
compiler/goal_path.m:
compiler/higher_order.m:
compiler/higher_order.m:
compiler/hlds_module.m:
compiler/hlds_out.m:
compiler/inlining.m:
compiler/ite_gen.m:
compiler/layout_out.m:
compiler/livemap.m:
compiler/liveness.m:
compiler/llds_out.m:
compiler/loop_inv.m:
compiler/magic.m:
compiler/make_hlds.m:
compiler/mark_static_terms.m:
compiler/middle_rec.m:
compiler/modes.m:
compiler/modules.m:
compiler/opt_debug.m:
compiler/pd_cost.m:
compiler/prog_rep.m:
compiler/purity.m:
compiler/quantification.m:
compiler/reassign.m:
compiler/rl_exprn.m:
compiler/saved_vars.m:
compiler/simplify.m:
compiler/size_prof.m:
compiler/store_alloc.m:
compiler/stratify.m:
compiler/switch_detection.m:
compiler/term_pass1.m:
compiler/term_traversal.m:
compiler/termination.m:
compiler/trace.m:
compiler/typecheck.m:
compiler/unify_proc.m:
compiler/unique_modes.m:
compiler/unneeed_code.m:
compiler/unused_args.m:
compiler/use_local_vars.m:
Conform to the new definition of foreign_procs, pragma_cs and/or
table trie steps, or to changed argument orders.
compiler/add_heap_ops.m:
compiler/add_trail_ops.m:
compiler/cse_detection.m:
compiler/dead_proc_elim.m:
compiler/equiv_type.m:
compiler/intermod.m:
compiler/lambda.m:
compiler/lco.m:
compiler/module_util.m:
compiler/opt_util.m:
compiler/stack_opt.m:
compiler/trans_opt.m:
Conform to the new definition of foreign_procs.
Bring these modules up to date with our current code style guidelines,
using predmode declarations, state variable syntax and unification
expressions as appropriate.
compiler/mercury_compile.m:
Conform to the changed argument order of a predicate in trans_opt.m.
compiler/options.m:
Add the --no-tabling-via-extra-args option, but leave the
documentation commented out since the option is for developers only.
doc/user_guide.texi:
Document --no-tabling-via-extra-args option, though leave the
documentation commented out since the option is for developers only.
doc/user_guide.texi:
doc/mdb_categories:
Document the new goal_paths mdb command.
trace/mercury_trace_internals.c:
Implement the new goal_paths mdb command.
tests/debugger/completion.exp:
Conform to the presence of the goal_paths mdb command.
tests/debugger/mdb_command_test.inp:
Test the existence of documentation for the goal_paths mdb command.
tests/debugger/print_table.{inp,exp*}:
tests/debugger/retry.{inp,exp*}:
Use the goal_paths command to avoid having the expected output
depend on the presence or absence of --tabling-via-extra-args.
tests/tabling/table_foreign_output.{m,exp}:
Add a new test case to test the save/restore of arguments of foreign
types.
tests/tabling/Mmakefile:
Enable the new test case.
tests/tabling/test_tabling:
Make this script more robust.
Add an option for testing only the standard model forms of tabling.
|
||
|
Zoltan Somogyi
|
cdf0383b52 |
Fix a bunch of problems with tabling that I identified in Uppsala.
Estimated hours taken: 32
Branches: main
Fix a bunch of problems with tabling that I identified in Uppsala. These fall
into two categories.
First, the tabling transformations we were using were dividing work up
too finely. This had three bad effects. First, it caused too much time to be
spent on transmitting data to and from library predicates. Second, it made the
transformations hard to document and hard to explain in a paper. Third, it
caused us to misidentify just what the various forms of tabling have in common,
and what forms of tabling work for what determinisms. To fix this problem,
this diff reorients table_builtin.m and table_gen.m from being divided
primarily by determinism to being divided by evaluation method.
Second, we weren't being careful in separating out the parts of the tabling
data structures that are needed only for debugging the tabling system itself.
The fix for this is to introduce a new grade flag, MR_MINIMAL_MODEL_DEBUG,
intended for use by implementors only, to govern whether the tabling data
structures include debug-only components. (If this flag weren't a grade flag,
the sizes of data structures created in files with different values of this
flag could be inconsistent, which is something you don't want when debugging
the complex code of the tabling infrastructure.)
compiler/table_gen.m:
Reorganize the simple (loopcheck and memo) tabling transformations
completely. Instead of separate transformations for model_det and
model_semi predicates, have separate transformations for loopcheck
and memo predicates, since this makes it easier to see (and to ensure)
that the transformation follows the required scheme. Instead of
generating nested if-then-elses, generate switches when possible.
For model_semi loopcheck and memo predicates, generate Mercury code
that obeys our scope rules by not binding output variables in the
condition of the one remaining if-then-else.
Finetune the minimal model tabling transformation by combining some
operations where this improves clarity and performance.
Order the transformation predicates logically, and move the
documentation of each form of tabling next to the code implementing
that form of tabling.
Attach call_table_gen markers to the setup goals that now all
loopcheck, memo and minimal model tabled predicates have,
to avoid having to special case the last lookup goal, and to avoid
having to have separate code for lookups in call tables versus answer
tables.
Generate unique and more meaningful variable names. Change some
predicate names to be more meaningful, both here and in the
transformed code.
Factor out some common code, e.g. for generating lookup goals,
for generating instmap_deltas and for attaching hide_debug_event
markers to goals.
Report errors in cases where the arguments of a tabled predicate
aren't completely input or output.
compiler/hlds_pred.m:
Be more strict about the determinisms of tabled predicates; permit
only the determinisms we really support in all cases, and do not
permit the ones that may happen to work in some cases.
Conform to the change of the name of a builtin.
compiler/det_report.m:
Improve the error message for cases when the determinism is
incompatible with the selected tabling mechanism.
compiler/compile_target_code.m:
compiler/handle_options.m:
compiler/options.m:
Handle the new grade component.
library/private_builtin.m:
Provide a semipure analog of the imp predicate, a call to which makes
predicates semipure rather than impure, for use in table_builtin.m.
library/table_builtin.m:
runtime/mercury_tabling_preds.h:
Change the tabling primitives in the ways required by the changes to
the tabling transformations.
Group the primitives by the tabling methods they support, and change
their names to reflect this.
Change the implementation of each of the affected predicates to be
nothing more than the invocation of a macro defined in the new header
file runtime/mercury_tabling_preds.h. The objective of this change
is to make it possible for table_gen.m to replace sequences of calls
to predicates in table_builtin.m with a single extended foreign_proc
goal whose body just invokes the corresponding macros in sequence.
That change should improve performance by allowing the variables
that flow from one tabling primitive to another to stay in x86
registers, instead of being copied to and from Mercury abstract
machines registers, which on the x86 aren't real machine registers.
Benchmarking in Uppsala verified that this is a major cost.
Mark the foreign types used for tabling as can_pass_as_mercury_type;
this was the intended use of that assertion. Make them private to the
module, since the rest of the compiler can now handle this.
Delete the implementations of the predicates for duplicate checking
and for returning answers for completed subgoals. Profiling with gprof
has shown their performance to be critical to the performance of
minimal model tabling overall, and even with our recent changes,
the compiler still can't create optimal C code for them. They are
now implemented with handwritten code in mercury_minimal_model.c.
library/term.m:
Add two utility predicates for use by table_gen.m.
library/Mmakefile:
Since much of the implementation of table_builtin.m is now in
runtime/mercury_tabling_preds.h, make its object files depend
on that header file.
runtime/mercury_conf_params.h:
runtime/mercury_grade.h:
Include MR_MINIMAL_MODEL_DEBUG when computing the grade.
runtime/mercury_minimal_model.[ch]:
Add handwritten code to implement the predicates declared as external
in table_builtin.m.
Conform to the new names of the suspension and completion predicates.
Conform to the presence of debugging fields in tabling data structures
only if MR_MINIMAL_MODEL_DEBUG is defined.
Collect a lot more statistics than before.
Reorder some functions.
Instead of saving the whole generator stack each time, which the new
statistics showed to have O(n^2) behavior on some benchmarks, save only
the segment we need to save.
runtime/mercury_tabling.h:
Conform to the fact that loopcheck and memo predicates now have
separate sets of status values, and import mercury_tabling_preds.h.
runtime/mercury_tabling.c:
runtime/mercury_hash_lookup_or_add_body.h:
Move a huge macro out of mercury_tabling.c to the new file
mercury_hash_lookup_or_add_body.h for ease of editing, and modify it to
gather more statistics.
Make the statistics report easier to read.
runtime/Mmakefile:
Mention mercury_tabling_preds.h and mercury_hash_lookup_or_add_body.h.
runtime/mercury_wrapper.h:
Provide a mechanism (--tabling-statistics in MERCURY_OPTIONS)
that causes the runtime to print tabling statistics at the ends of
executions, for use in benchmarking.
doc/user_guide.texi:
Document --tabling-statistics. (Minimal model tabling is not yet
stable enough to be documented, which is why .dmm isn't documented
either.)
scripts/canonical_grade.sh-subr:
scripts/init_grade_options.sh-subr:
scripts/parse_grade_options.sh-subr:
scripts/mgnuc.in:
Implement the new grade component.
trace/mercury_trace.c:
trace/mercury_trace_internal.c:
Conform to changes in the runtime.
tests/debugger/*.m:
Avoid now invalid combinations of determinism and evaluation method.
tests/debugger/*.exp:
Conform to new goal paths in procedures transformed by tabling.
tests/tabling/*.m:
For tests which had predicate whose determinisms isn't compatible
with the evaluation method, change the determinism if possible,
and the evaluation method otherwise, if either is possible.
Bring these tests up to date with our coding guidelines, since they
may now appear in papers.
tests/tabling/Mmakefile:
Disable the tests whose combination of determinism and evaluation
method is no longer supported, and in which neither one can be changed.
tests/tabling/loopcheck_no_loop.{m,exp}:
Make this test case tougher.
tests/tabling/test_tabling:
Make this script more robust in the face of different kinds of
test case failures.
tests/invalid/loopcheck.{m,err_exp}:
tests/invalid/Mmakefile:
Test that we get the expected error message for an invalid combination
of determinism and evaluation method. The new test invalid/loopcheck.m
is the old test tabling/loopcheck.m.
tests/valid/Mmakefile:
Use a more general pattern to test for minimal model grades,
now that we also use .dmm as a grade component.
|
||
|
Zoltan Somogyi
|
a023af4380 |
Update to expect the new set of goal paths.
Estimated hours taken: 0.1 Branches: main tests/debugger/retry.exp2: Update to expect the new set of goal paths. |
||
|
Simon Taylor
|
61a05131ac |
Add an option `--no-inline-builtins', which causes builtins to
Estimated hours taken: 8
Branches: main
Add an option `--no-inline-builtins', which causes builtins to
be generated as calls to out-of-line procedures. This is done
by default when debugging, as without this option the execution
of builtins is not traced.
On earth, a compiler built in grade asm_fast.gc.tr.debug
takes 36.8s to run `mmc -C -I ../analysis/ hlds.make_hlds'.
When the compiler is built with `--no-inline-builtins',
this is increased to 38.6s.
The size of the compiler built in grade asm_fast.gc.tr.debug
increases from 45.0MB to 46.6MB.
compiler/options.m:
Add the option.
compiler/code_util.m:
Work out whether builtins should be generated inline.
compiler/handle_options.m:
Disable inlining of builtins when debugging.
compiler/simplify.m:
compiler/higher_order.m:
compiler/modes.m:
code_util__builtin_state now needs to know where the
builtin is being called from to know whether a particular
call should be treated as an inline builtin. The "recursive"
calls from the automatically generated procedures for each
builtin should always be generated inline, or else we would
generate an infinite loop.
NEWS:
doc/user_guide.texi:
compiler/notes/todo.html:
Document the change.
tests/debugger/Mmakefile:
tests/debugger/no_inline_builtins.{m,exp,inp}:
Test case.
tests/debugger/*.{inp,exp,exp2}:
tests/debugger/declarative/*.{inp,exp,exp2}:
Update due to changed event numbers.
tests/debugger/lval_desc_array.inp:
Use a less brittle method for stepping to the point in
the program where the test needs to display variables.
tests/debugger/declarative/library_forwarding.m:
tests/debugger/declarative/*.m:
Add forwarding predicates for some library predicates
and functions so that the declarative debugger doesn't
ask different questions depending on whether or not
the library was compiled with debugging enabled.
|
||
|
Ralph Becket
|
a8ffd3680c |
Change the compiler and tools so that .' and not :' is now used as the
Estimated hours taken: 14 Branches: main Change the compiler and tools so that `.' and not `:' is now used as the module separator in all output. Infix `.' now has associativity yfx and priority 10. NEWS: Report the change. configure.in: Amend the test for an up-to-date Mercury compiler to check whether it recognises `.' as a module qualifier. compiler/code_gen.m: compiler/error_util.m: compiler/hlds_out.m: compiler/prog_out.m: compiler/prog_util.m: compiler/rl_exprn.m: compiler/rl_gen.m: compiler/source_file_map.m: compiler/unused_args.m: library/io.m: library/rtti_implementation.m: library/type_desc.m: runtime/mercury_debug.c: runtime/mercury_deconstruct.c: runtime/mercury_stack_trace.c: Change `:' to `.' as module separator for output. compiler/mercury_to_mercury.m: compiler/prog_io_typeclass.m: As above. Fixed a bug where `.' was not being recognised as a module separator. doc/reference_manual.texi: Report the change. library/term_io.m: Ensure that infix `.' is written without surrounding spaces. tests/hard_coded/dot_separator.m: tests/hard_coded/dot_separator.exp: tests/hard_coded/Mmakefile: Test case added. |
||
|
Zoltan Somogyi
|
5345fa4643 |
Fix (most of) the expected outputs of the debugger test cases after my recent
Estimated hours taken: 2 Branches: main Fix (most of) the expected outputs of the debugger test cases after my recent changes. In some cases, this involved modifying the input scripts to make tests less dependent on event numbers. tests/debugger/Mmakefile: Use MDB_STD instead of MDB for more test cases than before. Disable the output_term_dep test case, since it doesn't actually test anything that the other test cases don't test, and it prints so many events that its .exp files depend on event numbers far too much. tests/debugger/*.exp*: tests/debugger/*.inp: Update expected outputs, and in some cases, the inputs. |
||
|
Simon Taylor
|
07c0cf8ba6 |
Improve variable naming in the debugger. Where possible, use
Estimated hours taken: 10 Branches: main Improve variable naming in the debugger. Where possible, use the user's argument names rather than `HeadVar__N'. compiler/clause_to_proc.m: Use the user's names for the arguments of `:- pragma foreign_proc' procedures. compiler/simplify.m: When performing excess assignment elimination with `--trace deep', don't replace a variable with a meaningful name with `HeadVar__N' or an unnamed variable. compiler/trace_params.m: Add a predicate `trace_level_needs_meaningful_var_names' for use by simplify.m. compiler/typecheck.m: For predicates with a single clause, attempt to replace the `HeadVar__N' variables with the user's original head variables. trace/mercury_trace_declarative.c: trace/mercury_trace_vars.c: Don't assume head variables have names of the form `HeadVar__N'. Print the argument number when printing the names of head variables. tests/debugger/browser_test.inp: tests/debugger/completion.inp: Change names of variables in `print' commands. tests/debugger/*.exp: tests/debugger/*.exp2: tests/debugger/declarative/dependency.exp: tests/invalid/aditi_errors.err_exp: tests/invalid/mode_inf.err_exp: tests/invalid/record_syntax_errors.err_exp: Update expected output. |
||
|
Simon Taylor
|
4401a8e53e |
I forgot to update the `.exp2' files in tests/debugger when I updated
Estimated hours taken: 0.1 I forgot to update the `.exp2' files in tests/debugger when I updated the `.exp' files for my changes to tabling. tests/debugger/loopcheck.exp2: tests/debugger/retry.exp2: Adjust the expected output. The change to ensure that `call_table_gen' goal features can't be removed alters the goal paths slightly. |
||
|
Mark Brown
|
250a3026da |
Update the expected output for these test cases in debug grades,
Estimated hours taken: 0.2 tests/debugger/*.exp2: tests/debugger/declarative/*.exp2: Update the expected output for these test cases in debug grades, after Zoltan's recent change to `retry'. |