142 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	d609181cb9	Consider types of the form ... Estimated hours taken: 30 Branches: main Consider types of the form :- type x ---> f. to be dummy types, since they contain no information. Optimize them the same way we currently optimize io.state and store.store. runtime/mercury_type_info.h: Add a new type_ctor_rep for dummy types. runtime/mercury_tabling.h: Add a representation for "tabled" dummy types, which don't actually have a level in the trie, so that the runtime system can handle that fact. runtime/mercury_ml_expand_body.h: When deconstructing a value of a dummy type, ignore the actual value (since it will contain garbage) and instead return the only possible value of the type. runtime/mercury_construct.c: runtime/mercury_deconstruct.c: runtime/mercury_deep_copy_body.c: runtime/mercury_tabling.c: runtime/mercury_unify_compare_body.h: library/rtti_implementation.m: Handle the type_ctor_rep of dummy types. runtime/mercury_builtin_types.c: Provide a place to record profiling information about unifications and comparisons for dummy types. runtime/mercury_mcpp.h: java/runtime/TypeCtorRep.java: library/private_builtin.m: Add a new type_ctor_rep for dummy types, and fix some previous discrepancies in type_ctor_reps. mdbcomp/prim_data.m: Move a bunch of predicates for manipulating special_pred_ids here from the browser and compiler directories. Rename the function symbols of the special_pred_id type to avoid the need to parenthesize the old `initialise' function symbol. Convert to four-space indentation. mdbcomp/rtti_access.m: Don't hardcode the names of special preds: use the predicates in prim_data.m. Convert to four-space indentation. browser/declarative_execution.m: Delete some predicates whose functionality is now in mdbcomp/prim_data.m. compiler/hlds_data.m: Replace the part of du type that says whether a type an enum, which used to be a bool, with something that also says whether the type is a dummy type. Convert to four-space indentation. compiler/make_tags.m: Compute the value for the new field of du type definitions. compiler/hlds_out.m: Write out the new field of du type definitions. compiler/rtti.m: Modify the data structures we use to create type_ctor_infos to allow for dummy types. Convert to four-space indentation. compiler/type_ctor_info.m: Modify the code that generates type_ctor_infos to handle dummy types. compiler/type_util.m: Provide predicates for recognizing dummy types. Convert to four-space indentation. compiler/unify_proc.m: Generate the unify and compare predicates of dummy types using a new code scheme that avoids referencing arguments that contain garbage. When generating code for unifying or comparing other types, ignore any arguments of function symbols that are dummy types. Don't use DCG style access predicates. compiler/higher_order.m: Specialize the unification and comparison of values of dummy types. Break up an excessively large predicate, and factor out common code from the conditions of a chain of if-then-elses. compiler/llds.m: For each input and output of a foreign_proc, include a field saying whether the value is of a dummy type. compiler/pragma_c_gen.m: Fill in the new fields in foreign_proc arguments. compiler/hlds_goal.m: Rename some predicates for constructing unifications to avoid unnecessary ad-hoc overloading. Clarify their documentation. Rename a predicate to make clear the restriction on its use, and document the restriction. Add a predicate for creating simple tests. Add a utility predicate for setting the context of a goal directly. compiler/modules.m: Include dummy types interface files, even if they are private to the module. This is necessary because with the MLDS backend, the generated code inside the module and outside the module must agree whether a function returning a value of the type returns a real value or a void value, and this requires them to agree on whether the type is dummy or not. The impact on interface files is minimal, since very few types are dummy types, and changing a type from a dummy type to a non-dummy type or vice versa is an ever rarer change. compiler/hlds_pred.m: Provide a representation in the compiler of the trie step for dummy types. compiler/layout_out.m: Print the trie step for dummy types. compiler/table_gen.m: Don't table values of dummy types, and record the fact that we don't by including a dummy trie step in the list of trie steps. compiler/add_pragma.m: compiler/add_special_pred.m: compiler/add_type.m: compiler/aditi_builtin_ops.m: compiler/bytecode.m: compiler/bytecode_gen.m: compiler/code_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/det_report.m: compiler/exception_analysis.m: compiler/inst_match.m: compiler/livemap.m: compiler/llds_out.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_il.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/opt_util.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/qual_info.m: compiler/rl.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/rtti_out.m: compiler/simplify.m: compiler/size_prof.m: compiler/term_constr_initial.m: compiler/term_constr_util.m: compiler/term_norm.m: compiler/termination.m: compiler/trace.m: compiler/typecheck.m: compiler/unify_gen.m: Conform to the changes above. compiler/export.m: compiler/exprn_aux.m: compiler/foreign.m: compiler/polymorphism.m: compiler/proc_label.m: compiler/rtti_to_mlds.m: compiler/special_pred.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/state_var.m: compiler/switch_util.m: compiler/trace_params.m: Conform to the changes above. Convert to four-space indentation. compiler/mlds_to_java.m: compiler/var_locn.m: Conform to the changes above, which requires threading the module_info through the module. Convert to four-space indentation. compiler/mercury_compile.m: Pass the module_info to mlds_to_java.m. compiler/ml_util.m: compiler/polymorphism.m: compiler/type_ctor_info.m: compiler/type_util.m: Delete some previously missed references to the temporary types used to bootstrap the change to the type_info type's arity. compiler/polymorphism.m: Turn back on an optimization that avoids passing parameters (such as type_infos) to foreign_procs if they are not actually referred to. compiler/prog_data.m: Convert to four-space indentation. library/svvarset.m: Add a missing predicate. trace/mercury_trace.c: Delete the unused function that used to check for dummy types. tests/debugger/field_names.{m,inp,exp}: Add to this test case a test of the handling of dummy types. Check that their values can be printed out during normal execution, and that the debugger doesn't consider them live nondummy variables, just as it doesn't consider I/O states live nondummy variables.	2005-10-05 06:34:27 +00:00
Zoltan Somogyi	b54ab42d70	A simple tool for performing substitutions on the source files of the ... Estimated hours taken: 0.5 Branches: main tools/subst: A simple tool for performing substitutions on the source files of the compiler. compiler/*.m: Change the names of the get predicates operating on module_infos to include "get" in the name, for uniformity. This was done mostly by the following sed script, with some manual cleanup afterwards to reduce excessive line lengths. s/module_info_types/module_info_get_type_table/ s/module_info_set_types/module_info_set_type_table/ s/module_info_insts/module_info_get_inst_table/ s/module_info_set_insts/module_info_set_inst_table/ s/module_info_modes/module_info_get_mode_table/ s/module_info_set_modes/module_info_set_mode_table/ s/module_info_ctors/module_info_get_cons_table/ s/module_info_set_ctors/module_info_set_cons_table/ s/module_info_classes/module_info_get_class_table/ s/module_info_set_classes/module_info_set_class_table/ s/module_info_instances/module_info_get_instance_table/ s/module_info_set_instances/module_info_set_instance_table/ s/module_info_superclasses/module_info_get_superclass_table/ s/module_info_set_superclasses/module_info_set_superclass_table/ s/module_info_assertion_table/module_info_get_assertion_table/ s/module_info_exclusive_table/module_info_get_exclusive_table/ s/module_info_ctor_field_table/module_info_get_ctor_field_table/ s/module_info_name/module_info_get_name/ s/module_info_globals/module_info_get_globals/ s/module_info_contains_foreign_types/module_info_get_contains_foreign_types/ s/module_info_num_errors/module_info_get_num_errors/ s/module_info_type_ctor_gen_infos/module_info_get_type_ctor_gen_infos/ s/module_info_stratified_preds/module_info_get_stratified_preds/ s/module_info_unused_arg_info/module_info_get_unused_arg_info/ s/module_info_exception_info/module_info_get_exception_info/ s/module_info_type_spec_info/module_info_get_type_spec_info/ s/module_info_no_tag_types/module_info_get_no_tag_types/ s/module_info_analysis_info/module_info_get_analysis_info/ s/module_info_aditi_top_down_procs/module_info_get_aditi_top_down_procs/	2005-09-30 08:08:49 +00:00
Zoltan Somogyi	df0d9036cf	Optimize calls that would be tail calls in Prolog but are followed by ... Estimated hours taken: 40 Branches: main Optimize calls that would be tail calls in Prolog but are followed by construction unifications in Mercury: last call modulo construction. For now, the optimization is available only for the LLDS backend. compiler/lco.m: Turn this module from a placeholder to a real implementation of the optimization. compiler/hlds_goal.m: Allow lco.m to attach to construction unifications a note that says that certain arguments, instead of being filled in by the unification, should have their addresses taken and stored in the corresponding variables. Group this note together with the note that asks for term size profiling to avoid an increase in the sizes of goals in the compiler in most cases. compiler/hlds_pred.m: Provide a predicate for setting the name of a predicate after its creation. This functionality is used by lco.m. Extend the pred_transformation part of the pred_origin type to allow it to express that a procedure was created by lco.m. List the new primitive store_at_ref as a no-typeinfo builtin. Fix some problems with indentation. compiler/layout_out.m: Handle the new pred_transformation. compiler/unify_gen.m: When processing construction unifications that have the new feaure turned on, perform the requested action. Fix some departures from coding style. Shorten lines by deleting unnecessary module qualifications. Add some auxiliary predicates to make the code easier to read. compiler/var_locn.m: Fix an earlier oversight: when materializing variables inside rvals and lvals, look inside memory references too. Previously, the omission didn't matter, since we didn't generate such references, but now we do. Fix some departures from coding style. compiler/llds_out.m: Fix some old XXXs in code handling memory references. We didn't use to generate such references, but now we do. Move some functionality here from code_aux.m. compiler/code_info.m: Provide some primitive operations needed by the new code in var_locn.m. Delete an unneeded predicate. compiler/options.m: Rename the existing option optimize_constructor_last_call as optimize_constructor_last_call_accumulator, since that optimization is done by accumulator.m. Make optimize_constructor_last_call be the option that calls for the new optimization. compiler/handle_options.m: Handle the implications of the new option. compiler/mercury_compile.m: Invoke the lco module by its new interface. librrary/private_builtin.m: Add a new primitive operation, store_at_ref, for use by the new optimization. Switch the module to four-space indentation. compiler/add_clause.m: Comment out the warning for clauses for builtin, since this is needed to bootstrap the addition of the new builtin. compiler/term_constr_initial.m: Handle the new builtin. compiler/accumulator.m: Conform to the change in options. compiler/builtin_ops.m: Provide a third template for builtins, for use by store_at_ref. Convert the file to four-space indentation. compiler/call_gen.m: Generate code following the new builtin template. compiler/rl_exprn.m: Minor changes to conform to the changes in builtin templates. compiler/quantification.m: Minor changes to conform to the changes in construct unifications. Don't make the "get" predicates operating on quantification_infos to return the "new" quantification_info: it is always the same as the old one. compiler/aditi_builtin_ops.m: compiler/common.m: compiler/deep_profiling.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/lambda.m: compiler/magic_util.m: compiler/ml_unify_gen.m: compiler/modecheck_unify.m: compiler/polymorphism.m: compiler/size_prof.m: Minor changes to conform to the changes in construct unifications. compiler/dependency_graph.m: Add a new predicate to recompute the dependency information, even if a previous (and possibly now inaccurate) version is present. Change the interface to make it clearer, by changing bools into types specific to the situation. Convert the file to four-space indentation. compiler/mode_constraints.m: Minor changes to conform to the changes in dependency_graph.m. compiler/code_aux.m: Delete this module. Half its functionality has been moved into llds_out.m, half to middle_rec.m (its only user). compiler/goal_form.m: Move the predicates in this module that are used only by middle_rec.m to middle_rec.m. Convert the file to four-space indentation. compiler/goal_util.m: compiler/det_util.m: Move update_instmap from det_util to goal_util, since it is usefulness extends beyond determinism analysis. Convert det_util.m to four-space indentation. compiler/middle_rec.m: Move here the code required only here from code_aux and goal_form. Update the moved code for the changes in construct unifications. The updates are specific to middle_rec.m: they wouldn't be of use to other modules. They basically say that any code that takes the addresses of fields cannot be handled by middle_rec.m. compiler/code_gen.m: compiler/det_analysis.m: compiler/live_vars.m: compiler/ll_backend.m: compiler/loop_inv.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/notes/compiler_design.html: Minor changes to conform to the deletion of code_aux.m and/or the movement of code from det_util to goal_util.m. compiler/opt_debug.m: Print info for vars in rvals. compiler/hlds_module.m: Convert a lambda to an explicit predicate to make some code easier to read. Switch the module to four-space indentation.	2005-09-13 04:56:20 +00:00
Zoltan Somogyi	f0dbbcaa34	Generate better code for base relations such as the ones in the transitive ... Estimated hours taken: 16 Branches: main Generate better code for base relations such as the ones in the transitive closure benchmarkings in the paper on minimal model tabling. These improvements yield speedups ranging from 5 to 25% on those benchmarks. compiler/use_local_vars.m: Make this optimization operate on extended basic blocks instead of plain basic blocks. The greater length of extended basic blocks allows the local variables to have maximum scope possible. The price is that the test for whether assignment to a given lvalue can be avoided or not is now dependent on which of the constituent basic blocks of extended basic block contains the assignment, and thus the test has to be evaluate once for each assignment we try to optimize instead of once per block. Don't allocate temporary variables if the optimization they are intended for turns out not to be allowed. This change avoids having declarations for unused temporary variables in the resulting C code. If --auto-comments is set, insert use_local_vars.m's main data structure, the livemap, into the generated LLDS code as a comment. compiler/peephole.m: Look for the pattern mkframe(Size, Redoip) <straight line instructions that don't use stack slots> succeed and optimize away the mkframe. This pattern always arises for procedures that are actually semidet but are declared nondet (such as the base relations in the tabling benchmarks), and may also arise for semidet branches of nondet procedures. compiler/llds.m: Allow an existing peephole pattern to work better. The pattern is mkframe(Seize, do_fail) <straight line instructions> redoip(curfr) = Redoip Previously, if some compiler-generated C code was among the straight line instructions, the pattern couldn't be applied, since peephole.m couldn't know whether it branched away through the redoip slot of the frame. This diff adds an extra slot to the relevant pragma_c component that tells peephole.m (actually, the predicate in opt_util.m that peephole relies on) whether this is the case. compiler/basic_block.m: Provide functionality for merging basic blocks into extended basic blocks. compiler/dupelim.m: Conform to the change in basic_block.m's interface. Convert to four-space indentation, and fix departures from our style guidelines. compiler/opt_util.m: Provide extra information now needed by use_local_vars. Convert to four-space indentation, and fix departures from our style guidelines. compiler/opt_debug.m: Show the user friendly versions of label names when dumping livemaps and instructions. Shorten the dumped descriptions of registers and stack slots. Dump instructions inside blocks. compiler/frameopt.m: Conform to the changes in opt_util and opt_debug's interfaces. compiler/optimize.m: Use the facilities of opt_debug instead of llds_out when dumping the LLDS after each optimization, since these are now more compact and thus reader friendly. Print unmangled names when writing progress messages. Put the dump files we generate with --opt-debug in a separate subdirectory, since when compiling e.g. tree234.m, the process can generate more than a thousand files. Give the dump files minimally mangled names. compiler/code_gen.m: compiler/pragma_c_gen.m: Convert to four-space indentation, and fix departures from our style guidelines. Conform to the change in llds.m. compiler/code_info.m: compiler/exprn_aux.m: compiler/ite_gen.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/trace.m: Conform to the change in llds.m.	2005-09-07 06:51:57 +00:00
Zoltan Somogyi	0c45dc9188	Ensure the variable numbers we use procedure layouts are consistent across ... Estimated hours taken: 1 Branches: main Ensure the variable numbers we use procedure layouts are consistent across trace levels. compiler/continuation_info.m: compiler/code_gen.m: Record procedure bodies even if the trace level is not --trace rep, to allow it to be used to compute the variable number compression map. compiler/stack_layout.m: Always compute and use the variable number compression map. tests/debugger/field_names.exp: tests/debugger/declarative/dependency.exp: Update the expected variable numbers. tests/debugger/declarative/loopcheck.exp: Expect fewer events in declarative debugging grades after my previous change to buultin.unify.	2005-04-01 02:09:42 +00:00
Zoltan Somogyi	8b8b3b7d3f	Replace the some() HLDS goal with a more general scope() goal, which can be ... Estimated hours taken: 12 Branches: main Replace the some() HLDS goal with a more general scope() goal, which can be used not just for existential quantification but also for other purposes. The main such purposes are new goal types that allow the programmer to annotate arbitrary goals, and not just whole procedure bodies, with the equivalents of promise_pure/promise_semipure and promise_only_solution: promise_pure ( <impure/semipure goal> ) promise_semipure ( <impure goal> ) promise_equivalent_solutions [OutVar1, OutVar2] ( <cc_multi/cc_nondet goal that computed OutVar1 & OutVar2> ) Both are intended to be helpful in writing constraint solvers, as well as in other situations. doc/reference_manual.texi: Document the new constructs. library/ops.m: Add the keywords of the new constructs to the list of operators. Since they work similarly to the "some" operator, they have the same precedence. compiler/hlds_goal.m: Replace the some(Vars, SubGoal) HLDS construct, with its optional keep_this_commit attribute, with the new scope(Reason, SubGoal) construct. The Reason argument may say that this scope is an existential quantification, but it can also say that it represents a purity promise, the introduction of a single-solution context with promise_equivalent_solutions, or a decision by a compiler pass. It can also say that the scope represents a set of goals that all arise from the unraveling of a unification between a variable and a ground term. This was intended to speed up mode checking by significantly reducing the number of delays and wakeups, but the cost of the scopes themselves turned out to be bigger than the gain in modechecking speed. Update the goal_path_step type to refer to scope goals instead of just existential quantification. compiler/prog_data.m: Add new function symbols to the type we use to represent goals in items to stand for the new Mercury constructs. compiler/prog_io_goal.m: Add code to read in the new language constructs. compiler/prog_io_util.m: Add a utility predicate for use by the new code in prog_io_goal.m. compiler/make_hlds.m: Convert the item representation of the new constructs to the HLDS representation. Document how the from_ground_term scope reason would work, but do not enable the code. compiler/purity.m: When checking the purity of goals, respect the new promise_pure and promise_semipure scopes. Generate warnings if such scopes are redundant. compiler/det_analysis.m: Make the insides of promise_equivalent_solutions goals single solution contexts. compiler/det_report.m: Provide mechanisms for reporting inappropriate usage of promise_equivalent_solutions goals. compiler/instmap.m: Add a utility predicate for use by one of the modules above. compiler/deep_profiling.m: Use one of the new scope reasons to prevent simplify from optimizing away commits of goals that have been made impure, instead of the old keep_this_commit goal feature. compiler/modes.m: Handle from_ground_term scopes when present; for now, they won't be present, since make_hlds isn't creating them. compiler/options.m: Add two new compiler options, for use by implementors only, to allow finer control over the amount of output one gets with --debug-modes. (I used them when debugging the performance of the from_ground_term scope reason.) The options are --debug-modes-minimal and --debug-modes-verbose. compiler/handle_options.m: Make the options that are meaningful only in the presence of --debug-modes imply --debug-modes, since this allows more convenient (shorter) invocations. compiler/mode_debug.m: Respect the new options when deciding how much data to print when debugging of the mode checking process is enabled. compiler/switch_detect.m: Rename a predicate to make it differ from another predicate by more than just its arity. compiler/passes_aux.m: Bring this module up to date with our current style guidelines, by using state variable syntax where appropriate. compiler/*.m: Minor changes to conform to the change in the HLDS and/or parse tree goal type. mdbcomp/program_representation.m: Rename the some goal to the scope goal, and the same for path steps, to keep them in sync with the HLDS. browser/declarative_tree.m: Conform to the change in goal representations. tests/hard_coded/promise_equivalent_solutions_test.{m,exp}: A new test case to test the handling of the promise_equivalent_solutions construct. tests/hard_coded/Mmakefile: Enable the new test. tests/hard_coded/purity/promise_pure_test.{m,exp}: A new test case to test the handling of the promise_pure and promise_semipure constructs. tests/hard_coded/purity/Mmakefile: Enable the new test. tests/invalid/promise_equivalent_solutions.{m,err_exp}: A new test case to test the error messages for improper use of the promise_pure and promise_semipure constructs. tests/invalid/Mmakefile: Enable the new test.	2005-03-24 05:34:41 +00:00
Zoltan Somogyi	c08ca7fbc8	Import only one module per line in the modules of the compiler ... Estimated hours taken: 3 Branches: main compiler/*.m: Import only one module per line in the modules of the compiler where my previous diff did not already do so. Misc other cleanups. Where relevant, use the new mechanism in tree.m. compiler/tree.m: Fix a performance problem I noticed while update :- import_module items. Instead of supplying a function to convert lists of trees to a tree, make the tree data structure able to hold a list of subtrees directly. This reduces the number of times where we have to convert list of trees to trees that are sticks just to stay within the old definition of what a tree is.	2005-03-24 02:00:43 +00:00
Ian MacLarty	4970242093	Use proc_label data structure defined in mdbcomp.prim_data instead of proc_id ... Estimated hours taken: 4 Branches: main Use proc_label data structure defined in mdbcomp.prim_data instead of proc_id defined in mdb.declarative_execution and delete proc_id, since these data structures are almost identical. browser/declarative_execution.m Remove proc_id and flat_module_name types. Use mdbcomp.prim_data.proc_label and mdbcomp.prim_data.module_name instead. browser/declarative_debugger.m browser/declarative_oracle.m browser/declarative_tree.m browser/declarative_user.m Use mdbcomp.prim_data.proc_label and mdbcomp.prim_data.module_name instead of mdb.declarative_execution.proc_id and mdb.declarative_execution.module_name. mdbcomp/prim_data.m compiler/prog_out.m Move sym_name_to_string from prog_out to prim_data. Fix comment for prog_out.sym_name_and_arity_to_string. compiler/bytecode.m compiler/check_typeclass.m compiler/code_gen.m compiler/deforest.m compiler/higher_order.m compiler/hlds_code_util.m compiler/hlds_error_util.m compiler/hlds_module.m compiler/hlds_out.m compiler/intermod.m compiler/layout_out.m compiler/make.module_target.m compiler/make_hlds.m compiler/mercury_compile.m compiler/mercury_to_mercury.m compiler/ml_elim_nested.m compiler/mlds_to_c.m compiler/mlds_to_gcc.m compiler/mlds_to_il.m compiler/mlds_to_java.m compiler/mlds_to_managed.m compiler/modes.m compiler/modules.m compiler/opt_debug.m compiler/options_file.m compiler/polymorphism.m compiler/prog_io.m compiler/prog_rep.m compiler/rl.m compiler/rl_exprn.m compiler/rl_gen.m compiler/rl_info.m compiler/rl_out.pp compiler/rtti.m compiler/rtti_out.m compiler/rtti_to_mlds.m compiler/source_file_map.m compiler/table_gen.m compiler/trans_opt.m compiler/unify_gen.m compiler/unique_modes.m compiler/unused_args.m Use mdbcomp.prim_data.sym_name_to_string instead of prog_out.sym_name_to_string.	2005-02-01 07:11:42 +00:00
Zoltan Somogyi	9521818650	Get the purity check pass to not issue warnings about unnecessary purity ... Estimated hours taken: 16 Branches: main Get the purity check pass to not issue warnings about unnecessary purity annotations on compiler-generated predicates. The problem I am addressing is that when an optimization such as type specialization creates a clone of a predicate, that predicate gets all the original predicate's annotations. During the creation of a .opt file, purity checking sees the clauses of the original predicate and knows that the annotation is not redundant, but doesn't know that about the copy, since it has no definition at all (it doesn't need one). The fix is to put into each pred_info an indication of where the predicate came from, and to never warn about unnecessary purity annotations of predicates that the programmer didn't write. This diff also uses the origin indication to record human-usable names of compiler-generated or compiler-transformed predicates in RTTI for use by the debugger. compiler/hlds_pred.m: Replace two fields in pred_infos, that say (a) whether the predicate is a special (unify/compare/index/init) predicate and (b) whether it is a type class method implementation, with an origin field saying where the predicate came from. This field has several alternatives, special preds and type class method implementation being only two. Make the predicates that create pred_infos take an argument specifing where the predicate comes from. Replace a copy of one of the old fields in rtti_proc_labels with the new one. Make the name of the existing function more descriptive. compiler/purity.m: Use the origin field to suppress unnecessary annotation warnings for compiler-generated predicates. compiler/layout_out.m: Use the origin field to generate more human-friendly names for predicates, instead of the existing linker-friendly names. The debugger doesn't insist on predicate names being unique, even within a module. compiler/*.m: Conform to the changed interface of hlds_pred.m. The most significant changes were for recording the origin of new predicates. In one case (dnf.m) it also involved passing the required information down to the place where the new predicates were created through the dnf_info tuple instead of separate arguments, and switching to state variable notation. tests/debugger/*.exp*: tests/debugger/declarative/*.exp*: tests/hard_coded/*.exp*: Update the expected outputs to expect human-friendly predicate names.	2005-01-21 06:21:00 +00:00
Peter Wang	59d2d4a573	This adds a module mdbcomp__trace_counts that reads in the ... Estimated hours taken: 17 Branches: main This adds a module mdbcomp__trace_counts that reads in the .mercury_trace_counts files produced by the compiler's trace mechanism. The format of said files was slightly changed. As the new module is to be used by the compiler and the debugger, it is placed in the mdbcomp module. This required bringing some types from the compiler into a new module within mdbcomp. browser/trace_counts.m: New module for reading execution trace summaries. browser/prim_data.m: New module holding types and predicates moved in from the compiler. Types: pred_or_func, sym_name, module_name, proc_label, special_pred_id, trace_port Predicates: string_to_sym_name, insert_module_qualifier The mode field of proc_label is now an int instead of a proc_id to avoid pulling proc_id into mdbcomp. browser/mdbcomp.m: Add trace_counts and prim_data to the mdbcomp module. browser/declarative_execution.m: Renamed mdb's definition of module_name to flat_module_name to avoid conflicts with the definition in mdbcomp__prim_data. runtime/mercury_trace_base.c: In the format of .mercury_trace_counts, write module and predicate names now use quoted atom syntax so that names with spaces and non-printable characters can be machine-parsed. browser/: compiler/: Many changes to account for movement of types, and the change to proc_label.	2005-01-19 03:11:22 +00:00
Zoltan Somogyi	6c9e970f5b	Fix formatting. ... Estimated hours taken: 0.1 Branches: main compiler/code_gen.m: Fix formatting.	2005-01-17 04:26:55 +00:00
Zoltan Somogyi	d03ce7dbc0	Fix some bugs in my previous diff that optimized away stack slots storing ... Estimated hours taken: 8 Branches: main Fix some bugs in my previous diff that optimized away stack slots storing dummy values that manifested themselves as warnings from the C compiler about integers too big to fit into 8 or 16 bits being implicitly truncated. They did not lead to the failure of any test case, since it doesn't matter whether the debugger gets the values it ignores (I/O states or stores) from valid stack slots or not. When generating RTTI for gc and the debugger, the compiler had three places that generated references to stack slots: the return sites of calls, resume points, and trace events. The previous diff updated only the first of these. This diff updates the other two, and ensures there are no more. Since the debugger needs to know whether a procedure has a pair of I/O state arguments (e.g. when performing a retry), we add a field to proc layouts to hold this information. runtime/mercury_grade.h: Increment the debug grade runtime compatibility version number to reflect the change in layout structures. runtime/mercury_stack_layout.h: Add an extra field to proc layouts to specify flags. At the moment, the only flag says whether the procedure has a pair of I/O state arguments. Add an extra field to proc layouts to specify the trace level of a procedure. This used to be the same as the module's trace level, but one of my bug fixes a couple of months ago broke that link. We don't yet use this field, but it makes sense to do it at the same time as the increment of the compatibility version number. compiler/continuation_info.m: Attach to every description of a live value a description of where in the compiler that description was created. Rename the type involved to avoid an ambiguity. Ignore dummy types when generating resume layouts. Add some sanity checks. Add new fields to the continuation_info data structure to allow stack_layout.m to fill in the new fields in proc layout structures. compiler/trace.m: Do not generate references to dummy values at trace events, except at call ports. At those ports, all live variables should be in registers. compiler/stack_layout.m: Make the check for whether a value fits into an unsigned 8 bit value a direct rather than an indirect one. The indirect one assumed that stack slot numbers are all positive, which is now a bad assumption. Check for negative stack slot numbers in all RTTI stack slot descriptions. Fill in the two new slots in proc layout structures. compiler/layout.m: Reserve space for the two new slots in proc layout structures. compiler/layout_out.m: Output the two new slots in proc layout structures. compiler/code_gen.m: Preserve the information needed by stack_layout.m for the two new fields. compiler/llds_out.m: Add some code that ensures that we never output an integer constant that doesn't fit into the range of its type. Since this code is executed many millions of times, it is designed to be enabled only when the checking is manually enabled. It is normally off, but I got a clean bootcheck in the debug grade (which is the best stress test) with it enabled. compiler/trace_params.m: Update a comment. compiler/code_info.m: Export a function for use by trace.m. compiler/hlds_pred.m: Export a predicate for use by stack_layout.m. compiler/Mercury.options: Enable inlining for llds_out.m, to get rid of the sanity checking overhead if it is not enabled. tests/debugger/completion.exp*: tests/debugger/interpreter.exp*: tests/debugger/multi_parameter.exp*: tests/debugger/queens.exp*: tests/debugger/print_goal.exp*: tests/debugger/tabled_read.exp*: tests/debugger/tabled_read_decl.exp*: tests/debugger/declarative/io_stream_test.exp*: tests/debugger/declarative/tabled_read_decl.exp*: Update these expected output files to not expect dummy values that aren't kept anymore.	2004-11-19 05:46:25 +00:00
Zoltan Somogyi	f76c4823e5	Fix a problem reported by Ian: the debugger ignored information about the head ... Estimated hours taken: 2 Branches: main Fix a problem reported by Ian: the debugger ignored information about the head variables of the predicates generated by the compiler from lambda expressions because they didn't have names. compiler/hlds_pred.m: Add a predicate to ensure that all headvars have names. compiler/lambda.m: Call that predicate to give names to the predicates created from lambda expressions. compiler/code_gen.m: Call that predicate to give names to the predicates created from lambda expressions, in case other transformations also create predicates with unnamed head variables. doc/user_guide.texi: Add a new mdb command, var_details, and a new method of invocation of an existing mdb command, flag. I used them to track down this bug. trace/mercury_trace_internal.c: Implement the var_details mdb command, and the new method of invocation of the flag command. trace/mercury_trace_vars.[ch]: Add a function to print variable details. tests/debugger/mdb_command_test.inp: Test the documentation of the new command. tests/debugger/completion.exp: Expect the new command. tests/debugger/lambda_expr.{m,inp,exp}: Add the new test case to test for the bug. tests/debugger/Mmakefile: Enable the new test case.	2004-07-19 03:37:55 +00:00
Zoltan Somogyi	d332038ee1	Bring these modules up to date with our coding guidelines. ... Estimated hours taken: 16 Branches: main compiler/aditi_builtin_ops.m: compiler/bytecode.m: compiler/bytecode_backend.m: compiler/bytecode_gen.m: compiler/c_util.m: compiler/code_gen.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/dependency_graph.m: compiler/fact_table.m: compiler/follow_code.m: compiler/handle_options.m: compiler/hlds_out.m: compiler/il_peephole.m: compiler/ilasm.m: compiler/java_util.m: compiler/liveness.m: compiler/magic.m: compiler/magic_util.m: compiler/make.dependencies.m: compiler/make.m: compiler/make.module_dep_file.m: compiler/make.program_target.m: compiler/make.util.m: compiler/matching.m: compiler/name_mangle.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/options.m: compiler/options_file.m: compiler/prog_io.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/saved_vars.m: compiler/source_file_map.m: compiler/stack_alloc.m: compiler/stack_layout.m: compiler/stratify.m: compiler/switch_detection.m: compiler/term_errors.m: compiler/type_ctor_info.m: compiler/unify_proc.m: compiler/unique_modes.m: Bring these modules up to date with our coding guidelines. Use predmode syntax for declarations. Use state variable syntax where appropriate, and reorder arguments where this is needed for the use of state variable syntax. Remove module qualification from the names of defined predicates when the module qualification was used inconsistently (causing problems for the use of tags) or was causing problems with indentation. There are no changes in algorithms.	2004-06-30 02:48:20 +00:00
Zoltan Somogyi	885fd4a387	Remove almost all dependencies by the modules of parse_tree.m on the modules ... Estimated hours taken: 12 Branches: main Remove almost all dependencies by the modules of parse_tree.m on the modules of hlds.m. The only such dependencies remaining now are on type_util.m. compiler/hlds_data.m: compiler/prog_data.m: Move the cons_id type from hlds_data to prog_data, since several parts of the parse tree data structure depend on it (particularly insts). Remove the need to import HLDS modules in prog_data.m by making the cons_ids that refer to procedure ids refer to them via a new type that contains shrouded pred_ids and proc_ids. Since pred_ids and proc_ids are abstract types in hlds_data, add predicates to hlds_data to shroud and unshroud them. Also move some other types, e.g. mode_id and class_id, from hlds_data to prog_data. compiler/hlds_data.m: compiler/prog_util.m: Move predicates for manipulating cons_ids from hlds_data to prog_util. compiler/inst.m: compiler/prog_data.m: Move the contents of inst.m to prog_data.m, since that is where it belongs, and since doing so eliminates a circular dependency. The separation doesn't serve any purpose any more, since we don't need to import hlds_data.m anymore to get access to the cons_id type. compiler/mode_util.m: compiler/prog_mode.m: compiler/parse_tree.m: Move the predicates in mode_util that don't depend on the HLDS to a new module prog_mode, which is part of parse_tree.m. compiler/notes/compiler_design.m: Mention prog_mode.m, and delete the mention of inst.m. compiler/mercury_to_mercury.m: compiler/hlds_out.m: Move the predicates that depend on HLDS out of mercury_to_mercury.m to hlds_out.m. Export from mercury_to_mercury.m the predicates needed by the moved predicates. compiler/hlds_out.m: compiler/prog_out.m: Move predicates for printing parts of the parse tree out of hlds_out.m to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/purity.m: compiler/prog_out.m: Move predicates for printing purities from purity.m, which is part of check_hlds.m, to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/passes_aux.m: compiler/prog_out.m: Move some utility predicates (e.g. for printing progress messages) from passes_aux.m to prog_out.m, since some predicates in submodules of parse_tree.m need to use them. compiler/foreign.m: compiler/prog_data.m: Move some types from foreign.m to prog_data.m to allow the elimination of some dependencies on foreign.m from submodules of parse_tree.m. compiler/*.m: Conform to the changes above, mostly by updating lists of imported modules and module qualifications. In some cases, also do some local cleanups such as converting predicate declarations to predmode syntax and fixing white space.	2004-06-14 04:17:03 +00:00
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.	2004-06-07 09:07:23 +00:00
Zoltan Somogyi	cc508c83de	Perform frame optimization on nondet predicates. ... Estimated hours taken: 6 Branches: main Perform frame optimization on nondet predicates. The need for this was revealed by benchmarking in Uppsala, which initially showed Mercury to take three to five times as long as XSB on some tabling benchmarks. One major contributor was the fact that the predicate returning answers out of answer table was creating and destroying a nondet stack frame for every answer it returned. To make this change easier, make the representation of labels more reader friendly, classifying them primarily on whether they represent entry or internal labels, and only secondarily on the scope in which they represent valid references to the label. compiler/frameopt.m: Add a predicate to perform frame optimization on model_non predicates. This optimization involves separating the steps of creating the frame (done once) and setting the redoip (potentially done on every iteration). compiler/optimize.m: Invoke this new predicate. Reorder the arguments of predicates in this file, and the top level predicates of the optimizations it invokes, to allow the use of state variable notation. runtime/mercury_stacks.h: Provide macros for creating nondet stack frames that do not fill in the redoip slot. compiler/llds.m: Make the setting of redoip optional in mkframe operations. Make the representation of labels more reader friendly. compiler/layout_out.m: Change the representation of label layouts to enforce the invariant that these can refer only to internal labels. (The layout structures of entry labels are proc layout structures, whose design enforces the relevant invariant already.) compiler/jumpopt.m: Add an optimization that improves code that matches a new pattern: % Attempt to transform code such as % % if (Cond) L1 % goto L2 % % into % % if (! Cond) L2 % <code at L1> % % when we know the code at L1 and don't know the code at L2. The new frame optimization creates instances of this pattern, usually with L2 being do_fail. compiler/*.m: Minor diffs to conform to the changes above.	2004-05-23 23:14:37 +00:00
Zoltan Somogyi	642c902c90	Reduce the sizes of .c and .o files in debug grades by 8%. ... Estimated hours taken: 4 Branches: main Reduce the sizes of .c and .o files in debug grades by 8%. Add to mdb the capability of putting breakpoints on unify, compare and index predicates. compiler/code_gen.m: Since compiler-generated unify, index and compare pred can be presumed to be correct, compile them with shallow tracing instead of deep tracing even if the user asks for deep tracing of the rest of the module. This saves disk space, compile time and run time. Move the code for setting the trace level to generate_proc_code, where it is executed whether we generate code by predicates or by phases. compiler/trace_params.m: Provide a function for use by code_gen.m. Consider unify and compare predicates to behave as if their address were taken, since they may be called from builtin.unify or builtin.compare. compiler/jumpopt.m: Do not replace jumps with the block being jumped to if the block contains an instruction that represents a call to the debugger. In such cases, the jump is a minor cost in runtime compared to the call, and the locality benefit from not increasing the code size is quite likely to exceed that cost. compiler/llds.m: Add field names to pragma_c instructions to make the change to jumpopt easier. tests/debugger/uci.{inp,exp}: Update this test case. An update is required since we now generate fewer events from unify and compare preds due to their now being shallow traced. To make this the update easier, use the new capability of putting breakpoints on unify and compare predicates. trace/mercury_trace_tables.[ch]: Expand procedure specifications to allow the specification of unify, compare and index predicates, and expand the function that checks for matches between a procedure layout and a procedure specification accordingly. Fix two instances of a bug: if a procedure specification has no name, represent it as NULL, not as a non-NULL pointer to a null character, since the match function expects only the former. doc/user_guide.texi: Document the new definition of procedure specifications. NEWS: Mention the new definition of procedure specifications, and expand on some previous additions to the debugger. runtime/mercury_stack_trace.c: Allow mdb breakpoint specifications on uci predicates to be saved. Factor out some common data structure accesses. runtime/mercury_proc_id.h: Change the name of a macro from MR_PROC_ID_COMPILER_GENERATED to MR_PROC_ID_IS_UCI, for consistency with other names dealing with unify, compare and index predicates. runtime/*.[ch]: trace/*.[ch]: Conform to the change in mercury_proc_id.h.	2004-05-23 22:16:57 +00:00
Zoltan Somogyi	c80d143cc8	The following change is only 98% complete, not 100%. ... Estimated hours taken: 120 Branches: main The following change is only 98% complete, not 100%. I am committing it in this state because (1) we pass many more test cases in deep profiling grade with it than without it, and (2) the double maintanance involved in fixing CVS conflicts is preventing me from doing the last 2%. Get the deep profiler to work for code that sets up to catch exceptions, which for the last year or more has included the compiler, and to get it almost working for code that actually catching exceptions. The basic problem is that code that throws exceptions will in general cause several calls to "return" without executing the exit or fail port codes that the deep profiling transformation inserted into their bodies, and this leaves the data structure being built by the deep profiling inconsistent. The solution uses the same approach as we have adopted for the debugger: have the code that handles the throwing of exceptions simulate a return from each call between the throw and the catch, updating the deep profiling data structures as needed. This requires us to be able to walk the stack at runtime not just in debugging grades but also in deep profiling grades. Since the debugger already has the mechanisms required for this, we reuse them. The procedure layouts used by the debugger were designed to have three segments: the procedure stack walk information, the procedure id, and the execution tracing information. We now modify this design to make the third segment contain two pointers: to the execution tracing information (for use by the debugger), and to the procedure's proc_static structure (for use by deep profiling). Each pointer will be null unless the pointed-to structure is required by compile-time options. This common use by the debugger and by deep profiling of the stack-walk structure and the procedure id structure (which deep profiling used to generate independently and possibly redundantly) required some rearrangement of the compiler's version of these data structures. To make this rearrangement simpler, this diff removes a capability that we theoretically supported but never used: turning on stack traces without turning on execution tracing and vice versa. After this diff, stack tracing is enabled if and only if either execution tracing or deep profiling is enabled. The diff also includes improvements in the debugging infrastructure for debugging deep profiling, which were necessary for the implementation of the rest of the changes. compiler/deep_profiling.m: The code in exception.m needs to know the locations of the variables that we would pass to the exit or fail port code, so it can simulate leaving the procedure invocation through the exception port. Without this information, throwing an exception leaves the deep profiling data structures of the procedure invocations between throw and catch in an inconsistent state. Deep_profiling.m creates these variables, but it doesn't know where they will be at runtime, so it records their identities; the code generator will allocate them stack slots and record the numbers of these stack slots for placement in the now expanded proc layout structures. Deep profiling used to generate static data structures separately from the HLDS, but since the code generator now needs access to them, we store their information in proc_infos in the HLDS. Instead of passing the addresses of proc_static structures to the deep profiling port procedures, pass the address of proc_layout structures, since the information about the identities of procedures are now stored not in the proc_static structure, but in the proc_layout structure that points to the proc_static structure. compiler/hlds_pred.m: compiler/layout.m: Move the definitions of the static data structures generated by deep profiling from layout.m to hlds_pred.m, to allow deep_profiling.m to store them in proc_infos. compiler/hlds_pred.m: compiler/rtti.m: Move the definition of rtti_proc_label from rtti.m to hlds_pred.m, since some of the new data structures in hlds_pred.m need it. Despite its name, the rtti_proc_label type doesn't contain any info that doesn't belong in the HLDS. Add some information to the rtti_proc_label type that is now needed by deep profiling, e.g. record determinisms instead of just code models. Record explicitly the outcome of some tests that used to be duplicated in more than one place in the compiler, e.g. for whether the procedure (as opposed to the predicate) is imported. Change some of the field names to be more precise about the field's meaning. compiler/code_gen.m: Transmit the contents of the deep profiling data structures stored in the proc_info by deep_profiling.m to continuation_info.m, together with the layout structures created for execution tracing and the identities of the variables needed for handling exceptions, when code generation for a procedure is complete. After the goal that generates these variables, save them to stack for use by the exception handler. compiler/hlds_goal.m: Add a feature to mark the goal that generates the deep profiling variables needed by the exception handler. compiler/hlds_llds.m: Add a utility predicate for new code in code_gen.m compiler/continuation_info.m: Hold the deep profiling information computed by code_gen.m for use by stack_layout.m. compiler/layout.m: compiler/layout_out.m: Update the definitions of the data structures describing procedure layouts, and the code writing them out, to reflect the use of some parts of procedure layouts by deep profiling as well as debugging. Change the layout structures generated by deep profiling to use rtti_proc_labels, which are backend independent, instead of proc_labels, which are specific to the LLDS backend. Conform to the changes in runtime/mercury_stack_layout.h. compiler/stack_layout.m: Generate the updated version of proc_layout structures. compiler/mercury_compile.m: compiler/global_data.m: Conform to the fact that deep profiling no longer generates layout structures separate from proc_infos. compiler/llds_out.m: Register proc_layout structures instead of proc_static structures for use by runtime/mercury_deep_profiling.c. compiler/options.m: compiler/handle_options.m: Rename the require_tracing option as exec_trace, since this more directly reflects its meaning. Instead of having --debug set both require_tracing and stack_trace, make it set (be the user-visible name of) just exec_trace; the value of stack_trace is implied. Turn off the specialization of deep profiling for self-tail-recursive procedures for now. Due to the changes made by this diff in the data structures involved in debugging, it cannot be debugged until this change has been installed. Handling the full language is more important than a specialization that reduces only stack space overheads, not runtime overheads. compiler/compile_target_code.m: Conform to the changes in options.m and runtime/mercury_grade.h. compiler/hlds_data.m: Replace the deep_profiling_proc_static cons_id, and its associated tag, to deep_profiling_proc_layout, since we now generate addresses of proc layout structures, not of proc_static structures. compiler/code_util.m: Simplify some code based on the new info in rtti_proc_labels. compiler/bytecode_gen.m: compiler/dependency_graph.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_code_util.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/proc_label.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/saved_vars.m: compiler/switch_util.m: compiler/unify_gen.m: Minor changes to conform to the change from deep_profiling_proc_static to deep_profiling_proc_layout, to the change in the structure of rtti_proc_labels, to the changes in types of layout.m, and/or to the new goal feature. deep_profiler/measurements.m: Reserve space for exception counts. deep_profiler/html_format.m: Add a column for exception counts. deep_profiler/profile.m: deep_profiler/read_profile.m: Rename the data structures referring to compiler generated unify, compare and index predicates to avoid misleading names: they are not the only compiler generated predicates. deep_profiler/read_profile.m: runtime/mercury_deep_profiling.c: Update the string that identifies deep profiling data files. This is necessary because the format has changed: it now includes information about exception port counts. library/exception.m: In deep profiling grades, execute the exception port code for every procedure invocation between a throw and a catch, using the procedure layout structures now generated by the compiler for every procedure. Rename the function involved to reflect its new, more general purpose. Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code. Indent C preprocessor directives and foreign_procs according to our coding standards. library/profiling_builtin.m: Change the parameters of the call port code procedures from proc_static to proc_layout. Reach the proc_static structure from the proc_layout structure when needed. Include the proc_layout structure in any messages from assertion failures. Add some conditionally compiled debugging code. Give some variables better names. runtime/mercury_type_info.h: runtime/mercury_builtin_types.c: Move the macros required to create the proc_static structures of unify and compare predicates from mercury_type_info.h to mercury_builtin_types.c, since the latter is the only file that needs them. Use the same macros for creating the proc_static structures of hand-written unify, compare and compare_reprentation predicates as for user defined predicates. This required changing their naming scheme. runtime/mercury_unify_compare_body.h: Conform to the new naming scheme. runtime/mercury_ho_call.c: Provide the mechanism for mercury_unify_compare_body.h to conform to the new naming scheme. Remove the definitions of the proc_static structures for hand-written unify, compare and compare_reprentation predicates, since these now have to be defined together with the corresponding proc_layout structures in mercury_builtin_types.c. runtime/mercury_builtin_types.[ch]: Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code, and add the required declarations first. Handle deep profiling of compare_representation as well as unify and compare predicates on builtin types. Handle deep profiling of compare_representation on user-defined types, since this is done entirely in the runtime, not by compiler generated predicates. runtime/mercury_builtin_types_proc_layouts.h: New header file containing the declarations of the proc layout structures of the unify, compare and index predicates of builtin types. Logically, these declarations belong in mercury_builtin_types.h, but putting them there causes problems for the linker; the details are explained in the file itself. runtime/Mmakefile: Add the new header file. runtime/mercury_minimal_model.[ch]: Update the definitions of the hand-written proc_static and proc_layout structures for the procedures implemented via hand-written C code, and add the required declarations first. runtime/mercury_grade.h: Replace the MR_REQUIRE_TRACING grade option with MR_EXEC_TRACING. Besides being better named, the MR_EXEC_TRACING option implies MR_STACK_TRACE. Besides the overall binary compatibility version number, add subsidiary version numbers for binary compatibility in deep profiling and debugging grades. These will make it easier to bootstrap changes (such as this) that affect binary compatibility only in such grades. runtime/mercury_trace_base.c: trace/mercury_trace.c: Conform to the new names of the configuration parameters. runtime/mercury_hand_compare_body.h: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_unify_compare_body.h: runtime/mercury_ho_call.c: tools/make_port_code: Pass proc_layout structures instead of proc_static structures to deep profiling port routines. runtime/mercury_conf_param.h: Make MR_DEEP_PROFILING as well as MR_EXEC_TRACING imply MR_STACK_TRACE, since deep profiling now needs stack tracing. (MR_STACK_TRACE needs to be set in this file, because tests in this file depend on knowing its value, and this file is among the first files included (in this case indirectly) in mercury_imp.h.) Document the macros controlling the debugging of deep profiling. Enable printing of label names when the relevant deep profiling debugging macro is set. runtime/mercury_debug.c: runtime/mercury_deep_rec_depth_actions.h: runtime/mercury_deep_rec_depth_body.h: runtime/mercury_exception_catch_body.h: Get to proc_statics via proc_layouts. runtime/mercury_deep_call_port_body.c: runtime/mercury_deep_leave_port_body.c: Get to proc_statics via proc_layouts. Allow the debugger to disable deep profiling in Mercury code that is part of the debugger, not of the user program being executed. Add some more assertions. runtime/mercury_engine.[ch]: Add a new debugging flag that controls at runtime whether we generate a human readable Deep.debug equivalent to the binary Deep.data files. (We already had a mechanism for controlling this at compile time, but this isn't flexible enough.) runtime/mercury_wrapper.c: Allow this new debugging flag to be set from MERCURY_OPTIONS. runtime/mercury_deep_profiling.[ch]: Respect this new debugging flag. Update the hand-written proc_static structures representing the runtime system. Print out addresses of proc_layout as well as proc_static structures when assertions fail. Add a field to the measurement structure for exception port counts, and write out this field with the other port counts. Remove procedure id information from proc_static structures, deep profiling now uses the procedure id in the proc_layout structure. Add to proc_static structures fields that specify where, if anywhere, the variables needed by exception.m to executed the exception port code are in the procedure's stack frame. Define a global flag that allows the debugger to disable deep profiling in Mercury code that is part of the debugger, not of the user program being executed. Increase type safety by providing two versions of the function for registering proc_layouts, one for the proc_layout structures of user-defined predicates and one for unify, compare and index predicates. Fix a bug that occurs only if MR_DEEP_PROFILING_EXPLICIT_CALL_COUNTS is defined (which it usually isn't): the initial call count was wrong. runtime/mercury_deep_profiling_hand.h: Fix a bug: the handwritten code saving deep profiling variables was saving them in slots that didn't belong to the relevant stack frame. Update to conform to the modified definitions of proc_static structures and the fact that we now reach them via proc_layout structures. runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: Fix the other side of the bug in mercury_deep_profiling_hand.h by reserving the right number of stack slots in the stack frames of the various modes of exception__catch. Make it harder to make the same bug in the future by getting the needed info from the place in mercury_stacks.h that defines the structure of the relevant stack frame. runtime/mercury_proc_id.h: Rename the procedure id structure fields referring to compiler generated unify, compare and index predicates: they are not the only compiler-generated predicates. runtime/mercury_stack_layout.h: Change procedure layout structures to allow them to be used for deep profiling as well as for debugging, as described in the prologue above. We don't need the capability to support label layout structures with links to misnamed proc layout structures, and supporting it is inconvenient, so delete the capability. runtime/mercury_debug.c: runtime/mercury_deep_profiling_hand.h: runtime/mercury_layout_util.c: runtime/mercury_ml_expand_body.h: runtime/mercury_stack_trace.c: runtime/mercury_types.h: trace/mercury_trace_external.c: Conform to the new names of the procedure id structure fields. runtime/mercury_std.h: Add some more arities for MR_PASTE for use in some of the modified modules in the runtime. trace/mercury_trace_internal.c: Disable deep profiling actions in Mercury code that is part of the debugger, not of the program being debugged. scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make changes parallel to the ones in runtime/mercury_grade.h: delete --stack-trace as an independent option, and make --debug set its own option, not --require-tracing. scripts/canonical_grade.sh-subr: scripts/final_grade_options.sh-subr: scripts/c2init.in: scripts/mgnuc.in: scripts/ml.in: Conform to the changes in grade options for debugging and for deep profiling. tools/bootcheck: If Mmake.stage.{browser,deep,library,runtime,trace}.params exist, copy them to become the file Mmake.$dir.params in stage2/$dir (where dir is derived from the name of the original file in the obvious way). This allows more flexibility in the creation of the stage2; for example, it allows some directories (e.g. runtime or library) to be compiled with more debugging than other directories (e.g. compiler). This may be required because compiling all directories with lots of debugging may cause the linker to thrash. Add an option, --disable-debug-libs, that clobbers the libraries that should be linked in only in debugging grades. To conserve disk space, remove Deep.data files created by the bootcheck by default. Add an option, --keep-deep-data, to preserve these files. Use a consistent mechanism (test -f) for testing the existence of all files whose existence is tested. When recording modification times, record the modification times of some more files. tests/hard_coded/Mmakefile: In deep profiling grades, disable the test cases that we don't now pass in such grades, and document the reasons for their failure. Fix the misclassification of the write_binary test case.	2004-05-19 04:00:01 +00:00
Zoltan Somogyi	bd1ea24cc3	Remove the dependence of this module on ll_backend.llds by defining ... Estimated hours taken: 6 Branches: main compiler/hlds_llds.m: Remove the dependence of this module on ll_backend.llds by defining types using abstract descriptions of LLDS storage locations. These have the added advantage that they express the intent of the affected data structures more directly. For example, the stack slot type used to be able to map a variable to a register or to a field of a cell on the heap, which doesn't make sense. This is no longer the case. The cost of the conversion operations now required is partly paid for by our new ability to avoid some old sanity checks. compiler/llds.m: compiler/code_util.m: Add some utility predicates to operate on the new data structures. compiler/code_aux.m: compiler/code_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/follow_vars.m: compiler/lookup_switch.m: compiler/par_conj_gen.m: compiler/stack_alloc.m: compiler/store_alloc.m: compiler/var_locn.m: Conform to the changes in hlds_llds.m. In some cases, improve the style of the affected predicates, e.g. by introducing state variable syntax. compiler/hlds_out.m: Conform to the changes in hlds_llds.m, and avoid importing ll_backend.	2004-04-10 10:33:02 +00:00
Zoltan Somogyi	ff60134ee9	Bring these modules up to our current coding standards. ... Estimated hours taken: 8 Branches: main analysis/analysis.m: browser/browse.m: compiler/accumulator.m: compiler/assertion.m: compiler/atsort.m: compiler/c_util.m: compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/code_gen.m: compiler/code_model.m: compiler/const_prop.m: compiler/constraint.m: compiler/dead_proc_elim.m: compiler/delay_construct.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/export.m: compiler/fact_table.m: compiler/follow_code.m: compiler/graph_colour.m: compiler/hlds_module.m: compiler/inlining.m: compiler/llds.m: compiler/make_hlds.m: compiler/mercury_to_mercury.m: compiler/ml_tailcall.m: compiler/ml_unify_gen.m: compiler/mmc_analysis.m: compiler/mode_errors.m: compiler/passes_aux.m: compiler/post_typecheck.m: compiler/size_prof.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_errors.m: compiler/transform_llds.m: compiler/type_util.m: compiler/unify_gen.m: compiler/unneeded_code.m: compiler/unused_args.m: Bring these modules up to our current coding standards. Use predmode declarations and state variable syntax where relevant. Reorder arguments where this is needed for the use state variables. Make the orders of predicate definitions correspond to the order of their declarations. Replace some overly large lambda expressions with named predicates. Convert some predicates to functions where this makes their use more convenient. Use field access notation where convenient. Fix any inconsistent indentation. Remove module prefixes on predicate names where this is necessary to allow sane indentation. In several places, use predicates from error_util.m to print error messages. Apart from this, there are no changes in algorithms. In some places, conform to the changes below. compiler/error_util.m: compiler/hlds_error_util.m: Add new variants of existing predicates for use in some of the changed modules above. compiler/hlds_out.m: Add some functions to convert values of some HLDS types as strings, for use in preparing the arguments of the new calls to predicates in error_util.m. Change the implementations of the predicates that print values of those types to call those functions instead of allowing code duplication. compiler/llds.m: Add some field names to allow use of field updates where relevant. tests/invalid/assert_in_interface.err_exp: tests/invalid/multisoln_func.err_exp: tests/invalid/tricky_assert1.err_exp: Update the expected outputs of these test cases to allow for them being generated by error_util.m, and hence being better formatted than before.	2004-04-05 05:07:49 +00:00
Zoltan Somogyi	5d6fd3bd6f	Reduce the dependence of earlier parts of the compiler on the later ones. ... Estimated hours taken: 4 Branches: main Reduce the dependence of earlier parts of the compiler on the later ones. Unnecessary import_module declarations in top level modules such as hlds.m cause unnecessary recompilations when adding new types in later modules, such as submodules of ll_backend.m. This change reduces the number of such unnecessary imports. There are no changes in algorithms, only functionality being moved around. compiler/code_model.m: Change this module from being a submodule of backend_libs.m to being a submodule of hlds.m, since nothing in it is dependent on any backend. compiler/arg_info.m: compiler/code_util.m: Change arg_info.m from being a submodule of ll_backend.m to being a submodule of hlds.m, since most of it is applicable to all current and foreseeable backends. Move the one exported predicate that is ll_backend dependent, and its support predicates, to code_util.m. compiler/backend_libs.m: compiler/ll_backend.m: compiler/hlds.m: Update include_module declarations in accordance with the above. compiler/prog_data.m: compiler/term_util.m: Instead of defining two separate types for holding argument size and termination information, one including HLDS-specific information (in term_util.m) and one not (in prog_data.m), use a polymorphic type defined in prog_data.m and two monomorphic instances. compiler/termination.m: compiler/mercury_to_mercury.m: Change the predicates for writing out argument size and termination information to handle the polymorphic type (we don't need special handling of the monomorphic versions), and move them from termination.m to mercury_to_mercury.m, since this allows us to avoid some undesirable dependencies. compiler/base_typeclass_info.m: compiler/hlds_code_util.m: Move the predicate make_instance_string from base_typeclass_info.m to hlds_code_util.m, again because it allows us to remove some undesirable dependencies. compiler/top_level.m: compiler/backend_libs.m: compiler/check_hlds.m: compiler/hlds.m: compiler/ll_backend.m: compiler/parse_tree.m: compiler/transform_hlds.m: Delete some import_module declarations of other top level modules in these top level modules. Some imports were totally unnecessary. Some imports were useful in only a small minority of submodules; those submodules now import the necessary top level modules directly. Move remaining import_module declarations to the implementation section where this is feasible. Where we still need to import modules we ideally shouldn't, note why. compiler/*.m: Update imports of code_util and arg_info. In some cases, import top level modules no longer imported by the parent module. In some cases, delete unnecessary imports.	2004-03-23 10:52:14 +00:00
Zoltan Somogyi	6ac84aac9f	Bring these modules up to date with our current code style. ... Estimated hours taken: 4 Branches: main compiler/code_util.m: compiler/fact_table.m: compiler/make_tags.m: compiler/type_ctor_info.m: compiler/unify_proc.m: Bring these modules up to date with our current code style. Use predmode declarations and state variable syntax where appropriate, and reorder arguments where this is needed to use state variable syntax. Break up excessively large and/or excessively indented predicates. Factor out common code and fix indentation. Use error_util to print error messages where appropriate. In fact_util.m, change predicates that took I/O state arguments to print error messages to return a list of error reports instead, to be printed by an ancestor. This makes it clearer which parts of the module actually have file I/O as part of their main job. compiler/special_pred.m: Shorten an excessively long predicate name, since without this some of the above modules cannot be indented properly. compiler/make_hlds.m: Use the new shorter predicate name. compiler/code_gen.m: compiler/ml_code_util.m: Fix indentation. compiler/hlds_out.m: Add a predicate for use by the new version of fact_table.m	2004-03-23 06:56:42 +00:00
Zoltan Somogyi	fa9ca36d03	This diff makes several files easier to read and to maintain (as well as ... Estimated hours taken: 5 Branches: main This diff makes several files easier to read and to maintain (as well as more than 400 lines shorter), but contains no changes in algorithms whatsoever. compiler/deep_profiling.m: compiler/foreign.m: compiler/hlds_module.m: compiler/hlds_data.m: compiler/make_hlds.m: compiler/post_typecheck.m: compiler/prog_data.m: compiler/purity.m: compiler/type_util.m: Bring these modules into line with our current coding standards. Use predmode declarations and state variable syntax when appropriate. Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace predicates with functions where appropriate. Standardize indentation. compiler/*.m: Conform to the changes above.	2003-12-21 05:04:38 +00:00
Zoltan Somogyi	b39a3d855f	This diff makes hlds_module.m and many callers of its predicates easier to read ... Estimated hours taken: 6 Branches: main This diff makes hlds_module.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/hlds_module.m: Bring (most of) this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. (The 'most of' is because I left the part of the module dealing with predicate tables alone, not wishing to cause a conflict for Pete.) Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. compiler/*.m: Conform to the changes in hlds_module.m. This mostly means using the new argument orders of predicates exported by hlds_module.m, and switching to state variable notation. Replace old-style lambdas with new-style lambdas or with partially applied named procedures in updated code. Replace unnecessary occurrences of four-space indentation with standard indentation in updated code. library/list.m: library/map.m: library/tree234.m: Add list__foldl4 and map__foldl3, since in some compiler modules, state variable notation is more convenient (and the code more efficient) if we don't have to bundle up several data structures into a tuple just to iterate over them. Change the fold predicates to use state variable notation. NEWS: Mention the new library functions.	2003-10-31 03:27:39 +00:00
Zoltan Somogyi	c8e4004825	This diff makes code_info.m and many callers of its predicates easier to read ... Estimated hours taken: 4 Branches: main This diff makes code_info.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/code_info.m: Bring this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Where a predicate returned its input code_info unchanged, purely to allow the convenient use of DCG notation in the caller, delete the unnecessary output argument. This should make the caller somewhat more efficient, since it can avoid updating the stack slot holding the current code_info. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. compiler/*.m: Conform to the changes in code_info.m. This mostly means using the new argument orders of predicates exported by hlds_pred.m, and using state variable notation.	2003-10-27 05:42:37 +00:00
Zoltan Somogyi	8693e293a2	This diff makes hlds_pred.m and many callers of its predicates easier to read ... Estimated hours taken: 4 Branches: main This diff makes hlds_pred.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/hlds_pred.m: Bring this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. Standardize indentation. compiler/*.m: Conform to the changes in hlds_pred.m. This mostly means using the new argument orders of predicates exported by hlds_pred.m. Where this is now conveniently possible, change predicates to use state variable notation. In some modules, using state variable notation required changing the orders of arguments in the module's top predicate. compiler/passes_aux.m: Change the order of arguments in the calls this module makes to allow the callees to use state variable notation. Convert this module to state variable notation too.	2003-10-24 06:17:51 +00:00
Zoltan Somogyi	599ef915d9	Instead of being relied on all over the place, centralize the compiler's ... Estimated hours taken: 16 Branches: main Instead of being relied on all over the place, centralize the compiler's knowledge of the names of unify, compare and index predicates in one place, special_pred.m. This should make it easy to change the naming scheme once we switch over to compiler-generated type_ctor_infos for builtin types, which will eliminate the runtime system's knowledge of the naming scheme. compiler/hlds_pred.m: Add a field to pred_infos that says whether the predicate is a unify, compare or index predicate, and if so, for which type constructor. Code that used to test the predicate's name for __Unify__ etc now tests this field instead. Similarly the code that used to employ devious tricks to find out the type the unify/compare/index predicate is for. compiler/rtti.m: Include this field in rtti_proc_labels as well as pred_infos. compiler/make_hlds.m: Fill in this field as appropriate. compiler/proc_label.m: Replace the predicate name with special_pred_id in the proc_labels of unify, index and compare preds. compiler/special_pred.m: Narrow the interface to prevent reliance on the naming scheme for compiler-generated unify, compare and index predicates, except when absolutely necessary, i.e. when creating names for them. Narrow the mechanism required to reverse-engineer the type constructor a unify/compare/index predicate is for from the types to the functionality required by higher_order.m. compiler/code_gen.m: compiler/det_report.m: compiler/higher_order.m: compiler/intermod.m: compiler/layout_out.m: compiler/magic_util.m: compiler/ml_code_util.m: compiler/name_mangle.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/optimize.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/proc_label.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/simplify.m: compiler/termination.m: compiler/typecheck.m: compiler/unify_proc.m: compiler/unused_args.m: Update code and comments to conform to the changes above. compiler/hlds_out.m: Don't refer to the 'type' that a unify, compare or index predicate is for; refer to the type *constructor*. compiler/mlds_to_java.m: Delete an unused predicate. tests/invalid/purity/purity.err_exp: Update this expected output for the change in hlds_out.m.	2003-05-27 05:57:30 +00:00
Zoltan Somogyi	6554ef7daa	Replace "is" with "=". ... Estimated hours taken: 2 Branches: main Replace "is" with "=". Add field names where relevant. Replace integers with counters where relevant.	2003-05-26 09:01:46 +00:00
Zoltan Somogyi	d63cd1d055	Fix test case failures in tests/tabling in asm_fast.gc.mm. ... Estimated hours taken: 0.5 Branches: main Fix test case failures in tests/tabling in asm_fast.gc.mm. These were caused by the fact that my recent change to table_gen.m always stored the call table tip variable in proc_infos, not just when debugging was enabled; however we reserved a stack slot for this variable only when debugging was enabled. compiler/code_gen.m: Change the code to avoid relying the call table tip slot in proc_infos being set only when debugging is enabled. compiler/hlds_pred.m: Change the documentation of the slot to allow it to be set even if debugging is not enabled, since this may come in handy in the future.	2003-05-20 16:20:41 +00:00
Zoltan Somogyi	92045bdc78	Simplify the handling of static ground terms in the LLDS backend. ... Estimated hours taken: 5 Branches: main Simplify the handling of static ground terms in the LLDS backend. Instead of creating code, rtti and layout structures all containing create rvals and then converting those rvals to static cells, create the static cells directly. compiler/llds.m: Remove the create alternative from rvals, and the types used only by create. Delete the code handling the global_data type, which has been moved to global_data.m. compiler/global_data.m: A new module handling static data structures for the LLDS backend. The basis of this module is the code that used to be in llds.m handling the global_data type, but this has been augmented to manage static cells as well as the data structures defined in rtti.m and layout.m. Also, rename the non_common_data field of global_data, which no longer makes sense, to refer to deep profiling, since it holds deep profiling data structures. compiler/llds_common.m: Delete this file, since it is no longer needed. The operative part is now in global data.m; the rest (including the code to traverse code and data structures looking for create rvals) is no longer needed. compiler/ll_backend.m: Delete the deleted module, and add the added module. XXX These changes should be also be documented in notes/compiler_design.html when Fergus finishes his changes to that file. compiler/code_info.m: Add the database of static cells to the code generator state. compiler/code_gen.m: compiler/ll_pseudo_type_info.m: compiler/lookup_switch.m: compiler/mercury_compile.m: compiler/stack_layout.m: compiler/static_term.m: compiler/string_switch.m: compiler/unify_gen.m: compiler/var_locn.m: Instead of creating create rvals, create static cells and return references to those cells. The static cell database ensures that we never create duplicate cells (unless --no-common-data forces us to do so). Pass around the static cell database. compiler/code_util.m: compiler/continuation_info.m: compiler/dupelim.m: compiler/exprn_aux.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/optimize.m: Minor changes to conform to the above, mostly consisting of the deletion of code that handled create rvals.	2003-05-09 05:51:52 +00:00
Zoltan Somogyi	9b0aa613c4	Delete the cell number field from create rvals, since we don't need ... Estimated hours taken: 1 Branches: main compiler/llds.m: Delete the cell number field from create rvals, since we don't need it anymore. compiler/*.m: Conform to the change above, and simplify predicate interfaces by deleting arguments whose sole purpose was the allocation of cell numbers.	2003-05-01 22:50:50 +00:00
Zoltan Somogyi	f7dba9b8f8	Change "compiler_generated" in predicate names and field names ... Estimated hours taken: 0.5 Branches: main compiler/*.m: Change "compiler_generated" in predicate names and field names to "is_unify_or_compare_pred", because that is the actual meaning of those predicates and fields. Delete the XXXs warning about the old misleading name.	2003-03-21 05:52:09 +00:00
Zoltan Somogyi	4954da84cc	Reduce the dependence of the MLDS backend on the LLDS backend by moving ... Estimated hours taken: 2 Branches: main Reduce the dependence of the MLDS backend on the LLDS backend by moving functionality dealing with proc_labels from the LLDS backend (code_util.m) to a new module, proc_label.m, which is part of backend_libs. compiler/code_util.m: compiler/proc_label.m: Move a type and some code from code_util to the new module. Convert predicates to functions as relevant. (The old code was written before functions were available). compiler/backend_libs.m: Add proc_label to the list of submodules. compiler/rtti.m: Rename a function to avoid a name clash with a function in proc_label.m. compiler/*.m: Conform to the changes above. Ensure that all imports of modules in the compiler directory are on lines of their own, to make CVS merges easier. Sort the imports.	2003-03-14 08:10:12 +00:00
Simon Taylor	9aeb2516ec	Avoid dependencies on ll_backend.code_util in *hlds.*. ... Estimated hours taken: 1 Branches: main Avoid dependencies on ll_backend.code_util in *hlds.*. compiler/code_util.m: compiler/hlds_pred.m: Move the predicates to identify builtins into hlds_pred.m. compiler/*.m: Update calls and remove unnecessary imports.	2003-02-28 06:40:43 +00:00
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.	2003-01-17 05:57:20 +00:00
Zoltan Somogyi	2bef47ce85	Extend the information we record about procedures when debugging is enabled ... Estimated hours taken: 20 Branches: main (for now, after more testing, on release branch too) Extend the information we record about procedures when debugging is enabled to include information about the tabling transformation, if the procedure in question is tabled. This is useful to developers in debugging the tabling mechanism, and can be useful to general users by helping them understand the space (and hence time) costs of tabling. Add a new mdb command "table" that uses this information to print programmer-selected subsets of the tables of a tabled procedure. compiler/hlds_pred.m: Generalize the existing field in procedures that used to hold information about I/O tabling to contain information about tabling in general, including forms other than I/O tabling. compiler/continuation_info.m: compiler/code_gen.m: compiler/stack_layout.m: Conform to the changes in hlds_pred.m. compiler/layout.m: Provide Mercury parallels for the new data structures in mercury_stack_layout.h. compiler/layout_out.m: Generate the new data structures in mercury_stack_layout.h. compiler/table_gen.m: Generate the new data structures in hlds_pred.m. compiler/llds_common.m: compiler/opt_debug.m: Conform to the changes in layout.m compiler/llds_out.m: Abstract out existing code into a new procedure to make it available to layout_out.m. Make tabling pointer variables their natural type. compiler/modules.m: Fix an old bug: implicitly import table_builtin.m in .mm grades. doc/mdb_categories: doc/user_guide.texi: Document the new mdb command "table". runtime/mercury_types.h: Move some type definitions here from mercury_tabling.h and mercury_stack_layout.h. This was necessary to avoid problems with circular #includes, in which a.h #includes b.h to get access to a definition, but b.h #includes a.h, which is prevented by the macro guarding against duplicate definition, which causes syntax errors in the rest of b.h because the rest of b.h depends on typedefs in a.h that occur in a.h *after* the #include of b.h. runtime/mercury_label.h: Adjust the list of #includes after the change to mercury_types.h. runtime/mercury_stack_layout.h: Extend the debugging data structures with constructs that describe the call tables, answer tables and answer blocks of tabled procedures. Delete typedefs that are now in mercury_types.h. runtime/mercury_tabling.[ch]: Add new functions to allow lookups without insertions in hash tables containing ints, floats and strings. Add new functions to return the entire contents of these hash tables. Change to four-space indentation where this wasn't done previously. runtime/mercury_grade.h: Increment the binary compatbility version number, partially to account for the change to mercury_stack_layout.h in this diff, but mostly to account for all the other diffs to mercury_stack_layout.h since the last released version. trace/mercury_trace_tables.[ch]: Rename MR_print_proc_id_for_debugger as MR_print_proc_id_and_nl, since this better describes what the function does. trace/mercury_trace_util.[ch]: Add a new function MR_trace_is_integer that reads in signed integers. Rename MR_trace_is_number as MR_trace_is_natural_number, since the former would now be ambiguous. Add a new function MR_trace_is_float that reads in floating point values. library/string.m: Document that MR_trace_is_float uses the same logic as MR_trace_is_float. trace/mercury_trace_browse.c: trace/mercury_trace_vars.c: Update calls to MR_trace_is_number. trace/mercury_trace_internal.c: Implement the new mdb command "table". Update calls to MR_trace_is_number and to MR_print_proc_id_for_debugger. tests/debugger/print_table.{m,inp,exp}: New test case to test the new mdb command. tests/debugger/Mmakefile: Enable the new test case. Disable the sensitive test cases in .mm grades. tests/debugger/completion.exp: Update the expected output to include the new mdb command. tests/debugger/mdb_command_test.inp: Update this automatically generated file to include the new mdb command.	2002-11-15 04:50:49 +00:00
Zoltan Somogyi	d869c5505b	Hide the events associated with the goals inserted by tabling transformations, ... Estimated hours taken: 2 Branches: main Hide the events associated with the goals inserted by tabling transformations, since ordinary programmers shouldn't be exposed to the details of the transformation. (A later diff will adjust the goal paths of the events associated with the original code back to what they would have been without the transformation.) Add a new mdb command, unhide_events, that allows the programmer to expose hidden events. This is intended for implementors only. compiler/hlds_goal.m: Add a new goal feature, hide_debug_event. If a nonatomic goal has this feature, then the associated trace events will be hidden. compiler/trace.m: Respect the new goal feature. compiler/table_gen.m: Add the new goal feature to the compound goals created by tabling transformations. compiler/code_gen.m: compiler/dense_switch.m: compiler/disj_gen.m: compiler/ite_gen.m: compiler/string_switch.m: compiler/switch_gen.m: compiler/tag_switch.m: Pass the required goal_info to trace.m, to allow it to hide events as required. runtime/mercury_trace_base.[ch]: Add two global boolean variables. One says whether we are exposing hidden events, the other says whether we have ever exposed hidden events. trace/mercury_trace.c: Hide hidden events, unless the programmer has asked for them to be exposed. trace/mercury_trace_internal.c: Implement the unhide_events command. Make "dd" check whether we have ever exposed hidden events. Fix some unclear code in "print_optionals". doc/user_guide.texi: Doument the unhide_events command. doc/mdb_categories: Mention the unhide_events command. tests/debugger/mdb_command_test.inp: Test the documentation of the unhide_events command.	2002-09-09 07:48:25 +00:00
Zoltan Somogyi	d531fc48d5	Fix a bug that prevented the tools/extract_incr_sp script from working. ... Estimated hours taken: 0.1 Branches: main Fix a bug that prevented the tools/extract_incr_sp script from working. compiler/code_gen.m: Add a missing space in the comments attached to incr_sp operations. library/builtin.m: Add a missing pred/func indication to the comment of an incr_sp operation.	2002-08-05 02:31:32 +00:00
Zoltan Somogyi	ed83fe4623	Optimize shallow traced modules by not adding calls to MR_trace to shallow ... Estimated hours taken: 12 Branches: main Optimize shallow traced modules by not adding calls to MR_trace to shallow traced procedures which cannot be called from a deep traced environment. A shallow traced procedure can be optimized in this way if it is neither exported from its defining module nor has its address taken. The main purpose of this optimization is not the avoidance of the cost of the MR_trace calls as much as it is the restoration of tail recursion optimization. Previously, compiling a program in a debug grade would disable all tail recursion in the program (since debug grades require at least shallow tracing every module). This was a problem because it limited the sizes of the inputs the debugged program could process before running out of memory. As long as the procedures that recurse on the input are in the implementation section of a shallow traced module, this should no longer happen. compiler/trace_params.m: Introduce the concept of a procedure's effective trace level. This is identical to the global trace level, except if the procedure is not exported and doesn't have its address taken, and the global trace level is shallow. In that case, we say that the procedure's effective trace level is none. Computing a procedure's effective trace level requires its proc_info and its parent pred_info, so require callers to supply these as parameters. compiler/code_info.m: Store the current pred_info as well as the current proc_info, for trace parameter lookups. compiler/continuation_info.m: compiler/code_gen.m: Record the required trace parameters of a procedure in its layout structure, since it can no longer be computed from the global trace level. compiler/stack_layout.m: Use the trace parameters in procedures' layout structures, instead of trying to compute them from the global trace level. compiler/inlining.m: compiler/liveness.m: compiler/stack_alloc.m: compiler/store_alloc.m: compiler/trace.m: Use procedures' effective trace level instead of the global trace level where relevant. compiler/llds.m: Record the required trace parameter of a procedure in its c_procedure representation, since it can no longer be computed from the global trace level. Delete an obsolete field. compiler/optimize.m: compiler/jumpopt.m: Use a required trace parameter of a procedure in its c_procedure representation, since it can no longer be computed from the global trace level. compiler/compile_target_code.m: compiler/handle_options.m: compiler/llds_out.m: compiler/mercury_compile.m: Trivial changes to conform to updated interfaces. compiler/stack_opt.m: Use the option opt_no_return_calls, instead of approximating it with the trace level. (The old code was a holdover from before the creation of the option.) tests/debugger/shallow.m: tests/debugger/shallow2.m: tests/debugger/shallow.{inp,exp*}: Divide the old test case in shallow.m in two. The top level predicates stay in shallow.m and continue to be shallow traced. The two bottom predicates move to shallow2.m and are now deep traced. The new test input checks whether the debugger can walk across the stack frames of procedures in shallow traced modules whose effective trace level is "none" (such as queen/2).	2002-07-30 08:25:20 +00:00
Zoltan Somogyi	d6fbaa2161	Add two pieces of information that will be needed to an upcoming change ... Estimated hours taken: 2 Branches: main Add two pieces of information that will be needed to an upcoming change to the representation of procedure bodies in the declarative debugger. The first piece is the full list of head vars. This is needed now because the debugger no longer ignores variables of type type_info, and thus the Nth headvar is no longer guaranteed to be variable number N. The second piece is a cut/no_cut indicator in `some' goals. This is needed to allow us to reconstruct goal paths exactly as we traverse goal representations. browser/program_representation.m: Make the two data structure changes described above. browser/*.m: Trivial changes to conform to the new data structures. compiler/prog_rep.m: Create the updated data procedure representation. compiler/*.m: Record and transmit the information needed by the updated procedure representation. runtime/mercury_stack_layout.h: Update the documentation of the relevant field in proc_layouts.	2002-04-04 06:00:12 +00:00
Zoltan Somogyi	189b9215ae	This diff implements stack slot optimization for the LLDS back end based on ... Estimated hours taken: 400 Branches: main This diff implements stack slot optimization for the LLDS back end based on the idea that after a unification such as A = f(B, C, D), saving the variable A on the stack indirectly also saves the values of B, C and D. Figuring out what subset of {B,C,D} to access via A and what subset to access via their own stack slots is a tricky optimization problem. The algorithm we use to solve it is described in the paper "Using the heap to eliminate stack accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot. That paper also describes (and has examples of) the source-to-source transformation that implements the optimization. The optimization needs to know what variables are flushed at call sites and at program points that establish resume points (e.g. entries to disjunctions and if-then-elses). We already had code to compute this information in live_vars.m, but this code was being invoked too late. This diff modifies live_vars.m to allow it to be invoked both by the stack slot optimization transformation and by the code generator, and allows its function to be tailored to the requirements of each invocation. The information computed by live_vars.m is specific to the LLDS back end, since the MLDS back ends do not (yet) have the same control over stack frame layout. We therefore store this information in a new back end specific field in goal_infos. For uniformity, we make all the other existing back end specific fields in goal_infos, as well as the similarly back end specific store map field of goal_exprs, subfields of this new field. This happens to significantly reduce the sizes of goal_infos. To allow a more meaningful comparison of the gains produced by the new optimization, do not save any variables across erroneous calls even if the new optimization is not enabled. compiler/stack_opt.m: New module containing the code that performs the transformation to optimize stack slot usage. compiler/matching.m: New module containing an algorithm for maximal matching in bipartite graphs, specialized for the graphs needed by stack_opt.m. compiler/mercury_compile.m: Invoke the new optimization if the options ask for it. compiler/stack_alloc.m: New module containing code that is shared between the old, non-optimizing stack slot allocation system and the new, optimizing stack slot allocation system, and the code for actually allocating stack slots in the absence of optimization. Live_vars.m used to have two tasks: find out what variables need to be saved on the stack, and allocating those variables to stack slots. Live_vars.m now does only the first task; stack_alloc.m now does the second, using code that used to be in live_vars.m. compiler/trace_params: Add a new function to test the trace level, which returns yes if we want to preserve the values of the input headvars. compiler/notes/compiler_design.html: Document the new modules (as well as trace_params.m, which wasn't documented earlier). compiler/live_vars.m: Delete the code that is now in stack_alloc.m and graph_colour.m. Separate out the kinds of stack uses due to nondeterminism: the stack slots used by nondet calls, and the stack slots used by resumption points, in order to allow the reuse of stack slots used by resumption points after execution has left their scope. This should allow the same stack slots to be used by different variables in the resumption point at the start of an else branch and nondet calls in the then branch, since the resumption point of the else branch is not in effect when the then branch is executed. If the new option --opt-no-return-calls is set, then say that we do not need to save any values across erroneous calls. Use type classes to allow the information generated by this module to be recorded in the way required by its invoker. Package up the data structures being passed around readonly into a single tuple. compiler/store_alloc.m: Allow this module to be invoked by stack_opt.m without invoking the follow_vars transformation, since applying follow_vars before the form of the HLDS code is otherwise final can be a pessimization. Make the module_info a part of the record containing the readonly data passed around during the traversal. compiler/common.m: Do not delete or move around unifications created by stack_opt.m. compiler/call_gen.m: compiler/code_info.m: compiler/continuation_info.m: compiler/var_locn.m: Allow the code generator to delete its last record of the location of a value when generating code to make an erroneous call, if the new --opt-no-return-calls option is set. compiler/code_gen.m: Use a more useful algorithm to create the messages/comments that we put into incr_sp instructions, e.g. by distinguishing between predicates and functions. This is to allow the new scripts in the tool directory to gather statistics about the effect of the optimization on stack frame sizes. library/exception.m: Make a hand-written incr_sp follow the new pattern. compiler/arg_info.m: Add predicates to figure out the set of input, output and unused arguments of a procedure in several different circumstances. Previously, variants of these predicates were repeated in several places. compiler/goal_util.m: Export some previously private utility predicates. compiler/handle_options.m: Turn off stack slot optimizations when debugging, unless --trace-optimized is set. Add a new dump format useful for debugging --optimize-saved-vars. compiler/hlds_llds.m: New module for handling all the stuff specific to the LLDS back end in HLDS goal_infos. compiler/hlds_goal.m: Move all the relevant stuff into the new back end specific field in goal_infos. compiler/notes/allocation.html: Update the documentation of store maps to reflect their movement into a subfield of goal_infos. compiler/*.m: Minor changes to accomodate the placement of all back end specific information about goals from goal_exprs and individual fields of goal_infos into a new field in goal_infos that gathers together all back end specific information. compiler/use_local_vars.m: Look for sequences in which several instructions use a fake register or stack slot as a base register pointing to a cell, and make those instructions use a local variable instead. Without this, a key assumption of the stack slot optimization, that accessing a field in a cell costs only one load or store instruction, would be much less likely to be true. (With this optimization, the assumption will be false only if the C compiler's code generator runs out of registers in a basic block, which for the code we generate should be unlikely even on x86s.) compiler/options.m: Make the old option --optimize-saved-vars ask for both the old stack slot optimization (implemented by saved_vars.m) that only eliminates the storing of constants in stack slots, and the new optimization. Add two new options --optimize-saved-vars-{const,cell} to turn on the two optimizations separately. Add a bunch of options to specify the parameters of the new optimizations, both in stack_opt.m and use_local_vars.m. These are for implementors only; they are deliberately not documented. Add a new option, --opt-no-return-cells, that governs whether we avoid saving variables on the stack at calls that cannot return, either by succeeding or by failing. This is for implementors only, and thus deliberately documented only in comments. It is enabled by default. compiler/optimize.m: Transmit the value of a new option to use_local_vars.m. doc/user_guide.texi: Update the documentation of --optimize-saved-vars. library/tree234.m: Undo a previous change of mine that effectively applied this optimization by hand. That change complicated the code, and now the compiler can do the optimization automatically. tools/extract_incr_sp: A new script for extracting stack frame sizes and messages from stack increment operations in the C code for LLDS grades. tools/frame_sizes: A new script that uses extract_incr_sp to extract information about stack frame sizes from the C files saved from a stage 2 directory by makebatch and summarizes the resulting information. tools/avg_frame_size: A new script that computes average stack frame sizes from the files created by frame_sizes. tools/compare_frame_sizes: A new script that compares the stack frame size information extracted from two different stage 2 directories by frame_sizes, reporting on both average stack frame sizes and on specific procedures that have different stack frame sizes in the two versions.	2002-03-28 03:44:41 +00:00
Fergus Henderson	7597790760	Use sub-modules to structure the modules in the Mercury compiler directory. ... The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c.	2002-03-20 12:37:56 +00:00
Zoltan Somogyi	13f0e7610a	A large step towards declarative debugging of goals that do I/O. ... Estimated hours taken: 40 Branches: main A large step towards declarative debugging of goals that do I/O. This step does everything needed for that except modify the declarative debugger itself; that is for Mark to do. If you give the new option --trace-table-io-decl, the transformation performed by the compiler on I/O primitives will preserve not just the output arguments of the primitive, so that the primitive can be "reexecuted" without performing any side-effects, but also the input arguments and the identity of the I/O primitive itself. The I/O table therefore will contain a list of the I/O primitives executed by the program after I/O tabling is started. You can test this via the new debugger commands "print action <action-number>" and "browse action <action-number>". The new option is currently not documented, because the declarative debugger does not yet use the information it provides. The new debugger commands are not documented because they are meant only for implementors, at least for now. Since this change adds a field to proc_layout structures, any workspaces compiled with debugging enabled will need to do a cvs update when this change is installed. compiler/options.m: Add the option --trace-table-io-decl. When set, this causes the compiler to transform I/O action primitives to allow declarative debugging of I/O actions. compiler/handle_options.m: Make --trace-table-io-decl imply --trace-table-io. compiler/table_gen.m: Perform the transformation, which is similar to the existing --trace-table-io transformation, but preserves the identity of all non-io-state arguments (not just the outputs) and the identity of the I/O primitive itself. Provide better names for variables generated by tabling transformations. compiler/hlds_goal.m: Add extra parameters to procedures whose job it is to create new goals to name the variables in those goals. compiler/layout.m: Add a new layout structure to contain the information the runtime system needs to interpret the information saved by the new transformation. compiler/layout_out.m: Output the new layout structure. compiler/continuation_info.m: Add a field to proc_layouts to point to the declarative I/O tabling structure, and another to identify the proc_layout without using LLDS types. compiler/code_gen.m: Provide the definition of this field when appropriate. compiler/hlds_pred.m: Add a field to proc_infos to store the information from the tabling transformation until code generation. compiler/stack_layout.m: Add a mechanism for transforming the high level description of I/O action tabling data in proc_infos to the low level description we need to generate C data structures. compiler/hlds_data.m: Add a new cons_id and a new cons_tag; they are used to refer to I/O tabling structures in code generated by the new transformation. compiler/*.m: Handle the updates to global data types above. library/table_builtin.m: Modernize some old code. Fix an old off-by-one error: make I/O tabling use the first slot in the I/O action table. library/varset.m: Add a mechanism for creating a variable that is named iff the caller has a name for it. runtime/mercury_layout_util.[ch]: Add a function for materializing type parameters from an answer block, not from registers or a closure. runtime/mercury_stack_layout.h: Declare a C type for the data structure holding information about I/O primitives transformed by --trace-table-io-decl, and add a field to proc_layout structures to point to these new structures. Add a new evaluation method for --trace-table-io-decl. runtime/mercury_tabling_macros.h: Add some conditionally-compiled debugging code to the primitive for saving answers. trace/mercury_trace_vars.[ch]: Add functions for printing I/O action goals. trace/mercury_trace_internal.c: Add code for recognizing and implementing commands to print I/O action goals. trace/mercury_trace.c: Add code for handling the new eval method. tests/debugger/tabled_read.{m,inp,exp*}: Add a polymorphic I/O action primitive, add calls to it, and test the printing of both monomorphic and polymorphic action goals. tests/debugger/tabled_read_decl.{m,inp,exp*,data}: A new test case. It does the same things as the new version of tabled_read, but it is compiled with --trace-table-io-decl, not just --trace-table-io. It therefore can (and does) test the printing of tabled I/O actions. tests/debugger/Mmakefile: Add the new test case.	2002-02-20 03:14:51 +00:00
Simon Taylor	b7c4a317e9	Add MR_ prefixes to the remaining non-prefixed symbols. ... Estimated hours taken: 4 Branches: main Add MR_ prefixes to the remaining non-prefixed symbols. This change will require all workspaces to be updated The compiler will start generating references to MR_TRUE, MR_bool, etc., which are not defined in the old runtime header files. runtime/mercury_std.h: Add MR_ prefixes to bool, TRUE, FALSE, max, min, streq, strdiff, strtest, strntest, strneq, strndiff, strntest, NO_RETURN. Delete a commented out definition of `reg'. runtime/mercury_tags.h: Add an MR_ prefix to TAGBITS. configure.in: runtime/mercury_goto.h: runtime/machdeps/i386_regs.h/mercury_goto.h: Add an MR_ prefix to PIC. runtime/mercury_conf_param.h: Allow non-prefixed PIC and HIGHTAGS to be defined on the command line. runtime/mercury_bootstrap.h: Add backwards compatibility definitions. RESERVED_MACRO_NAMES: Remove the renamed macros. compiler/export.m: compiler/ml_code_gen.m: Use MR_bool rather than MR_Bool (MR_Bool is meant to be for references to the Mercury type bool__bool). runtime/mercury_types.h: Add a comment the MR_Bool is for references to bool__bool. */*.c: */*.h: */*.m: Add MR_ prefixes.	2002-02-18 07:01:33 +00:00
Zoltan Somogyi	9c58f97e3b	Add a new optimization, --use-local-vars, to the LLDS backend. ... Estimated hours taken: 20 Branches: main Add a new optimization, --use-local-vars, to the LLDS backend. This optimization is intended to replace references to fake registers and stack slots with references to temporary variables in C code, since accessing these should be cheaper. With this optimization and one for delaying construction unifications, the eager code generator should generate code at least good as that produced by the old value numbering pass. This should make it possible to get rid of value numbering, which is much harder to maintain. compiler/use_local_vars.m: New module containing the optimization. compiler/notes/compiler_design.html: Mention the new module. compiler/exprn_aux.m: Add new utility predicates for use by use_local_vars. If --debug-opt is specified, do not dump instruction sequences to standard output. Instead, put them in separate files, where they can be compared more easily. compiler/options.m: Add the --use-local-vars option to control whether the use_local_vars pass gets run. compiler/llds.m: Add liveness information to the c_code and pragma_foreign_code LLDS instructions, in order to allow use_local_vars to work in the presence of automatically-generated C code (e.g. by debugging). compiler/livemap.m: Use the new liveness information to generate useful livemap information even in the presence of automatically generated C code. compiler/code_gen.m: compiler/code_info.m: compiler/dupelim.m: compiler/frameopt.m: compiler/llds_common.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pragma_c_gen.m: compiler/trace.m: compiler/vn_block.m: compiler/vn_cost.m: compiler/vn_filter.m: compiler/vn_verify.m: Provide and/or ignore this additional liveness information. compiler/wrap_block.m: The post_value_number pass wraps LLDS instruction sequences using temporaries in a block instruction which actually declares those temporaries. It used to be used only by value numbering; it is now also used by use_local_vars. It has therefore been renamed and put in its own file. compiler/optimize.m: Invoke use_local_vars if required, and call wrap_blocks instead of post_value_number. compiler/value_number.m: Since the value numbering pass still cannot handle automatically generated C code, check for it explicitly now that livemap carries out only a weaker check. compiler/basic_block.m: Add a module qualification. library/set.m: library/set_bbbtree.m: library/set_ordlist.m: library/set_unordlist.m: Add a new predicate, union_list, to each implementation of sets, for use by some of the new code above. tests/general/array_test.m: Print out the result of each operation as soon as it is done, so that if you get a seg fault, you know which operations have completed and which haven't.	2001-04-24 03:59:13 +00:00
Adrian Pellas-Rice	1c65d003f7	Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. ... Estimated hours taken: 4.5 Branches: main Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations. compiler/hlds_goal.m Create a new type, the `shorthand_goal_expr', for goals kinds that are implemented by a (ordinary_hlds + shorthand) -> (ordinary_hlds) transformation. At present, bi_implication is the only kind of of goal that is implemented in this way. Moved bi_implication functor from the type goal_expr to the new shorthand_goal_expr type. Added the functor shorthand to the goal_expr type. compiler/*.m Change switches on hlds_goal_expr that call error when they recognise `bi_implication' from calling error when they recognise `bi_implication' to calling error when they recognise `shorthand'. For all predicates K that a) switch on hlds_goal_expr and b) perform non-trivial processing when they recognise `bi_implication' change K such that it now calls K_shorthand upon recognising the functor `shorthand'. Define K_shorthand to switch on shorthand_goal_expr, where the code for the `bi_implication' case formerly contained in K is now contained in K_shorthand.	2001-04-07 14:05:03 +00:00
Tyson Dowd	711da78188	Rename foreign_code as foreign_proc where appropriate in the compiler. ... Estimated hours taken: 4.0 Branches: main Rename foreign_code as foreign_proc where appropriate in the compiler. The rationale for this change is that it makes maintaining the code much simpler because it is clear whether `foreign' refers to a slab of code (foreign_code) or a procedure (foreign_proc). :- type pragma_foreign_code_attributes :- type pragma_foreign_proc_attributes The functors for pragma_type foreign(Lang, BodyCode) foreign(Attributes, Name, PredOrFunc, Vars, Varset, Impl) become foreign_code(Lang, BodyCode) foreign_proc(Attributes, Name, PredOrFunc, Vars, Varset, Impl) And the HLDS goal `pragma_foreign_code' becomes `foreign_proc'. compiler/*.m: Update the compiler to use the new names.	2001-04-03 03:20:33 +00:00
Levi Cameron	0921310ca5	More work on the bytecode interpreter. ... With these changes, it now passes all tests/general/* test cases except those with floats. Changes to the compiler: - Added extra argument to test instruction (string comparisons were being treated as integer comparisons; properly deals with different atomic type unifications now) - Changed bytecode stub functions Changes to the bytecode interpreter: - Cleaned up comments - Forked part of mb_machine to mb_exec - Added support for submodules - Added support for nondet procedures - Added support for cc_xxx procedures - Finished higher order calls - Added (very basic) debug interface - Added support for type information - Added memory corruption checking - Changed machine state dump formatting - Fixed bug in nested switches - Resolved builtin__unify and builtin_compare failures - Modified bytecode tags generation so .c & .m tag files are separate - Header usage rationalised Changes to test suite: - Added test cases for the bytecode interpreter. - More work on the bytecode interpreter. bytecode/Mmakefile: Modified bytecode tags generation so .c & .m tag files are separate. mb_machine split into mb_exec. test file renamed to simple.m (copy over tests/simple??.m to test). bytecode/TODO: Updated. bytecode/mb_basetypes.h: Removed redundant MB_WORD_BITS (use MR_WORDBITS instead). bytecode/mb_bytecode.h: bytecode/mpb_bytecode.c: Formatting changes Third test instruction argument added. bytecode/mb_disasm.h: bytecode/mb_disasm.c: Formatting changes. Third test instruction argument added. Added MB_FMT_INTWIDE. bytecode/mb_exec.h: bytecode/mb_exec.c: bytecode/mb_machine.h: bytecode/mb_machine.c: mb_machine* split into mb_exec* and mb_machine*. Almost all instructions now work (see important changes above). bytecode/mb_interface.h: bytecode/mb_interface.c: Added nondet stub functions. Added functions to lookup builtin compiler procedures: do_redo, do_fail, __unify, __compare. Removed old debugging code. Stack layout changed to support nondet procedures. bytecode/mb_interface_stub.c: bytecode/mb_interface_stub.h: Split off bare minimum of includes for bytecode stubs. Added nondet stubs. bytecode/mb_machine_show.c: Made code cleaner (added subfunctions for MB_show_state). Added variable names to machine state dump. bytecode/mb_mem.h: bytecode/mb_mem.c: Added limited memory corruption checking. bytecode/mb_module.h: bytecode/mb_module.c: Swapped order of temps & vars on stack. Fixed nested switches causing random crashes. Added nested module support. bytecode/test/simple??.m: Various test files - just to check that it doesn't crash. (Most do not output anything & must be verified by stepping through manually). compiler/bytecode.m: compiler/bytecode_gen.m: Added extra argument to test instruction (otherwise string comparisons would be treated as integer comparisons). compiler/code_gen.m: Changed call structure name in bytecode stub to resolve issues with illegal characters in C structure names. Changed bytecode stub header file name.	2001-02-19 02:05:59 +00:00
Levi Cameron	cfd7bd279a	Changed code generator to output bytecode stubs as needed ... Estimated hours taken: 4 Changed code generator to output bytecode stubs as needed Will not output stubs for compiler generated procedures or for procedures with foreign code bytecode/code_gen.m: Changed code generator to output bytecode call stub if procedure contains no foreign code and procedure was not automatically generated by the compiler bytecode/hlds_util.m: Added predicates to determine if a goal tree contains any foreign code. bytecode/llds_out.m: Added a #include to modules generating bytecode	2001-02-05 00:46:42 +00:00