57 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	295415090e	Convert almost all remaining modules in the compiler to use ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all remaining modules in the compiler to use "$module, $pred" instead of "this_file" in error messages. In a few cases, the old error message was misleading, since it contained an incorrect, out-of-date or cut-and-pasted predicate name. tests/invalid/unresolved_overloading.err_exp: Update an expected output containing an updated error message.	2011-05-23 05:08:24 +00:00
Julien Fischer	78b0bf3c7f	Use state variable field update syntax in more places. ... Branches: main Use state variable field update syntax in more places. browser/*.m: compiler/*.m: deep_profiler/*.m: As above.	2011-05-05 07:11:52 +00:00
Zoltan Somogyi	8a28e40c9b	Add the predicates sorry, unexpected and expect to library/error.m. ... Estimated hours taken: 2 Branches: main Add the predicates sorry, unexpected and expect to library/error.m. compiler/compiler_util.m: library/error.m: Move the predicates sorry, unexpected and expect from compiler_util to error. Put the predicates in error.m into the same order as their declarations. compiler/*.m: Change imports as needed. compiler/lp.m: compiler/lp_rational.m: Change imports as needed, and some minor cleanups. deep_profiler/*.m: Switch to using the new library predicates, instead of calling error directly. Some other minor cleanups. NEWS: Mention the new predicates in the standard library.	2010-12-15 06:30:36 +00:00
Zoltan Somogyi	543fc6e342	Change the way the typechecker iterates over the predicates of the program. ... Estimated hours taken: 12 Branches: main Change the way the typechecker iterates over the predicates of the program. We used to do it by looking up each predicate in the module_info, typechecking it, and putting it back into the module_info. We now do it by converting the predicate table into a list, iterating over the list transforming each pred_info in it, converting the updated list back to a predicate table. The original intention of this change was to allow different predicates to be typechecked in parallel by removing a synchronization bottleneck: the typechecking of a predicate now doesn't have to wait for the typechecking of the previous predicate to generate the updated version of the module_info. However, it turned out that the change is good for sequential execution as well, improving the time on tools/speedtest from 11.33 seconds to 11.08 seconds, a speedup of 2.2%. On tools/speedtest -l, which tests the compilation of more modules, the speedup is even better: 3.1% (from 32.63 to 31.60s). compiler/typecheck.m: Implement the above change. compiler/hlds_module.m: compiler/pred_table.m: Add a new operation, setting the list of valid pred_ids, now needed by typecheck.m, to both modules. Make the names of the predicates for accessing the predicate table more expressive, and make them conform to our naming conventions. compiler/*.m: Trivial changes to conform to the change in hlds_module.m. library/assoc_list.m: Add new predicates used by the new version of typecheck.m (at some time in its development). NEWS: Mention the new predicates. library/list.m: Improve documentation that is now copied to assoc_list.m. tools/speedtest: Make the test command more easily configurable.	2010-07-30 05:16:26 +00:00
Zoltan Somogyi	4ebe3d0d7e	Stop storing globals in the I/O state, and divide mercury_compile.m ... Estimated hours taken: 60 Branches: main Stop storing globals in the I/O state, and divide mercury_compile.m into smaller, more cohesive modules. (This diff started out as doing only the latter, but it became clear that this was effectively impossible without the former, and the former ended up accounting for the bulk of the changes.) Taking the globals out of the I/O state required figuring out how globals data flowed between pieces of code that were often widely separated. Such flows were invisible when globals could be hidden in the I/O state, but now they are visible, because the affected code now passes around globals structures explicitly. In some cases, the old flow looked buggy, as when one job invoked by mmc --make could affect the globals value of its parent or the globals value passed to the next job. I tried to fix such problems when I saw them. I am not 100% sure I succeeded in every case (I may have replaced old bugs with new ones), but at least now the flow is out in the open, and any bugs should be much easier to track down and fix. In most cases, changes the globals after the initial setup are intended to be in effect only during the invocation of a few calls. This used to be done by remembering the initial values of the to-be-changed options, changing their values in the globals in the I/O state, making the calls, and restoring the old values of the options. We now simply create a new version of the globals structure, pass it to the calls to be affected, and then discard it. In two cases, when discovering reasons why (1) smart recompilation should not be done or (2) item version numbers should not be generated, the record of the discovery needs to survive this discarding. This is why in those cases, we record the discovery by setting a mutable attached to the I/O state. We use pure code (with I/O states) both to read and to write the mutables, so this is no worse semantically than storing the information in the globals structure inside the I/O state. (Also, we were already using such a mutable for recording whether -E could add more information.) In many modules, the globals information had to be threaded through several predicates in the module. In some places, this was made more difficult by predicates being defined by many clauses. In those cases, this diff converts those predicates to using explicit disjunctions. compiler/globals.m: Stop storing the globals structure in the I/O state, and remove the predicates that accessed it there. Move a mutable and its access predicate here from handle_options.m, since here is when the mutables treated the same way are. In a couple of cases, the value of an option is available in a mutable for speed of access from inside performance-critical code. Set the values of those mutables from the option when the processing of option values is finished, not when it is starting, since otherwise the copies of each option could end up inconsistent. Validate the reuse strategy option here, since doing it during ctgc analysis (a) is too late, and (b) would require an update to the globals to be done at an otherwise inconvenient place in the code. Put the reuse strategy into the globals structure. Two fields in the globals structure were unused. One (have_printed_usage) was made redundant when the one predicate that used it itself became unused; the other (source_file_map) was effectively replaced by a mutable some time ago. Delete these fields from the globals. Give the fields of the globals structure a distinguishing prefix. Put the type declarations, predicate declarations and predicate definitions in a consistent order. compiler/source_file_map.m: Record this module's results only in the mutable (it serves as a cache), not in globals structure. Use explicitly passed globals structure for other purposes. compiler/handle_options.m: Rename handle_options as handle_given_options, since it does not process THE options to the program, but the options it is given, and even during the processing of a single module, it can be invoked up the three times in a row, each time being given different options. (It was up to four times in a row before this diff.) Make handle_given_options explicitly return the globals structure it creates. Since it does not take an old global structure as input and globals are not stored in the I/O state, it is now clear that the globals structure it returns is affected only by the default values of the options and the options it processes. Before this diff, in the presence of errors in the options, handle_options *could* return (implicitly, in the I/O state) the globals structure that happened to be in the I/O state when it was invoked. Provide a separate predicate for generating a dummy globals based only on the default values of options. This allows by mercury_compile.m to stop abusing a more general-purpose predicate from handle_options.m, which we no longer export. Remove the mutable and access predicate moved to globals.m. compiler/options.m: Document the fact that two options, smart_recompilation and generate_item_version_numbers, should not be used without seeing whether the functionalities they call for have been disabled. compiler/mercury_compile_front_end.m: compiler/mercury_compile_middle_passes.m: compiler/mercury_compile_llds_back_end.m: compiler/mercury_compile_mlds_back_end.m: compiler/mercury_compile_erl_back_end.m: New modules carved out of the old mercury_compile.m. They each cover exactly the areas suggested by their names. Each of the modules is more cohesive than the old mercury_compile.m. Their code is also arranged in a more logical order, with predicates representing compiler passes being defined in the order of their invocation. Some of these modules export predicates for use by their siblings, showing the dependencies between the groups of passes. compiler/top_level.m: compiler/notes/compiler_design.html: Add the new modules. compiler/mark_static_terms.m: Move this module from the ml_backend package to the hlds package, since (a) it does not depend on the MLDS in any way, and (b) it is also needed by a compiler pass (loop invariants) in the middle passes. compiler/hlds.m: compiler/ml_backend.m: compiler/notes/compiler_design.html: Reflect mark_static_terms.m's change of package. compiler/passes_aux.m: Move the predicates for dumping out the hLDS here from mercury_compile.m, since the new modules also need them. Look up globals in the HLDS, not the I/O state. compiler/hlds_module.m: Store the prefix (common part) of HLDS dump file names in the HLDS itself, so that the code moved to passes_aux.m can figure out the file name for a HLDS dump without doing system calls. Give the field names of some structures prefixes to avoid ambiguity. compiler/mercury_compile.m: Remove the code moved to the other modules. This module now looks after only option handling (such as deciding whether to generate .int3 files, .int files, .opt files etc), and the compilation passes up to and including the creation of the first version of the HLDS. Everything after that is subcontracted to the new modules. Simplify and make explicit the flow of globals information. When invoking predicates that could disable smart recompilation, check whether they have done so, and if yes, update the globals accordingly. When compiling via gcc, we need to link into the executable the object files of any separate C files we generate for C code foreign_procs, which we cannot translate into gcc's internal structures without becoming a C compiler as well as a Mercury compiler. Instead of adding such files to the accumulating option for extra object files in the globals structure, we return their names using the already existing mechanism we have always used to link the object files of fact tables into the executable. Give several predicates more descriptive names. Put predicates in a more logical order. compiler/make.m: compiler/make.dependencies.m: compiler/make.module_target.m: compiler/make.module_dep_file.m: compiler/make.program_target.m: compiler/make.util.m: Require callers to supply globals structures explicitly, not via the I/O state. Afterward pass them around explicitly, passing modified versions to mercury_compile.m when invoking it with module- and/or task-specific options. Due the extensive use of partial application for higher order code in these modules, passing around the globals structures explicitly is quite tricky here. There may be cases where a predicate uses an old globals structure it got from a closure instead of the updated module- and/or task-specific globals it should be using, or vice versa. However, it is just as likely that, this diff fixes old problems by preventing the implicit flow of updated-only-for-one-invocation globals structures back to the original invoking context. Although I have tried to be careful about this, it is also possible that in some places, the code is using an updated-for-an-invocation globals structure in some but not all of the places where it SHOULD be used. compiler/c_util.m: compiler/compile_target_code.m: compiler/compiler_util.m: compiler/error_util.m: compiler/file_names.m: compiler/file_util.m: compiler/ilasm.m: compiler/ml_optimize.m: compiler/mlds_to_managed.m: compiler/module_cmds.m: compiler/modules.m: compiler/options_file.m: compiler/pd_debug.m: compiler/prog_io.m: compiler/transform_llds.m: compiler/write_deps_file.m: Require callers to supply globals structures explicitly, not via the I/O state. In some cases, the explicit globals structure argument allows a predicate to dispense with the I/O states previously passed to it. In some modules, rename some predicates, types and/or function symbols to avoid ambiguity. compiler/read_modules.m: Require callers to supply globals structures explicitly, not via the I/O state. Record when smart recompilation and the generation of item version numbers should be disabled. compiler/opt_debug.m: compiler/process_util.m: Require callers to supply the needed options explicitly, not via the globals in the I/O state. compiler/analysis.m: compiler/analysis.file.m: compiler/mmc_analysis.m: Make the analysis framework's methods take their global structures as explicit arguments, not as implicit data stored in the I/O state. Stop using `with_type` and `with_inst` declarations unnecessarily. Rename some predicates to avoid ambiguity. compiler/hlds_out.m: compiler/llds_out.m: compiler/mercury_to_mercury.m: compiler/mlds_to_c.m: compiler/mlds_to_java.m: compiler/optimize.m: Make these modules stop accessing the globals from the I/O state. Do this by requiring the callers of their top predicates to explicitly supply a globals structure. To compensate for the cost of having to pass around a representation of the options, look up the values of the options of interest just once, to make further access much faster. (In the case of mlds_to_c.m, the code already did much of this, but it still had a few accesses to globals in the I/O state that this diff eliminates.) If the module exports a predicate that needs these pre-looked-up options, then export the type of this data structure and its initialization function. compiler/frameopt.m: Since this module needs only one option from the globals, pass that option instead of the globals. compiler/accumulator.m: compiler/add_clause.m: compiler/closure_analysis.m: compiler/complexity.m: compiler/deforest.m: compiler/delay_construct.m: compiler/elds_to_erlang.m: compiler/exception_analysis.m: compiler/fact_table.m: compiler/intermod.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/pd_util.m: compiler/post_term_analysis.m: compiler/recompilation.usage.m: compiler/size_prof.usage.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.m: compiler/structure_sharing.analysis.m: compiler/tabling_analysis.m: compiler/term_constr_errors.m: compiler/term_constr_fixpoint.m: compiler/term_constr_initial.m: compiler/term_constr_main.m: compiler/term_constr_util.m: compiler/trailing_analysis.m: compiler/trans_opt.m: compiler/typecheck_info.m: Look up globals information from the HLDS, not the I/O state. Conform to the changes above. compiler/gcc.m: compiler/maybe_mlds_to_gcc.pp: compiler/mlds_to_gcc.m: Look up globals information from the HLDS, not the I/O state. Conform to the changes above. Convert these modules to our current programming style. compiler/termination.m: Look up globals information from the HLDS, not the I/O state. Conform to the changes above. Report some warnings with error_specs, instead of immediately printing them out. compiler/export.m: compiler/il_peephole.m: compiler/layout_out.m: compiler/rtti_out.m: compiler/liveness.m: compiler/make_hlds.m: compiler/make_hlds_passes.m: compiler/mlds_to_il.m: compiler/mlds_to_ilasm.m: compiler/recompilation.check.m: compiler/stack_opt.m: compiler/superhomogeneous.m: compiler/tupling..m: compiler/unneeded_code.m: compiler/unused_args.m: compiler/unused_import.m: compiler/xml_documentation.m: Conform to the changes above. compiler/equiv_type_hlds.m: Give the field names of a structure prefixes to avoid ambiguity. Stop using `with_type` and `with_inst` declarations unnecessarily. compiler/loop_inv.m: compiler/pd_info.m: compiler/stack_layout.m: Give the field names of some structures prefixes to avoid ambiguity. compiler/add_pragma.m: Add notes. compiler/string.m: NEWS: Add a det version of remove_suffix, for use by new code above.	2009-10-14 05:28:53 +00:00
Zoltan Somogyi	5ad9a27793	Speed up the compiler's handling of code that constructs large ground terms ... Estimated hours taken: 80 Branches: main Speed up the compiler's handling of code that constructs large ground terms by specializing the treatment of such code. This diff reduces the compilation time for training_cars_full.m from 106.9 seconds to 30.3 seconds on alys, my laptop. The time on tools/speedtest stays pretty much the same. compiler/hlds_goal.m: Record the classification of from_ground_term scopes as purely constructing terms, purely deconstructing them or something other. Fix an old potential bug: variables inside the construct_how fields of unifications weren't being renamed along with other variables. This is a bug if any part of the compiler later looks at those variables. (I am not sure whether or not this happens.) compiler/superhomogenous.m: Provisionally mark newly constructed static terms as being from_ground_term_construct. Mode checking will either confirm this or change the scope kind. compiler/options.m: compiler/handle_options.m: Add a new option, from_ground_term_threshold, that allows the user to set the boundary between ground terms that get scopes and ground terms do not. I plan to experiment with different settings later. compiler/modes.m: Make this classification. For scopes that construct ground terms, use a specialized algorithm that avoids quadratic behavior. (It does not access the unify_inst_table, which is where the factor of N other than the length of the goal list came from.) The total size of the instmap_deltas, if printed out, still looks like O(N^2) in size, but due to structure sharing it needs only O(N) memory. For scopes that construct ground terms, set the determinism information so that det_analysis.m doesn't have to traverse such scopes. When handling disjunctions, check whether some nonlocals of the disjunctions are constructed by from_ground_term_construct scopes. For any such nonlocals, set their insts to just ground, throwing away the precise information we have about exactly what function symbols they and ALL their subterms are bound to. This is HUGE win, since it allows us avoid spending a lot of time building a huge merge_inst table, which later passes of the compiler (e.g. equiv_type_hlds) would then have to spend similarly huge times traversing. This approach does have a down side. If lots of arms of a disjunction bind a nonlocal to a large ground term, but a few bind it to a SMALL ground term, a term below the from_ground_term_threshold, this optimization won't kick in. That could be one purpose of the new option. It isn't documented yet; I will seek feedback about its usefulness first. compiler/modecheck_unify.m: Handle the three different kinds of right hand sides separately. This yields a small speedup, because now we don't test rhs_vars and rhs_functors (the common right hand sides) for a special case (goals containing "any" insts) that is applicable only to rhs_lambda_goals. compiler/unique_modes.m: Don't traverse scopes that construct ground terms, since modes.m has already done everything that needs to be done. compiler/det_analysis.m: Don't traverse scopes that construct ground terms, since modes.m has already done the needed work. compiler/instmap.m: Add a new predicate for use by modes.m. Many predicate names in this module were quite uninformative; give them informative names. compiler/polymorphism.m: If this pass invalidates the from_ground_term_construct invariants, then mark the relevant scope as from_ground_term_other. Delete two unused access predicates. compiler/equiv_type_hlds.m: Don't traverse scopes that construct ground terms, since modes.m ensures that their instmap deltas do not contain typed insts, and thus the scope cannot contain types that need to be expanded. Convert some predicates to single clauses. compiler/goal_form.m: compiler/goal_util.m: In predicates that test goals for various properties, don't traverse scopes that construct ground terms when the outcome of the test is the same for all such scopes. Convert some predicates to single clauses. compiler/simplify.m: Do not look for common structs in from_ground_term_construct scopes, both because this speeds up the compiler, and because retaining references to ground terms is in fact a pessimization, not an optimization. This is because (a) those references need to be stored in stack slots across calls, and (b) the C code generators ensure that the cells representing ground terms will be shared as needed. If all arms of a switch are from_ground_term_construct scopes, do not merge the instmap_deltas from those arms, since this is both time-consuming (even after the other changes in this diff) and extremely unlikely to improve the instmap_delta. Disable common_struct in from_ground_term_construct scopes, since for these scopes, it is actually a pessimization. Do not delete from_ground_term_construct scopes, since many compiler passes can now use them. Do some manual deforestation, break up some large predicates, and give better names to some. compiler/liveness.m Special-case the handling from_ground_term_construct scopes. This allows us to traverse them just once instead of three times, and this traversal is simpler and faster than any of the three. In some traversals, we were switching on the goal type twice; once in e.g. detect_liveness_in_goal_2, and once by calling goal_expr_has_subgoals. Eliminate the double switching by merging the relevant predicates. (The double-switching structure was easier to work with before we had multi-cons-id switches.) compiler/typecheck.m: Move a lookup after a test, so we don't have to do it if the test fails. Provide a specialized mode for a predicate. This should allow the compiler to eliminate an argument and a test in the common case. Note a possible chance for a speedup. compiler/typecheck_info.m: Don't apply empty substitutions to the types of a possibly very large set of variables. compiler/quantification.m: Don't quantify from_ground_term_construct scopes. They are created correctly quantified, and any compiler pass that invalidates that quantification also removes the from_ground_term_construct mark. Don't apply empty renamings to a possibly very large set of variables. Move the code for handling scopes to its own predicate, to avoid overwhelming the code that handles other kinds of goals. Even from this, factor out the renaming code, since it is needed only for some kinds of scopes. Make some predicate names better reflect what the predicate does. compiler/pd_cost.m: For from_ground_term_construct scopes, instead of computing their cost by adding up the costs of the goals inside, make their cost a constant, since binding a variable to a static term takes constant time. compiler/pd_info.m: Add prefixes on field names to avoid ambiguities. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/closure_analysis.m: compiler/constraint.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/distance_granularity.m: compiler/exception_analysis.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/format_call.m: compiler/granularity.m: compiler/higher_order.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/loop_inv.m: compiler/middle_rec.m: compiler/mode_util.m: compiler/parallel_to_plain_conj.m: compiler/saved_vars.m: compiler/stm_expand.m: compiler/store_alloc.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.lbu.m: compiler/structure_sharing.analysis.m: compiler/switch_detection.analysis.m: compiler/trail_analysis.m: compiler/term_pass1.m: compiler/tupling.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: These passes have nothing to do in from_ground_term_construct scopes, so don't traverse them. In some modules (e.g. dead_proc_elim), some traversals had to be kept. In loop_inv.m, replace a code structure that updated accumulators with functions (which prevented the natural use of state variables), that in lots of places reconstructed the term it had just deconstructed, and obscured the identical handling of different kinds of goals, with a structure based on predicates, state variables and shared code for different goal types where possible. In store_alloc.m, avoid some double switching on the same value. In stratify.m, unneeded_code.m and unused_args.m, rename predicates to avoid ambiguities. compiler/goal_path.m: compiler/goal_util.m: compiler/implementation_defined_literals.m: compiler/intermode.m: compiler/mark_static_terms.m: compiler/ml_code_gen.m: compiler/mode_ordering.m: compiler/ordering_mode_constraints.m: compiler/prop_mode_constraints.m: compiler/purity.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_path.m: compiler/rbmm.region_transformation.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/term_const_build.m: compiler/term_traversal.m: compiler/unused_imports.m: Mark places where we cannot (yet) special case from_ground_term_construct scopes. In structure_reuse.lfu.m, turn nested if-then-elses into a switch in. compiler/size_prof.m: Turn from_ground_term_construct scopes into from_ground_term_other scopes, since in term size profiling grades, we need to attach sizes to terms. Give predicates better names. compiler/*.m: Minor changes to conform to the changes above. compiler/make_hlds_passes.m: With -S, print statistics after the third pass over items, since this is the time-consuming one. compiler/mercury_compile.m: Conform to the new names of some predicates. When declining to output a HLDS dump because it would be identical to the previous dump, don't confuse the user either by being silent about the decision, or by leaving an old dump laying around that could be mistaken for a new one. tools/binary: tools/binary_step: Bring these tools up to date. compiler/Mmakefile: Add an int3s target for use by the new code in the tools. The Mmakefiles in the other directories with Mercury code already have such a target. compiler/notes/allocation.html: Fix an out-of-date reference. tests/debugger/polymorphic_ground_term.{m,inp,exp}: New test case to check whether liveness.m handles typeinfo liveness of ground terms correctly. tests/debugger/Mmakefile: Enable the new test case. tests/debugger/polymorphic_output.{m,exp}: Fix tab/space mixup.	2008-12-23 01:38:03 +00:00
Peter Wang	0e68aa6813	Don't look up exception analysis results from the intermodule analysis ... Branches: main compiler/exception_analysis.m: Don't look up exception analysis results from the intermodule analysis registry if exception analysis isn't enabled. This avoids recording requests for further exception analysis when it isn't actually enabled.	2008-08-21 07:31:57 +00:00
Zoltan Somogyi	a00596c283	The file modules.m contains lots of different kinds of functionality. ... Estimated hours taken: 16 Branches: main The file modules.m contains lots of different kinds of functionality. While much of it belongs together, much of it does not. This diff moves most of the functionality that does not belong with the rest to several new modules: libs.file_util parse_tree.deps_map parse_tree.file_names parse_tree.module_cmds parse_tree.module_imports parse_tree.read_module parse_tree.write_deps_file To make them coherent, move some predicates from hlds.passes_aux, parse_tree.prog_io and parse_tree.prog_out to the new modules, making them more accessible, reducing the required access from the hlds package to parse_tree, or from the parse_tree package to libs. In the same spirit, this diff also moves some simple predicates and functions dealing with sym_names from prog_util.m to mdbcomp/prim_data.m. This allows several modules to avoid depending on parse_tree.prog_util. Rename some of the moved predicates and function symbols where this avoids ambiguity. (There were several that differed from other predicates or function symbols only in arity.) Replace several uses of bools with purpose-specific types. This makes some of the code significantly easier to read. This diff moves modules.m from being by far the largest module, to being only the seventh largest, from 8900+ lines to just 4200+. It also reduces the number of modules that import parse_tree.modules considerably; most modules that imported it now import only one or two of the new modules instead. Despite the size of the diff, there should be no algorithmic changes. compiler/modules.m: compiler/passes_aux.m: compiler/prog_io.m: compiler/prog_out.m: Delete the moved functionality. compiler/file_util.m: New module in the libs package. Its predicates search for files and do simple error or progress reporting. compiler/file_names.m: New module in the parse_tree package. It contains predicates for converting module names to file names. compiler/module_cmds.m: New module in the parse_tree package. Its predicates handle the commands for manipulating interface files of various kinds. compiler/module_import.m: New module in the parse_tree package. It contains the module_imports type and its access predicates, and the predicates that compute various sorts of direct dependencies (those caused by imports) between modules. compiler/deps_map.m: New module in the parse_tree package. It contains the data structure for recording indirect dependencies between modules, and the predicates for creating it. compiler/read_module.m: New module in the parse_tree package. Its job is reading in modules, both human-written and machine-written (such as interface and optimization files). compiler/write_deps_file.m: New module in the parse_tree package. Its job is writing out makefile fragments. compiler/libs.m: compiler/parse_tree.m: Include the new modules. compiler/notes/compiler_design.m: Document the new modules. mdbcomp/prim_data.m: compiler/prog_util.m: Move the predicates that operate on nothing but sym_names from prog_util to prim_data. Move get_ancestors from modules to prim_data. compiler/prog_item.m: Move stuff that looks for foreign code in a list of items here from modules.m. compiler/source_file_map.m: Note why this module needs to be in the parse_tree package. compiler/add_pred.m: compiler/add_special_pred.m: compiler/analysis.file.m: compiler/analysis.m: compiler/assertion.m: compiler/check_typeclass.m: compiler/compile_target_code.m: compiler/cse_detection.m: compiler/det_analysis.m: compiler/elds_to_erlang.m: compiler/exception_analysis.m: compiler/export.m: compiler/fact_table.m: compiler/higher_order.m: compiler/hlds_module.m: compiler/hlds_pred.m: compiler/intermod.m: compiler/llds_out.m: compiler/make.dependencies.m: compiler/make.m: compiler/make.module_dep_file.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make.util.m: compiler/make_hlds_passes.m: compiler/maybe_mlds_to_gcc.pp: compiler/mercury_compile.m: compiler/mlds.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_ilasm.m: compiler/mlds_to_java.m: compiler/mmc_analysis.m: compiler/mode_constraints.m: compiler/mode_debug.m: compiler/modes.m: compiler/module_qual.m: compiler/optimize.m: compiler/passes_aux.m: compiler/proc_gen.m: compiler/prog_foreign.m: compiler/prog_io.m: compiler/prog_io_util.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/pseudo_type_info.m: compiler/purity.m: compiler/recompilation.check.m: compiler/recompilation.usage.m: compiler/simplify.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.direct.m: compiler/structure_sharing.analysis.m: compiler/tabling_analysis.m: compiler/term_constr_main.m: compiler/termination.m: compiler/trailing_analysis.m: compiler/trans_opt.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_info.m: compiler/unify_proc.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/xml_documentation.m: Minor changes to conform to the changes above.	2008-07-21 03:10:29 +00:00
Peter Wang	36b7bd4ea0	Store call and answer patterns as terms in `.analysis' (and related) files and ... Branches: main Store call and answer patterns as terms in `.analysis' (and related) files and not strings. It's easier to convert complex patterns to/from terms than strings. Also change the module names and function-ids while we're at it. compiler/analysis.m: Replace the `to_string' typeclass with a `to_term' typeclass. Make call and answer patterns convert to/from terms instead of strings. compiler/analysis.file.m: Read/write terms for call and answer patterns. Read/write module names and function-ids with more natural syntax than the term representations of internal data structures. Bump the analysis file version number. Move some code around. Use promise_equivalent_solutions goals instead of promise_equivalent_solution_io. compiler/exception_analysis.m: compiler/structure_reuse.analysis.m: compiler/structure_sharing.analysis.m: compiler/tabling_analysis.m: compiler/trailing_analysis.m: compiler/unused_args.m: Conform to `to_term' typeclass interface. tests/analysis/ctgc/reuse_runtest.sh: tests/analysis/excp/excp_runtest.sh: tests/analysis/sharing/sharing_runtest.sh: tests/analysis/unused_args/unused_args_runtest.sh: Update test scripts for changed file formats. compiler/mercury_compile.m: Print verbose messages and report stats when reading in files for intermodule analysis.	2008-06-06 02:18:07 +00:00
Peter Wang	6eab527191	More changes to the intermodule analysis framework. ... Branches: main More changes to the intermodule analysis framework. This patch mainly deals with incorrect treatment of :- external procedures, opt_imported procedures, and forcing the correct reanalyses when answers change or requests are satisfied. - Previously, the way to ensure that a module M is reanalysed if a request in module N is satisfied was, while analysing M: assume an answer for the procedure in N; record that as a result in N; and record that M has a dependency on that answer. When N is analysed, if the real answer is better than the assumed answer, M would be marked `suboptimal' and later reanalysed. That's complicated and wasn't always done correctly. Now we remember the module which makes a request. When the request is satisfied, we mark the requesting module as `suboptimal'. This also means the `.analysis' file of a module will only be modified when analysing that module and no others, which should be useful for parallel builds. - In most analyses we weren't recording results for exported `:- external' procedures as we don't have their clauses and don't analyse them. Other modules would happily make requests for `:- external' procedures, which would never be satisfied. - We shouldn't make intermodule requests for `opt_imported' procedures as we actually have their clauses. Even if the request is satisfied, we'd probably not look them up since we do have their clauses. - If a module M opt_imports a procedure P from module N (its clauses are available while analysing M) then M also needs to depend on any answers required by P. Otherwise a change to an answer required by P won't cause M to be reanalysed. - There doesn't seem to be any reason to keep track of the analysis status of individual results. If an answer changes requiring another module to be reanalysed, the *whole module* will be marked suboptimal or invalid. And if that results in changed answers, its dependant modules will be marked. This patch doesn't remove the status of individual results but makes them always `optimal'. compiler/analysis.m: Remember the name of the module being analysed in the analysis_info. Simplify some predicate interfaces with this information. Remember whether we're currently making an analysis file or just reading from them. Make the record_* predicates do nothing in the latter case, so the caller doesn't need to check. Also make the record predicates do the right thing if the callee module is non-local, e.g. don't make requests to non-local modules. Automatically add a request if depending on a result that doesn't exist. Add a procedure to return the existing call patterns for a procedure, regardless of whether the module has been marked `invalid'. Add some assertions to check the analysis framework is being used as intended. Minor cleanups. compiler/analysis.file.m: Record the module that made the request in `.request' files. Bump the analysis file version number. compiler/hlds_module.m: Pass extra arguments to `init_analysis_info'. compiler/hlds_pred.m: Add `pred_info_is_imported_not_external' which doesn't succeed on `:- external' procedures (defined in the current module), unlike `pred_info_is_imported'. compiler/exception_analysis.m: compiler/tabling_analysis.m: compiler/trailing_analysis.m: compiler/unused_args.m: Record results for `:- external' procedures. Don't look up results for our own `:- external' procedures from the analysis registry. In general, fix many spots where external procs would be treated as imported. Write out results for procedures which are exported to submodules. Conform to analysis framework changes. Remove some redundant checks which have been moved into the framework. compiler/mercury_compile.m: Conform to analysis framework changes. compiler/structure_reuse.analysis.m: Be careful not to read in requests and call patterns for `opt_imported' procedures as if they were defined in the current module. If depending on an answer that doesn't exist, also make a request for that answer. Conform to analysis framework changes. Write out messages when removing useless reuse version procedures. compiler/structure_reuse.indirect.m: Use `pred_info_is_imported_not_external' so as not to look up results for our own `:- external' procedures from the analysis registry. Treat `opt_imported' procedures as intra-module as far as requests are concerned. We need to satisfy requests for them in the current compiler invocation rather than when analysing imported modules. compiler/structure_sharing.analysis.m: Fix treatment of `:- external' procedures. Conform to analysis framework changes. compiler/structure_sharing.domain.m: Don't return suboptimal when unable to look up a result. compiler/mmc_analysis.m: Replace pred_or_func_name_arity_to_func_id by a higher-level predicate. tests/Mmakefile: tests/analysis/Mmakefile: tests/analysis/common.sh: tests/analysis/excp/Mercury.options: tests/analysis/excp/Mmakefile: tests/analysis/excp/excp_m1.m.exception: tests/analysis/excp/excp_m1.m.no_exception: tests/analysis/excp/excp_m2.m: tests/analysis/excp/excp_m3.m: tests/analysis/excp/excp_runtest.sh: tests/analysis/ext/Mercury.options: tests/analysis/ext/Mmakefile: tests/analysis/ext/ext.m: tests/analysis/ext/ext2.m: tests/analysis/ext/ext2_runtest.sh: tests/analysis/ext/ext_runtest.sh: tests/analysis/sharing/Mercury.options: tests/analysis/sharing/Mmakefile: tests/analysis/sharing/sharing_m1.m.no_share: tests/analysis/sharing/sharing_m1.m.share: tests/analysis/sharing/sharing_m2.m: tests/analysis/sharing/sharing_m3.m: tests/analysis/sharing/sharing_runtest.sh: tests/analysis/table/Mercury.options: tests/analysis/table/Mmakefile: tests/analysis/table/table_m1.m.no_tabling: tests/analysis/table/table_m1.m.tabling: tests/analysis/table/table_m2.m: tests/analysis/table/table_m3.m: tests/analysis/table/table_runtest.sh: tests/analysis/trail/Mercury.options: tests/analysis/trail/Mmakefile: tests/analysis/trail/trail_m1.m.no_trail: tests/analysis/trail/trail_m1.m.trail: tests/analysis/trail/trail_m2.m: tests/analysis/trail/trail_m3.m: tests/analysis/trail/trail_runtest.sh: tests/analysis/unused_args/Mercury.options: tests/analysis/unused_args/Mmakefile: tests/analysis/unused_args/ua_m1.m.no_unused_args: tests/analysis/unused_args/ua_m1.m.unused_args: tests/analysis/unused_args/ua_m2.m: tests/analysis/unused_args/ua_m3.m: tests/analysis/unused_args/unused_args_runtest.sh: Add test cases.	2008-06-05 06:25:20 +00:00
Peter Wang	2e3b81442c	Make the structure sharing analysis capable of using the intermodule analysis ... Branches: main Make the structure sharing analysis capable of using the intermodule analysis framework. This requires changes to the analysis framework. Structure sharing answer patterns need information from the module_info and proc_info in order to be compared. In Simon Taylor's original analysis framework implementation, this would have been provided for by a `FuncInfo' parameter in the `partial_order' typeclass. I removed it two years ago as it was causing difficulties which couldn't be solved cleanly while the analysis framework was not specific to the Mercury compiler. Also, there were no analyses at the time which needed FuncInfos. Now that we do require it, and the analysis framework has been made Mercury specific, we can restore the `FuncInfo' parameter. Also make some more simplifications to the analysis framework. compiler/analysis.m: compiler/analysis.file.m: Remove the `module_id' type and replace occurrences by `module_name'. Remove "extra info" facilities. They were intended for storing information needed by intermodule inlining and higher order specialisation but now that information is in `.opt' files, even when using `--intermodule-analysis'. Change `func_id' from a string to a structured type so we can extract its components easily. Add a message argument to the `invalid_analysis_file' functor so when we throw an exception due to being unable to parse a `.analysis' we get a meaningful message. Change the `.analysis' file format to account for the changes to `module_id' and `func_id'. Bump the file version number. Add a `FuncInfo' parameter to the `partial_order' typeclass, as explained above. Add a `no_func_info' dummy type. Add a `get_func_info' method to the `analysis' framework. When updating the analysis files after analysing a module, we need to be able to materialise FuncInfos for each procedure in order to compare its call or answer patterns. This is what couldn't be added cleanly while the analysis framework was not specific to the Mercury compiler. compiler/structure_sharing.analysis.m: Make the structure sharing analysis capable of using the analysis framework, i.e. use imported answers from the analysis registry, record new answers, dependencies and requests, and keeping track of the optimality of results during analysis. compiler/structure_sharing.domain.m: Add `sharing_as_and_status' to pair `sharing_as' with an `analysis_status'. Make `sharing_as_table' record the `analysis_status' alongside a sharing domain. Update access predicates. Move `sharing_as' into the interface section as it is needed by structure_sharing.m to convert between `sharing_as' and `structure_sharing_answer' values for the analysis framework. When we can't look up the sharing result for an `:- external' predicate, that should not be a sign that the analysis is non-optimal since we can't get a better result by reanalysis. Make special predicates be approximated by `bottom' sharing as we know they don't introduce sharing. Avoid an assertion failure in removing subsumed sharing pairs from a sharing set. compiler/ctgc.util.m: Make `pred_requires_no_analysis' not succeed on special predicates (unify, compare, index, init) which causes the analysis to assume all possible sharing between its arguments, whereas we know that those predicates don't introduce any sharing. Also make `pred_requires_no_analysis' not succeed on `:- external' predicates. compiler/ctgc.selector.m: Make type_on_path_2 fail instead of aborting if asked to select a subtype which turns out to be existentially typed. compiler/structure_reuse.direct.m: Don't run direct structure reuse on compiler generated special predicates. We need to handle them specifically now due to the change to `pred_requires_no_analysis'. compiler/structure_reuse.indirect.m: Don't run indirect structure reuse on compiler generated special predicates, as for the direct reuse pass. Conform to change to `top_feedback'. Change a semidet function to a predicate. compiler/hlds_pred.m: compiler/hlds_out.m: Change `structure_sharing_info' to associate an analysis status with the structure sharing domain of a procedure (if any). Add a type `structure_sharing_domain_and_status' for this. compiler/prog_data.m: Make `top_feedback' a structured type instead of a string. Divide the reasons that we might approximate structure sharing by `top' into different classes. compiler/exception_analysis.m: compiler/tabling_analysis.m: compiler/trailing_analysis.m: Conform to analysis framework changes. compiler/unused_args.m: Conform to analysis framework changes. Move the predicate arity from the call pattern into a FuncInfo, where it belongs. Bump the analysis version number. compiler/prog_ctgc.m: compiler/structure_reuse.direct.detect_garbage.m: Conform to change to `top_feedback'. compiler/make.dependencies.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make.util.m: Conform to removal of `module_id' type. compiler/mercury_compile.m: Call mm_tabling_analysis, structure sharing and structure reuse passes when making `.analysis' files. Conform to removal of `module_id' type. compiler/mmc_analysis.m: Add structure sharing to the list of analyses. Add `func_id_to_ppid'. Conform to analysis framework changes. compiler/ctgc.fixpoint_table.m: Replace a semidet function by a predicate.	2008-03-27 02:29:43 +00:00
Zoltan Somogyi	b000cb322e	Provide compiler support for Software Transactional Memory through the new ... Estimated hours taken: 80 by zs, and lots more by lmika Branches: main Provide compiler support for Software Transactional Memory through the new atomic goal. This work was done by Leon Mika; I merely brought it up to date, resolved conflicts, and cleaned up a few things. There are still several aspects that are as yet incomplete. library/ops.m: Add the operators needed for the syntax of atomic scopes. library/stm_builtin.m: Add the builtin operations needed for the implementation of atomic goals. compiler/hlds_goal.m: Add a new HLDS goal type, which represents an atomic goal and its possible fallbacks (in case an earlier goal throws an exception). Rename the predicate goal_is_atomic as goal_expr_has_subgoals, since now its old name would be misleading. compiler/prog_data.m: compiler/prog_item.m: Add a parse tree representation of the new kind of goal. compiler/prog_io_goal.m: Parse the new kind of goal. compiler/add_clause.m: Translate atomic goals from parse tree form to HLDS. compiler/typecheck.m: compiler/typecheck_errors.m: Do type checking of atomic goals. compiler/modes.m: Do mode checking of atomic goals, and determine whether they are nested or not. compiler/unique_modes.m: Do unique mode checking of atomic goals. compiler/stm_expand.m: New module to expand atomic goals into sequences of simpler goals. library/stm_builtin.m: Add the primitives needed by the transformation. Improve the existing debugging support. mdbcomp/prim_data.m: Add utility functions to allow stm_expand.m to refer to modules in the library. mdbcomp/program_representation.m: Expand the goal_path type to allow the representation of components of atomic goals. compiler/notes/compiler_design.html: Document the new module. compiler/transform_hlds.m: Include the new module in the compiler. compiler/mercury_compile.m: Invoke the STM transformation. compiler/hlds_module.m: Add an auxiliary counter used by the STM transformation. compiler/hlds_pred.m: Add a new predicate origin: the STM transformation. compiler/modules.m: Import the STM builtin module automatically if the module contains any atomic goals. 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/cse_detection.m: compiler/deep_profiling.m: compiler/code_util.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/exception_analysis.m: compiler/follow_code.m: compiler/format_call.m: compiler/goal_form.m: compiler/goal_path.m: compiler/goal_util.m: compiler/granularity.m: compiler/hlds_out.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/intermod.m: compiler/lambda.m: compiler/layout_out.m: compiler/lco.m: compiler/lookup_switch.m: compiler/make_hlds_warn.m: compiler/mark_static_terms.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_code_gen.m: compiler/mode_constraint_robdd.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_info.m: compiler/mode_util.m: compiler/ordering_mode_constraints.m: compiler/pd_cost.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_rep.m: compiler/prog_type.m: compiler/prop_mode_constraints.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_info.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prog.m: compiler/smm_common.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/switch_detection.m: compiler/unused_imports.m: compiler/granularity.m: compiler/granularity.m: Conform to the changes above. Mostly this means handling the new kind of goal. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/build_mode_constraints.m: compiler/closure_analysis.m: compiler/dead_proc_elim.m: compiler/deforest.m: compiler/follow_vars.m: compiler/higher_order.m: compiler/live_vars.m: compiler/liveness.m: compiler/loop_inv.m: compiler/module_qual.m: compiler/prog_util.m: compiler/purity.m: compiler/quantification.m: compiler/store_alloc.m: compiler/stratify.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/trailing_analysis.m: Conform to the changes above. Mostly this means handling the new kind of goal. Switch syntax from clauses to disj. runtime/mercury_stm.[ch]: Implement the primitives needed by the STM transformation. Add more debugging support to the existing primitives. library/term.m: Generalize get_term_context to work on terms of all kinds.	2008-02-27 07:23:57 +00:00
Peter Wang	8c4bcaf297	Make the intermodule analysis framework not require the I/O state for looking ... Estimated hours taken: 6 Branches: main Make the intermodule analysis framework not require the I/O state for looking up and recording analysis results. The I/O state was required because analysis files were loaded "on demand" but in most cases this was pointless. Now we just load all the analysis files of transitively imported modules before we run anything that uses the analysis framework. compiler/analysis.file.m: compiler/analysis.m: Make the main change above. Use `unexpected' instead of `error' for fatal errors. Replace `{Call, Answer, analysis_status}' tuples by a new type `analysis_result'. Rename the existing existentially-typed `analysis_result' to `some_analysis_result'. Remove the `module_is_local' method from the `compiler' typeclass. Replace it by a plain procedure that takes an `analysis_info' as input, instead of using the I/O state. Use trace goals for debugging output, where we no longer have the I/O state. Clean up some code. compiler/mercury_compile.m: Before running anything that uses the analysis framework, read in all the analysis files which might be needed. compiler/mmc_analysis.m: Delete `module_is_local' method. compiler/constraint.m: compiler/deforest.m: compiler/exception_analysis.m: compiler/goal_form.m: compiler/goal_util.m: compiler/pd_util.m: compiler/simplify.m: compiler/size_prof.m: compiler/tabling_analysis.m: compiler/trailing_analysis.m: compiler/unused_args.m: Conform to the changes above. Don't thread I/O state through procedures which no longer require it.	2008-02-21 04:22:42 +00:00
Peter Wang	3cc7312cbf	Support .opt' files with --intermodule-analysis'. ... Branches: main Support `.opt' files with `--intermodule-analysis'. Unlike with `--intermodule-optimisation', in this case `.opt' files only contain the initial information produced by `intermod.m' and not later analyses which should instead use the analysis framework. This makes intermodule inlining, etc. work with `--intermodule-analysis'. Also, the CTGC analyses will require the definitions of abstract types from imported modules. compiler/mercury_compile.m: Read and make `.opt' files with `--intermodule-analysis'. Don't run exception analysis, etc. when producing `.opt' files for `--intermodule-analysis'. Eliminate unnecessary clauses from `.opt' files to speed up compilation with `--intermodule-analysis', as we do for `--intermodule-optimisation'. compiler/make.dependencies.m: compiler/make.program_target.m: Account for `.opt' files being made with `--intermodule-analysis' in `mmc --make'. Make `.analysis' files depend on `.opt' files. compiler/globals.m: Add a predicate to return whether either intermodule optimisation system is enabled. compiler/post_typecheck.m: Avoid spurious warning about duplicate mode declarations when using `--intermodule-analysis' as they may be read from `.opt' files (same as for `--intermodule-optimisation'). compiler/exception_analysis.m: compiler/structure_sharing.analysis.m: compiler/tabling_analysis.m: compiler/trailing_analysis.m: compiler/unused_args.m: Don't write the analysis results into `.opt' files. compiler/term_constr_main.m: compiler/termination.m: Add todos for when these analyses are updated to support `--intermodule-analysis'. compiler/trans_opt.m: Fix a comment.	2008-02-18 23:57:45 +00:00
Zoltan Somogyi	097b45acec	Fix two problems that together caused bug Mantis bug #44. ... Estimated hours taken: 12 Branches: main Fix two problems that together caused bug Mantis bug #44. The first bug was that unify_gen.m wasn't checking whether a variable it was adding to a closure was of dummy type or not. The second bug was that the code for recognizing whether a type is dummy or not recognized only two cases: builtin dummy types such as io.state, and types with one function symbol of arity zero. In this program, there is a notag wrapper around a dummy type. Since the representation of a notag type is always the same as the type it wraps, this notag type should be recognized as a dummy type too. compiler/unify_gen.m: Fix the first bug by adding the required checks. compiler/code_info.m: Add a utility predicate to factor out some now common code in unify_gen.m. (The modifications to all the following files were to fix the second bug.) compiler/hlds_data.m: compiler/prog_type.m: Change the type_category type (in prog_type.m) and the enum_or_dummy type (in hlds_data.m) to separate out the representation of notag types from other du types. This allows the fix for the second bug, and incidentally allows some parts of the compiler to avoid the same tests over and over. To ensure that all places in the compiler that could need special handling for notag types get them, rename those types to type_ctor_category (since it does *not* take argument types into account) and du_type_kind respectively. Since the type_ctor_category type needs to be modified anyway, change it to allow code that manipulates values of the type to factor out common code fragments. Rename some predicates, and turn some into functions where this helps to make code (either here or in clients) more robust. compiler/make_tags.m: When creating a HLDS representation for a du type, record whether it is a notag type (we already recorded whether it is enum or dummy). compiler/type_util.m: Fix the predicate that tests for dummy types by recognizing the third way a type can be a dummy type. Don't test for dummyness of the argument when deciding whether a type could be a notag types; just record it as a notag type, and let later lookup code use the new fixed algorithm to do the right thing. Add a type for recording the is_dummy_type/is_not_dummy_type distinction. Rename some predicates, and turn some into functions where this helps to make code (either here or in clients) more robust. Add an XXX about possible redundant code. compiler/llds.m: Use the new type instead of booleans in some places. compiler/add_pragma.m: compiler/add_special_pred.m: compiler/add_type.m: compiler/bytecode_gen.m: compiler/continuation_info.m: compiler/ctgc.selector.m: compiler/ctgc.util.m: compiler/equiv_type_hlds.m: compiler/erl_call_gen.m: compiler/erl_code_gen.m: compiler/erl_code_util.m: compiler/erl_unify_gen.m: compiler/exception_analysis.m: compiler/export.m: compiler/foreign.m: compiler/higher_order.m: compiler/hlds_data.m: compiler/hlds_out.m: compiler/hlds_pred.m: compiler/inst_match.m: compiler/intermod.m: compiler/llds_out.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_simplify_switch.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mlds.m: compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_java.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/polymorphism.m: compiler/pragma_c_gen.m: compiler/prog_type.m: compiler/rtti_to_mlds.m: compiler/simplify.m: compiler/special_pred.m: compiler/stack_layout.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_util.m: compiler/term_norm.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/unify_proc.m: compiler/var_locn.m: Conform to the changes above. Make a few analyses more precise by using the new detail in the type_ctor_category type to make less conservative assumptions about du types that are either notag or dummy. In ctgc.selector.m, ctgc.util.m, make_tags.m, mlds_to_java.m and special_pred.m, add XXXs about possible bugs. tests/valid/fzn_debug_abort.m: Add the bug demo program from Mantis as a regression test. tests/valid/Mmakefile: tests/valid/Mercury.options: Enable the new test, and run it with the old bug-inducing option.	2008-02-11 21:27:48 +00:00
Zoltan Somogyi	cc88711d63	Implement true multi-cons_id arm switches, i.e. switches in which we associate ... Estimated hours taken: 40 Branches: main Implement true multi-cons_id arm switches, i.e. switches in which we associate more than one cons_id with a switch arm. Previously, for switches like this: ( X = a, goal1 ; ( X = b ; X = c ), goal2 ) we duplicated goal2. With this diff, goal2 won't be duplicated. We still duplicate goals when that is necessary, i.e. in cases which the inner disjunction contains code other than a functor test on the switched-on var, like this: ( X = a, goal1 ; ( X = b, goalb ; X = c goalc ), goal2 ) For now, true multi-cons_id arm switches are supported only by the LLDS backend. Supporting them on the MLDS backend is trickier, because some MLDS target languages (e.g. Java) don't support the concept at all. So when compiling to MLDS, we still duplicate the goal in switch detection (although we could delay the duplication to just before code generation, if we wanted.) compiler/options.m: Add an internal option that tells switch detection whether to look for multi-cons_id switch arms. compiler/handle_options.m: Set this option based on the back end. Add a version of the "trans" dump level that doesn't print unification details. compiler/hlds_goal.m: Extend the representation of switch cases to allow more than one cons_id for a switch arm. Add a type for representing switches that also includes tag information (for use by the backends). compiler/hlds_data.m: For du types, record whether it is possible to speed up tests for one cons_id (e.g. cons) by testing for the other (nil) and negating the result. Recording this information once is faster than having unify_gen.m trying to compute it from scratch for every single tag test. Add a type for representing a cons_id together with its tag. compiler/hlds_out.m: Print out the cheaper_tag_test information for types, and possibly several cons_ids for each switch arm. Add some utility predicates for describing switch arms in terms of which cons_ids they are for. Replace some booleans with purpose-specific types. Make hlds_out honor is documentation, and not print out detailed information about unifications (e.g. uniqueness and static allocation) unless the right character ('u') is present in the control string. compiler/add_type.m: Fill in the information about cheaper tag tests when adding a du type. compiler/switch_detection.m: Extend the switch detection algorithm to detect multi-cons_id switch arms. When entering a switch arm, update the instmap to reflect that the switched-on variable can now be bound only to the cons_ids that this switch arm is for. We now need to do this, because if the arm contains another switch on the same variable, computing the can_fail field of that switch correctly requires us to know this information. (Obviously, an arm for a single cons_id is unlikely to have switch on the same variable, and for arms for several cons_ids, we previously duplicated the arm and left the unification with the cons_id in each copy, and this unification allowed the correct handling of any later switches. However, the code of a multi-cons_id switch arm obviously cannot have a unification with each cons_id in it, which is why we now need to get the binding information from the switch itself.) Replace some booleans with purpose-specific types, and give some predicates better names. compiler/instmap.m: Provide predicates for recording that a switched-on variable has one of several given cons_ids, for use at the starts of switch arms. Give some predicates better names. compiler/modes.m: Provide predicates for updating the mode_info at the start of a multi-cons_id switch arm. compiler/det_report.m: Handle multi-cons_id switch arms. Update the instmap when entering each switch arm, since this is needed to provide good (i.e. non-misleading) error messages when one switch on a variable exists inside another switch on the same variable. Since updating the instmap requires updating the module_info (since the new inst may require a new entry in an inst table), thread the det_info through as updateable state. Replace some multi-clause predicate definitions with single clauses, to make it easier to print the arguments in mdb. Fix some misleading variable names. compiler/det_analysis.m: Update the instmap when entering each switch arm and thread the det_info through as updateable state, since the predicates we call in det_report.m require this. compiler/det_util.m: Handle multi-cons_id switch arms. Rationalize the argument order of some access predicates. compiler/switch_util.m: Change the parts of this module that deal with string and tag switches to optionally convert each arm to an arbitrary representation of the arm. In the LLDS backend, the conversion process generated code for the arm, and the arm's representation is the label at the start of this code. This way, we can duplicate the label without duplicating the code. Add a new part of this module that associates each cons_id with its tag, and (during the same pass) checks whether all the cons_ids are integers, and if so what are min and max of these integers (needed for dense switches). This scan is needed because the old way of making this test had single-cons_id switch arms as one of its basic assumptions, and doing it while adding tags to each case reduces the number of traversals required. Give better names to some predicates. compiler/switch_case.m: New module to handle the tasks associated with managing multi-cons_id switch arms, including representing them for switch_util.m. compiler/ll_backend.m: Include the new module. compiler/notes/compiler_design.html: Note the new module. compiler/llds.m: Change the computed goto instruction to take a list of maybe labels instead of a list of labels, with any missing labels meaning "not reached". compiler/string_switch.m: compiler/tag_switch.m: Reorganize the way these modules work. We can't generate the code of each arm in place anymore, since it is now possible for more than one cons_id to call for the execution of the same code. Instead, in string_switch.m, we generate the codes of all the arms all at once, and construct the hash index afterwards. (This approach simplifies the code significantly.) In tag switches (unlike string switches), we can get locality benefits if the code testing for a cons_id is close to the code for that cons_id, so we still try to put them next to each other when such a locality benefit is available. In both modules, the new approach uses a utility predicate in switch_case.m to actually generate the code of each switch arm, eliminating several copies the same code in the old versions of these modules. In tag_switch.m, don't create a local label that simply jumps to the code address do_not_reached. Previously, we had to do this for positions in jump tables that corresponded to cons_ids that the switch variable could not be bound to. With the change to llds.m, we now simply generate a "no" instead. compiler/lookup_switch.m: Get the info about int switch limits from our caller; don't compute it here. Give some variables better names. compiler/dense_switch.m: Generate the codes of the cases all at once, then assemble the table, duplicate the labels as needed. This separation of concerns allows significant simplifications. Pack up all the information shared between the predicate that detects whether a dense switch is appropriate and the predicate that actually generates the dense switch. Move some utility predicates to switch_util. compiler/switch_gen.m: Delete the code for tagging cons_ids, since that functionality is now in switch_util.m. The old version of this module could call the code generator to produce (i.e. materialize) the switched-on variable repeatedly. We now produce the variable once, and do the switch on the resulting rval. compiler/unify_gen.m: Use the information about cheaper tag tests in the type constructor's entry in the HLDS type table, instead of trying to recompute it every time. Provide the predicates switch_gen.m now needs to perform tag tests on rvals, as opposed to variables, and against possible more than one cons_id. Allow the caller to provide the tag corresponding to the cons_id(s) in tag tests, since when we are generating code for switches, the required computations have already been done. Factor out some code to make all this possible. Give better names to some predicates. compiler/code_info.m: Provide some utility predicates for the new code in other modules. Give better names to some existing predicates. compiler/hlds_code_util.m: Rationalize the argument order of some predicates. Replace some multi-clause predicate definitions with single clauses, to make it easier to print the arguments in mdb. compiler/accumulator.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/build_mode_constraints.m: compiler/check_typeclass.m: compiler/closure_analysis.m: compiler/code_util.m: compiler/constraint.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/deforest.m: compiler/delay_construct.m: compiler/delay_partial_inst.m: compiler/dep_par_conj.m: compiler/distance_granularity.m: compiler/dupproc.m: compiler/equiv_type_hlds.m: compiler/erl_code_gen.m: compiler/exception_analysis.m: compiler/export.m: compiler/follow_code.m: compiler/follow_vars.m: compiler/foreign.m: compiler/format_call.m: compiler/frameopt.m: compiler/goal_form.m: compiler/goal_path.m: compiler/goal_util.m: compiler/granularity.m: compiler/hhf.m: compiler/higher_order.m: compiler/implicit_parallelism.m: compiler/inlining.m: compiler/inst_check.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lambda.m: compiler/lambda.m: compiler/lco.m: compiler/live_vars.m: compiler/livemap.m: compiler/liveness.m: compiler/llds_out.m: compiler/llds_to_x86_64.m: compiler/loop_inv.m: compiler/make_hlds_warn.m: compiler/mark_static_terms.m: compiler/middle_rec.m: compiler/ml_tag_switch.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_util.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pd_cost.m: compiler/pd_into.m: compiler/pd_util.m: compiler/peephole.m: compiler/polymorphism.m: compiler/post_term_analysis.m: compiler/post_typecheck.m: compiler/purity.m: compiler/quantification.m: compiler/rbmm.actual_region_arguments.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.condition_renaming.m: compiler/rbmm.execution_paths.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/saved_vars.m: compiler/simplify.m: compiler/size_prof.m: compiler/ssdebug.m: compiler/store_alloc.m: compiler/stratify.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/structure_reuse.lbu.m: compiler/structure_reuse.lfu.m: compiler/structure_reuse.versions.m: compiler/structure_sharing.analysis.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/term_pass1.m: compiler/term_traversal.m: compiler/trailing_analysis.m: compiler/transform_llds.m: compiler/tupling.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/unify_proc.m: compiler/unique_modes.m: compiler/unneeded_code.m: compiler/untupling.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/xml_documentation.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. compiler/ml_string_switch.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. Give some predicates better names. compiler/dependency_graph.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. Change the order of arguments of some predicates to make this easier. compiler/bytecode.m: compiler/bytecode_data.m: compiler/bytecode_gen.m: Make the changes necessary to conform to the changes above, principally to handle multi-cons_id arm switches. (The bytecode interpreter has not been updated.) compiler/prog_rep.m: mdbcomp/program_representation.m: Change the byte sequence representation of goals to allow switch arms with more than one cons_id. compiler/prog_rep.m now writes out the updated representation, while mdbcomp/program_representation.m reads in the updated representation. deep_profiler/mdbprof_procrep.m: Conform to the updated program representation. tools/binary: Fix a bug: if the -D option was given, the stage 2 directory wasn't being initialized. Abort if users try to give that option more than once. compiler/Mercury.options: Work around bug #32 in Mantis.	2007-12-30 08:24:23 +00:00
Zoltan Somogyi	672f77c4ec	Add a new compiler option. --inform-ite-instead-of-switch. ... Estimated hours taken: 20 Branches: main Add a new compiler option. --inform-ite-instead-of-switch. If this is enabled, the compiler will generate informational messages about if-then-elses that it thinks should be converted to switches for the sake of program reliability. Act on the output generated by this option. compiler/simplify.m: Implement the new option. Fix an old bug that could cause us to generate warnings about code that was OK in one duplicated copy but not in another (where a switch arm's code is duplicated due to the case being selected for more than one cons_id). compiler/options.m: Add the new option. Add a way to test for the bug fix in simplify. doc/user_guide.texi: Document the new option. NEWS: Mention the new option. library/*.m: mdbcomp/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: Convert if-then-elses to switches at most of the sites suggested by the new option. At the remaining sites, switching to switches would have nontrivial downsides. This typically happens with the switched-on type has many functors, and we treat one or two specially (e.g. cons/2 in the cons_id type). Perform misc cleanups in the vicinity of the if-then-else to switch conversions. In a few cases, improve the error messages generated. compiler/accumulator.m: compiler/hlds_goal.m: (Rename and) move insts for particular kinds of goal from accumulator.m to hlds_goal.m, to allow them to be used in other modules. Using these insts allowed us to eliminate some if-then-elses entirely. compiler/exprn_aux.m: Instead of fixing some if-then-elses, delete the predicates containing them, since they aren't used, and (as pointed out by the new option) would need considerable other fixing if they were ever needed again. compiler/lp_rational.m: Add prefixes to the names of the function symbols on some types, since without those prefixes, it was hard to figure out what type the switch corresponding to an old if-then-else was switching on. tests/invalid/reserve_tag.err_exp: Expect a new, improved error message.	2007-11-23 07:36:01 +00:00
Julien Fischer	1fac629e6d	Add support for foreign enumerations to Mercury. ... Estimated hours taken: 50 Branches: main Add support for foreign enumerations to Mercury. These allow the programmer to assign foreign language values as the representation of enumeration constructors. e.g. :- type status ---> optimal ; infeasible ; unbounded ; unknown. :- pragma foreign_enum("C", status/0, [ optimal - "STATUS_OPTIMAL", infeasible - "STATUS_INFEASIBLE", unbounded - "STATUS_UNBOUNDED", unknown - "STATUS_UNKNOWN" ]). The advantage of this is that when values of type status/0 are passed to foreign code (C in this case) no translation is necessary. This should simplify the task of writing bindings to foreign language libraries. Unification and comparison for foreign enumerations are the usual unification and comparison for enumeration types, except that the default ordering on them is determined by the foreign representation of the constructors. User-defined equality and comparison also work for foreign enumeration types. In order to implement foreign enumerations we have to introduce two new type_ctor representations. The existing ones for enum type do not work since they use the value of an enumeration constructor to perform table lookups in the RTTI data structures. For foreign enumerations we need to perform a linear search at the corresponding points. This means that some RTTI operations related to deconstruction are more expensive. The dummy type optimisation is not applied to foreign enumerations as the code generators currently initialise the arguments of non-builtin dummy type foreign_proc arguments to zero. For unit foreign enumerations they should be initialised to the correct foreign value. (This is could be implemented but in practice it's probably not going to be worth it.) Currently, foreign enumerations are only supported by the C backends. compiler/prog_io_pragma.m: Parse foreign_enum pragmas. Generalise the code used to parse association lists of sym_names and strings since this is now used by the code to parse foreign_enum pragmas as well as that for foreign_export_enum pragmas. Fix a typo: s/foreign_expor_enum/foreign_export_enum/ compiler/prog_item.m: Represent foreign_enum pragmas in the parse tree. compiler/prog_type.m: Add a new type category for foreign enumerations. compiler/modules.m: Add any foreign_enum pragmas for enumeration types defined in the interface of a module to the interface files. Output foreign_import_module pragmas in the interface file if any foreign_enum pragmas are included in it. This ensures that the contents that any foreign declarations that are needed by the foreign_enum pragmas are visible. compiler/make_hlds_passes.m: compiler/add_pragma.m: Add pragma foreign_enum items to the HLDS after all the types have been added. As they are added, error check them. Change the constructor tag values of foreign enum types to their foreign values. compiler/module_qual.m: Module qualify pragma foreign_enum items. compiler/mercury_to_mercury.m: Output foreign_enum pragmas. Generalise some of the existing code for writing out association lists in foreign_export_enum pragmas for use with foreign_enum pragmas as well. compiler/hlds_data.m: Add the alternative `is_foreign_type' to the type enum_or_dummy/0. Add new type of cons_tag, foreign_tag, whose values are directly embedded in the target language. compiler/intermod.m: Write out any foreign_enum pragmas for opt_exported types. (The XXX concerning attaching language information to foreign tags will be addressed in a subsequent change.) compiler/llds.m: compiler/mlds.m: Support new kinds of rval constants: llconst_foreign and mlconst_foreign respectively. Both of these represent tag values as strings that are intended to be directly embedded in the target language. compiler/llds_out.m: Add code to write out the new kind of rval_const. s/Integer/MR_Integer/ in a spot. s/Float/MR_Float/ in a spot. compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/type_ctor_info.m: Add support the RTTI required by foreign enums. compiler/switch_util.m: Handle switches on foreign_enums as-per normal enumerations. compiler/table_gen.m: Tabling of foreign_enums is also like normal enumerations. compiler/type_util.m: Add a predicate that tests whether a type is a foreign enumeration. compiler/unify_gen.m: compiler/unify_proc.m: compiler/ml_unify_gen.m: Handle unification and comparison of foreign enumeration values. They are treated like normal enumerations for the purposes of implementing these operations. compiler/ml_type_gen.m: Handle foreign enumerations when generating the MLDS representation of enumerations. compiler/ml_util.m: Add a function to create an initializer for an object with a foreign tag. compiler/mlds_to_c.m: Handle mlconst_foreign/1 rval constants. compiler/bytecode_gen.m: compiler/dupproc.m: compiler/erl_rtti.m: compiler/exception_analysis.m: compiler/export.m: compiler/exprn_aux.m: compiler/global_data.m: compiler/hlds_out.m: compiler/higher_order.m: compiler/inst_match.m: compiler/jumpopt.m: compiler/llds_to_x86_64.m: compiler/ml_code_util.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_java.m: compiler/mlds_to_managed.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/polymorphism.m: compiler/recompilation.version.m: compiler/term_norm.m: compiler/trailing_analysis.m: Conform to the above changes. doc/reference_manual.texi: Document the new pragma. Fix some typos: s/pramga/pragma/, s/behavior/behaviour/ library/construct.m: Handle the two new type_ctor reps. Break an over-long line. library/rtti_implementation.m: Support the two new type_ctor reps. (XXX The Java versions of some of this cannot be implemented until support for foreign enumerations is added to mlds_to_java.m.) Reformat the inst usereq/0 and extend it to include foreign enums. runtime/mercury_type_info.h: Add two new type_ctor reps. One for foreign enumerations and another for foreign enumerations with user equality. Define new types (and extend existing ones) in order to support RTTI for foreign enumerations. runtime/mercury_unify_compare_body.h: Implement generic unify and compare for foreign enumerations. (It is the same as that for regular enumerations.) runtime/mercury_construct.[ch]: runtime/mercury_deconstruct.h: Handle (de)construction of foreign enumeration values. runtime/mercury_deep_copy_body.h: Implement deep copy for foreign enumerations. runtime/mercury_table_type_body.h: runtime/mercury_term_size.c: Handle the new type_ctor representations. java/runtime/ForeignEnumFunctorDesc.java: Add a Java version of the MR_ForeignEnumFuntorDesc structure. (Note: this is untested, as the java grade runtime doesn't work anyway.) java/runtime/TypeFunctors.java: Add a constructor method for foreign enumerations. (Likewise, untested.) NEWS: Announce pragma foreign_enum. vim/syntax/mercury.vim: Highlight the new pragma appropriately. tests/hard_coded/.cvsignore: Ignore executables generated by the new tests. Ignore a bunch of other files create by the Mercury compiler. tests/hard_coded/Mmakefile: tests/hard_coded/foreign_enum_rtti.{m,exp}: Test RTTI for foreign enumerations. tests/hard_coded/foreign_enum_dummy.{m,exp}: Check that dummy type optimisation is disabled for foreign enumerations. tests/hard_coded/Mercury.options: tests/hard_coded/foreign_enum_mod1.{m,exp}: tests/hard_coded/foreign_enum_mod2.m: Test that foreign_enum pragmas are hoisted into interface files and that they are handled correctly in optimization interfaces. tests/invalid/Mercury.options: tests/invalid/Mmakefile: tests/invalid/foreign_enum_import.{m,err_exp}: tests/invalid/foreign_enum_invalid.{m,err_exp}: Test that errors in foreign_enum pragmas are reported. tests/tabling/Mmakefile: tests/hard_coded/table_foreign_enum.{m,exp}: Test case for tabling of foreign enumerations.	2007-08-20 03:39:31 +00:00
Zoltan Somogyi	168f531867	Add new fields to the goal_info structure for region based memory management. ... Estimated hours taken: 4 Branches: main Add new fields to the goal_info structure for region based memory management. The fields are currently unused, but (a) Quan will add the code to fill them in, and then (b) I will modify the code generator to use the filled in fields. compiler/hlds_goal.m: Make the change described above. Group all the procedures that access goal_info components together. Some of the getters were predicates while some were functions, so this diff changes them all to be functions. (The setters remain predicates.) compiler/*.m: Trivial changes to conform to the change in hlds_goal.m. In simplify.m, break up a huge (800+ line) predicate into smaller pieces.	2007-08-07 07:10:09 +00:00
Julien Fischer	9958d3883c	Fix some formatting. ... Estimated hours taken: 0 Branches: main Fix some formatting. compiler/distance_granularity.m: compiler/exception_analysis.m: compiler/implicit_parallelism.m: compiler/inst_graph.m: compiler/interval.m: compiler/layout_out.m: compiler/lp_rational.m: compiler/make.program_target.m: compiler/modules.m: compiler/prog_data.m: compiler/purity.m: compiler/recompilation.check.m: compiler/term_constr_data.m: compiler/term_util.m: compiler/xml_documentation.m: deep_profiler/mdprof_cgi.m: library/pqueue.m: profiler/output.m: Fix the positioning of commas. s/[_|_]/[_ | _]/ in a spot.	2007-05-23 10:09:24 +00:00
Zoltan Somogyi	b56885be93	Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. ... Estimated hours taken: 12 Branches: main Fix a bug that caused bootchecks with --optimize-constructor-last-call to fail. The problem was not in lco.m, but in follow_code.m. In some cases, (specifically, the LCMC version of insert_2 in sparse_bitset.m), follow_code.m moved an impure goal (store_at_ref) into the arms of an if-then-else without marking those arms, or the if-then-else, as impure. The next pass, simplify, then deleted the entire if-then-else, since it had no outputs. (The store_at_ref that originally appeared after the if-then-else was the only consumer of its only output.) The fix is to get follow_code.m to make branched control structures such as if-then-elses, as well as their arms, semipure or impure if a goal being moved into them is semipure or impure, or if they came from an semipure or impure conjunction. Improve the optimization of the LCMC version of sparse_bitset.insert_2, which had a foreign_proc invocation of bits_per_int in it: replace such invocations with a unification of the bits_per_int constant if not cross compiling. Add a new option, --optimize-constructor-last-call-null. When set, LCMC will assign NULLs to the fields not yet filled in, to avoid any junk happens to be there from being followed by the garbage collector's mark phase. This diff also makes several other changes that helped me to track down the bug above. compiler/follow_code.m: Make the fix described above. Delete all the provisions for --prev-code; it won't be implemented. Don't export a predicate that is not now used anywhere else. compiler/simplify.m: Make the optimization described above. compiler/lco.m: Make sure that the LCMC specialized procedure is a predicate, not a function: having a function with the mode LCMC_insert_2(in, in) = in looks wrong. To avoid name collisions when a function and a predicate with the same name and arity have LCMC applied to them, include the predicate vs function status of the original procedure included in the name of the new procedure. Update the sym_name of calls to LCMC variants, not just the pred_id, because without that, the HLDS dump looks misleading. compiler/pred_table.m: Don't have optimizations like LCMC insert new predicates at the front of the list of predicates. Maintain the list of predicates in the module as a two part list, to allow efficient addition of new pred_ids at the (logical) end without using O(N^2) algorithms. Having predicates in chronological order makes it easier to look at HLDS dumps and .c files. compiler/hlds_module.m: Make module_info_predids return a module_info that is physically updated though logically unchanged. compiler/options.m: Add --optimize-constructor-last-call-null. Make the options --dump-hlds-pred-id, --debug-opt-pred-id and --debug-opt-pred-name into accumulating options, to allow the user to specify more than one predicate to be dumped (e.g. insert_2 and its LCMC variant). Delete --prev-code. doc/user_guide.texi: Document the changes in options.m. compiler/code_info.m: Record the value of --optimize-constructor-last-call-null in the code_info, to avoid lookup at every cell construction. compiler/unify_gen.m: compiler/var_locn.m: When deciding whether a cell can be static or not, make sure that we never make static a cell that has some fields initialized with dummy zeros, to be filled in for real later. compiler/hlds_out.m: For goals that are semipure or impure, note this fact. This info was lost when I changed the representation of impurity from markers to a field. mdbcomp/prim_data.m: Rename some ambiguous function symbols. compiler/intermod.m: compiler/trans_opt.m: Rename the main predicates (and some function symbols) of these modules to avoid ambiguity and to make them more expressive. compiler/llds.m: Don't print line numbers for foreign_code fragments if the user has specified --no-line-numbers. compiler/make.dependencies.m: compiler/mercury_to_mercury.m: compiler/recompilation.usage.m: Don't use io.write to write out information to files we may need to parse again, because this is vulnerable to changes to the names of function symbols (e.g. the one to mdbcomp/prim_data.m). The compiler still contains some uses of io.write, but they are for debugging. I added an item to the todo list of the one exception, ilasm.m. compiler/recompilation.m: Rename a misleading function symbol name. compiler/parse_tree.m: Don't import recompilation.m here. It is not needed (all the components of parse_tree that need recompilation.m already import it themselves), and deleting the import avoids recompiling almost everything when recompilation.m changes. compiler/*.m: Conform to the changes above. compiler/*.m: browser/*.m: slice/*.m: Conform to the change to mdbcomp. library/sparse_bitset.m: Use some better variable names.	2007-01-19 07:05:06 +00:00
Zoltan Somogyi	ba93a52fe7	This diff changes a few types from being defined as equivalent to a pair ... Estimated hours taken: 10 Branches: main This diff changes a few types from being defined as equivalent to a pair to being discriminated union types with their own function symbol. This was motivated by an error message (one of many, but the one that broke the camel's back) about "-" being used in an ambiguous manner. It will reduce the number of such messages in the future, and will make compiler data structures easier to inspect in the debugger. The most important type changed by far is hlds_goal, whose function symbol is now "hlds_goal". Second and third in importance are llds.instruction (function symbol "llds_instr") and prog_item.m's item_and_context (function symbol "item_and_context"). There are some others as well. In several places, I rearranged predicates to factor the deconstruction of goals into hlds_goal_expr and hlds_goal_into out of each clause into a single point. In many places, I changed variable names that used "Goal" to refer to just hlds_goal_exprs to use "GoalExpr" instead. I also changed variable names that used "Item" to refer to item_and_contexts to use "ItemAndContext" instead. This should make reading such code less confusing. I renamed some function symbols and predicates to avoid ambiguities. I only made one algorithmic change (at least intentionally). In assertion.m, comparing two goals for equality now ignores goal_infos for all kinds of goals, whereas previously it ignored them for most kinds of goals, but for shorthand goals it was insisting on them being equal. This seemed to me to be a bug. Pete, can you confirm this?	2007-01-06 09:23:59 +00:00
Zoltan Somogyi	3295b8e8b5	Fix style. ... Estimated hours taken: 0.1 Branches: main compiler/exception_analysis.m: compiler/mlds_to_c.m: Fix style.	2006-12-19 04:06:55 +00:00
Julien Fischer	b4c3bb1387	Clean up in unused module imports in the Mercury system detected ... Estimated hours taken: 3 Branches: main Clean up in unused module imports in the Mercury system detected by --warn-unused-imports. analysis/*.m: browser/*.m: deep_profiler/*.m: compiler/*.m: library/*.m: mdbcomp/*.m: profiler/*.m: slice/*.m: Remove unused module imports. Fix some minor departures from our coding standards. analysis/Mercury.options: browser/Mercury.options: deep_profiler/Mercury.options: compiler/Mercury.options: library/Mercury.options: mdbcomp/Mercury.options: profiler/Mercury.options: slice/Mercury.options: Set --no-warn-unused-imports for those modules that are used as packages or otherwise break --warn-unused-imports, e.g. because they contain predicates with both foreign and Mercury clauses and some of the imports only depend on the latter.	2006-12-01 15:04:40 +00:00
Zoltan Somogyi	91501d2453	This diff is the first step in implementing trace events. ... Estimated hours taken: 12 Branches: main This diff is the first step in implementing trace events. It introduces the representation of trace event goals into both the parse tree and HLDS representations, and updates most compiler passes to handle them. Changes to the code generator and to the runtime system, user-level documentation and test cases will come later. library/ops.m: Add "event" as an operator. mdbcomp/program_representation.m: Extend the representation of goals to include events. browser/declarative_execution.m: Allow the reconstruction from bytecode of event goals. browser/declarative_tree.m: Extend the algorithm for following terms to their sources to allow it to traverse events (which never generate any values). compiler/prog_item.m: compiler/hlds_goal.m: Extend the parse tree and the HLDS representations to include event goals. compiler/prog_io_goal.m: Convert the term representation of events to the parse tree representation. compiler/add_clause.m: Convert the parse tree representation of events to the HLDS representation. compiler/prog_event.m: Add this new module to contain the compiler's database of event types. compiler/notes/compiler_design.html: Mention the new module. compiler/parse_tree.m: Include the new module. compiler/prog_rep.m: Generate the extended bytecode for event goals. compiler/mercury_to_mercury.m: Output event goals. compiler/typecheck.m: Typecheck event goals. The types of the arguments of each event type is given by the database in prog_event.m. compiler/typecheck_errors.m: Add a predicate for reporting unknown events. compiler/modecheck_call.m: Add a predicate to modecheck event goals. The modes of the arguments are also given by the database in prog_event.m. compiler/modes.m: Call the new predicate in modecheck_call.m for event goals. Some predicates in this module took a boolean flag, tested many times at runtime, to control whether an exact match was required or not. However, the choice was fixed at all call sites except one. I have split each predicate into two, one for each value of the boolean flag, both for clarity of code and for slightly improved speed. compiler/ml_call_gen.m: Ignore event goals, since the MLDS backend doesn't support debugging. compiler/call_gen.m: Document the fact that event goals *should* be handled here. compiler/build_mode_constraints.m: compiler/deep_profiling.m: compiler/exception_analysis.m: compiler/goal_util.m: compiler/hlds_out.m: compiler/hlds_pred.m: compiler/intermod.m: compiler/mercury_to_mercury.m: compiler/mlds_to_c.m: compiler/mode_constraints.m: compiler/modecheck_unify.m: compiler/module_qual.m: compiler/prog_util.m: compiler/purity.m: compiler/simplify.m: compiler/superhomogeneous.m: compiler/tabling_analysis.m: compiler/term_traversal.m: compiler/trailing_analysis.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unique_modes.m: Handle the new goal type. In most cases the new code should be functional, but in a few cases (e.g. constraint based mode analysis and deep profiling) it just aborts the compiler.	2006-09-05 06:21:37 +00:00
Zoltan Somogyi	00741b0162	This diff contains no algorithmic changes. ... Estimated hours taken: 6 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch more function symbols to reduce ambiguity. After this diff, the summary line from the mdb command "ambiguity -f" is Total: 351 names used 975 times, maximum 31, average: 2.78 browser/*.m: compiler/*.m: Rename function symbols to eliminate ambiguities. tests/debugger/declarative/dependency.exp: tests/debugger/declarative/dependency2.exp: Update the expected out where some internal function symbol names appear in the output of the debugger. (This output is meant for implementors only.)	2006-08-22 05:04:29 +00:00
Zoltan Somogyi	2b2f3d3cbe	This diff contains no algorithmic changes. ... Estimated hours taken: 8 Branches: main This diff contains no algorithmic changes. It merely renames apart a bunch of function symbols to reduce ambiguity. Basically I went through prog_data.m, prog_item.m, hlds_data.m, hlds_goal.m and hlds_pred.m looking for type definitions containing function symbol names that were either language "keywords" (e.g. "terminates", which is an annotation on foreign_procs), used with slightly different meanings in several types (e.g. "sym"), or both (e.g. "call"). When I found such type definitions, I changed the names of the function symbols, usually by adding a prefix or suffix indicating the type to all function symbols of the type. For example, the old function symbol "foreign_proc" in type "pragma_type" is now named "pragma_foreign_proc", and the names of all other function symbols in that type also start with "pragma_". All of this should yield simpler compiler error messages when we make mistakes, and will make it more likely that looking up a function symbol using a tags file will take you to the actual definition of the relevant instance of that function symbol. However, the most important benefit is the increase in the readability of unfamiliar code; the reader won't have to emulate the compiler's type ambiguity resolution algorithm (which in many cases used to require distinguishing between f/14 and f/15 by counting the arguments, e.g. for "pred_or_func"). compiler/prog_data.m: compiler/prog_item.m: compiler/hlds_data.m: compiler/hlds_goal.m: compiler/hlds_pred.m: Rename function symbols as explained above. compiler/*.m: Conform to the function symbol renames. In some cases, rename other function symbols as well. Minor style fixes, e.g. replace if-then-elses with switches, or simple det predicates with functions.	2006-08-20 08:21:36 +00:00
Julien Fischer	aeeedd2c13	Standardize formatting of comments at the beginning of modules. ... compiler/*.m: Standardize formatting of comments at the beginning of modules.	2006-07-31 08:32:11 +00:00
Zoltan Somogyi	9d23d8e2e7	Implement the trace goal construct we discussed, for now for the LLDS backends ... Estimated hours taken: 70 Branches: main Implement the trace goal construct we discussed, for now for the LLDS backends only. Since the syntax of trace goals is non-trivial, useful feedback on syntax errors inside trace goal attributes is essential. With the previous setup, this wasn't possible, since the code that turned terms into parse tree goals turned *all* terms into goals; it couldn't recognize any errors, sweeping them under the rug as calls. This diff changes that. Now, if this code recognizes a keyword that indicates a particular construct, it insists on the rest of the code following the syntax required for that construct, and returns error messages if it doesn't. We handle the trace goal attributes that specify state variables to be threaded through the trace goal (either the I/O state or a mutable variable) in add_clause.m, at the point at which we transform the list of items to the HLDS. We handle the compile-time condition on trace goals in the invocation of simplify at the end of semantics analysis, by eliminating the goal if the compile-time condition isn't met. We handle run-time conditions on trace goals partially in the same invocation of simplify: we transform trace goals with runtime conditions into an if-then-else with the trace goal as the then part and `true' as the else part, the condition being a foreign_proc that is handled specially by the code generator, that special handling being to replace the actual code of the foreign_proc (which is a dummy) with the evaluation of the runtime condition. Since these changes require significant changes to some of our key data structures, I took the liberty of doing some renaming of function symbols at the same time to avoid using ambiguities with respect to language keywords. library/ops.m: Add "trace" as an operator. compiler/prog_data.m: Define data types to represent the various attributes of trace goals. Rename some function symbols to avoid ambiguities. compiler/prog_item.m: Extend the parse tree representation of goals with a trace goal. compiler/mercury_to_mercury.m: Output the new kind of goal and its components. compiler/hlds_goal.m: Extend the HLDS representation of scopes with a scope_reason representing trace goals. Add a mechanism (an extra argument in foreign_procs) to allow the representation of goals that evaluate runtime trace conditions. Since this requires modifying all code that traverses the HLDS, do some renames that were long overdue: rename not as negation, rename call as plain_call, and rename foreign_proc as call_foreign_proc. These renames all avoid using language keywords as function symbols. Change the way we record goals' purities. Instead of optional features to indicate impure or semipure, which is error-prone, use a plain field in the goal_info, accessed in the usual way. Add a way to represent that a goal contains a trace goal, and should therefore be treated as if it were impure when considering whether to optimize it away. Reformat some comments describing function symbols. compiler/hlds_out.m: Output the new construct in the HLDS. compiler/prog_io_util.m: Generalize the maybe[123] types to allow the representation of more than one error message. Add functions to extract the error messages. Add a maybe4 type. Rename the function symbols of these types to avoid massive ambiguity. Change the order of some predicates to bring related predicates next to each other. compiler/prog_io.m: compiler/prog_io_dcg.m: compiler/prog_io_goal.m: compiler/prog_io_pragma.m: Rework these modules almost completely to find and accumulate syntax errors as terms are being parsed. In some cases, this allowed us to replace "XXX this is a hack" markers with meaningful error-reporting code. In prog_io_goal.m, add code for parsing trace goals. In a bunch of places, update obsolete coding practices, such as using nested chains of closures instead of simple sequential code, and using A0 and A to refer to values of different types (terms and goals respectively). Use more meaningful variable names. Break up some too-large predicates. compiler/superhomogeneous.m: Find and accumulate syntax errors as terms are being parsed. compiler/add_clause.m: Add code to transform trace goals from the parse tree to the HLDS. This is where the IO state and mutable variable attributes of trace goals are handled. Eliminate the practice of using the naming scheme Body0 and Body to refer to values of different types (prog_item.goal and hlds_goal respectively). Use error_util for some error messages. library/private_builtin.m: Add the predicates referred to by the transformation in add_clause.m. compiler/goal_util.m: Rename a predicate to avoid ambiguity. compiler/typecheck.m: Do not print error messages about missing clauses if some errors have been detected previously. compiler/purity.m: Instead of just computing purity, compute (and record) also whether a goal contains a trace goal. However, treat trace goals as pure. compiler/mode_info.m: Add trace goals as a reason for locking variables. Rename some function symbols to avoid ambiguity. compiler/modes.m: When analyzing trace goal scopes, lock the scope's nonlocal variables to prevent them from being further instantiated. compiler/det_analysis.m: Insist on the code in trace goal scopes being det or cc_multi. compiler/det_report.m: Generate the error message if the code in a trace goal scope isn't det or cc_multi. compiler/simplify.m: At the end of the front end, eliminate trace goal scopes if their compile-time condition is false. Transform trace goals with runtime conditions as described at the top. Treat goals that contain trace goals as if they were impure when considering whether to optimize them away. compiler/mercury_compile.m: Tell simplify when it is being invoked at the end of the front end. Rename a predicate to avoid ambiguity. compiler/trace_params.m: Provide the predicates simplify.m need to be able to evaluate the trace goal conditions regarding trace levels. compiler/trace.m: compiler/trace_gen.m: Rename the trace module as trace_gen, since "trace" is now an operator. Rename some predicates exported by the module, now that it is no longer possible to preface calls with "trace." as a module qualifier. compiler/notes/compiler_design.html: Document this name change. compiler/options.m: Rename the trace option as trace_level internally, since "trace" is now an operator. The user-visible name remains the same. Add the new --trace-flag option. Delete an obsolete option. compiler/handle_options.m: Rename the function symbols of the grade_component type, since "trace" is now an operator. compiler/llds.m: Extend the LLDS with a mechanism to refer to C global variables. For now, these are used to refer to C globals that will be created by mkinit to represent the initial values of the environment variables referred to by trace goals. compiler/commit_gen.m: Check that no trace goal with a runtime condition survives to code generation; they should have been transformed by simplify.m. compiler/code_gen.m: Tell commit_gen.m what kind of scope it is generating code for. compiler/pragma_c_gen.m: Generate code for runtime conditions when handling the foreign_procs created by simplify.m. compiler/code_info.m: Allow pragma_c_gen.m to record what environment variables it has generated references to. compiler/proc_gen.m: Record the set of environment variables a procedure refers to in the LLDS procedure header, for efficient access by llds_out.m. compiler/llds_out.m: Handle the new LLDS construct, and tell mkinit which environment variables need C globals created for them. compiler/pd_util.m: Rename some predicates to avoid ambiguity. compiler/*.m: Conform to the changes above, mainly the renames of function symbols and predicates, the changed signatures of some predicates, and the new handling of purity. util/mkinit.c: Generate the definitions and the initializations of any C globals representing the initial status (set or not set) of environment variables needed by trace goals. library/assoc_list.m: Add some predicates that are useful in prog_io*.m. library/term_io.m: Minor cleanup. tests/hard_coded/trace_goal_{1,2}.{m,exp}: New test cases to test the new construct, identical except for whether the trace goal is enabled at compile time. tests/hard_coded/trace_goal_env_{1,2}.{m,exp}: New test cases to test the new construct, identical except for whether the trace goal is enabled at run time. tests/hard_coded/Mercury.options: tests/hard_coded/Mmakefile: Enable the new test cases. tests/invalid/*.err_exp: Update the expected output for the new versions of the error messages now being generated.	2006-07-27 05:03:54 +00:00
Zoltan Somogyi	fb9f78b784	Fix a bug reported by Peter Hawkins. The bug was that an predicate without ... Estimated hours taken: 3 Branches: main Fix a bug reported by Peter Hawkins. The bug was that an predicate without a declared determinism but whose inferred determinism was invalid for its tabling declaration led to a compiler abort. compiler/det_analysis.m: Fix the main cause of the bug, which was that the check for the compatibility of evaluation method and determinism was performed only for predicates with declared determinisms, not those without. Centralize the printing of determinism error messages, and sort the messages first. compiler/hlds_pred.m: Fix the other half of the bug: the predicate that checked the compatibility of evaluation method and determinism was too liberal with minimal model predicates, letting through determinisms that the tabling transformation cannot (yet) support. compiler/det_report.m: Fix the formatting of the error message. compiler/prog_data.m: Rename the function symbols of the type "determinism", to avoid conflicts with language keywords. compiler/*.m: Conform to the change to prog_data.m. tests/invalid/hawkins_mm_fail_reset.{m,err_exp}: New test case for the bug being fixed. tests/invalid/Mmakefile: Enable the new test case. tests/invalid/loopcheck.err_exp: Expect the new format of the improved error message.	2006-07-12 02:51:22 +00:00
Julien Fischer	f5de906db6	Minor style cleanups for the CTGC system. There are no changes to any ... Estimated hours taken: 1 Branches: main Minor style cleanups for the CTGC system. There are no changes to any algorithms. compiler/ctgc.*.m: compiler/prog_ctgc.m: compiler/structure_reuse.*.m: compiler/structure_sharing.*.m: Minor style cleanups. compiler/builtin_ops.m: compiler/check_hlds.m: compiler/exception_analysis.m: compiler/hlds_rtti.m: compiler/process_util.m: s/__/./ in a couple of spots and fix a few other formatting problems.	2006-06-05 05:23:27 +00:00
Julien Fischer	ee5e325924	Workaround a hole in exception analysis that was causing it to incorrectly ... Estimated hours taken: 3.5 Branches: main, release Workaround a hole in exception analysis that was causing it to incorrectly conclude that polymorphic procedures that might throw an exception would not. The problem involved types like the following: :- type foo ---> foo1 ; foo2(bar). :- type bar ... where equality is bar_equals. where bar_equals is a predicate that may throw an exception. The problem was that calls to builtin.unify (and by extension all procedures the analysis considers conditional) with arguments of type foo were not being treated as possibly throwing an exception. This is because exception analysis was considering only the head of the type and not what was contained in the body. In particular it missed the situation above where a type with user-defined equality was embedded in a monomorphic type. The workaround in this diff restricts exception analysis to declaring polmorphic procedures not to throw an exception only if the properties of the type can be determined by examining the head of the type. In practice this means restricting it to enumerations and to types exported by the standard library. In the case of the latter, the information is hardcoded into the analyser. (The above is in reference to so-called type-exceptions, exceptions that result from a call to a user-defined equality or comparison predicate that throws an exception - the behaviour of polymorphic procedures with user-exceptions, exceptions (ultimately) caused by a call to throw/1, is unchanged.) The long term fix is to add an analysis that analyses type definitions for features of interest to other optimizations, e.g. whether they contain other types that have user-defined equality or whether they contain existentially quantified constructors. (Such an analysis will also eventually be required for things like trail-usage optimization and the experimental optimization for removing the overhead of minimal model tabling.) compiler/exception_analysis.m: Fix the handling of polymorphism so that we don't erroneously conclude that procedures that may throw exceptions do not. tests/term/Makefile: tests/term/Mercury.options: tests/term/exception_analysis_test2.m: tests/term/exception_analysis_test2.trans_opt_exp: Add a test case for the above problem and also check that we handle enumerations with user-defined equality correctly.	2006-05-30 03:19:40 +00:00
Julien Fischer	459847a064	Move the univ, maybe, pair and unit types from std_util into their own ... Estimated hours taken: 18 Branches: main Move the univ, maybe, pair and unit types from std_util into their own modules. std_util still contains the general purpose higher-order programming constructs. library/std_util.m: Move univ, maybe, pair and unit (plus any other related types and procedures) into their own modules. library/maybe.m: New module. This contains the maybe and maybe_error types and the associated procedures. library/pair.m: New module. This contains the pair type and associated procedures. library/unit.m: New module. This contains the types unit/0 and unit/1. library/univ.m: New module. This contains the univ type and associated procedures. library/library.m: Add the new modules. library/private_builtin.m: Update the declaration of the type_ctor_info struct for univ. runtime/mercury.h: Update the declaration for the type_ctor_info struct for univ. runtime/mercury_mcpp.h: runtime/mercury_hlc_types.h: Update the definition of MR_Univ. runtime/mercury_init.h: Fix a comment: ML_type_name is now exported from type_desc.m. compiler/mlds_to_il.m: Update the the name of the module that defines univs (which are handled specially by the il code generator.) library/*.m: compiler/*.m: browser/*.m: mdbcomp/*.m: profiler/*.m: deep_profiler/*.m: Conform to the above changes. Import the new modules where they are needed; don't import std_util where it isn't needed. Fix formatting in lots of modules. Delete duplicate module imports. tests/*: Update the test suite to confrom to the above changes.	2006-03-29 08:09:58 +00:00
Zoltan Somogyi	12deb40264	Rename all the get access predicates in these modules that don't ... Estimated hours taken: 0.1 Branches: main compiler/hlds_clauses.m: compiler/hlds_pred.m: Rename all the get access predicates in these modules that don't already have put "get" in their name. (The names of the set access predicates were OK already.) compiler/*.m: Conform to the above. All this was done by this sed script: s/clauses_info_varset/clauses_info_get_varset/ s/clauses_info_explicit_vartypes/clauses_info_get_explicit_vartypes/ s/clauses_info_vartypes/clauses_info_get_vartypes/ s/clauses_info_headvars/clauses_info_get_headvars/ s/clauses_info_clauses_rep/clauses_info_get_clauses_rep/ s/clauses_info_rtti_varmaps/clauses_info_get_rtti_varmaps/ s/pred_info_import_status/pred_info_get_import_status/ s/pred_info_arg_types/pred_info_get_arg_types/ s/pred_info_typevarset/pred_info_get_typevarset/ s/pred_info_tvar_kinds/pred_info_get_tvar_kinds/ s/pred_info_procedures/pred_info_get_procedures/ s/proc_info_context/proc_info_get_context/ s/proc_info_varset/proc_info_get_varset/ s/proc_info_vartypes/proc_info_get_vartypes/ s/proc_info_headvars/proc_info_get_headvars/ s/proc_info_inst_varset/proc_info_get_inst_varset/ s/proc_info_maybe_declared_argmodes/proc_info_get_maybe_declared_argmodes/ s/proc_info_argmodes/proc_info_get_argmodes/ s/proc_info_maybe_arglives/proc_info_get_maybe_arglives/ s/proc_info_declared_determinism/proc_info_get_declared_determinism/ s/proc_info_inferred_determinism/proc_info_get_inferred_determinism/ s/proc_info_goal/proc_info_get_goal/ s/proc_info_can_process/proc_info_get_can_process/ s/proc_info_rtti_varmaps/proc_info_get_rtti_varmaps/ s/proc_info_eval_method/proc_info_get_eval_method/ s/proc_info_is_address_taken/proc_info_get_is_address_taken/ s/proc_info_stack_slots/proc_info_get_stack_slots/ s/proc_info_liveness_info/proc_info_get_liveness_info/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/ s/proc_info_context/proc_info_get_context/	2006-03-27 09:36:34 +00:00
Zoltan Somogyi	5b8f96f61d	Prepare for an extension of promise_equivalent_solutions that will allow us ... Estimated hours taken: 5 Branches: main Prepare for an extension of promise_equivalent_solutions that will allow us to better handle values of user-defined types. The problem is that currently, the deconstruction of a value of such a type can be followed only by code that cannot fail, otherwise the cc_multi deconstruction is not in the required single-solution context. If the following code is naturally semidet, this can be worked around by turning it into det code returning a maybe and testing the maybe outside the promise_equivalent_solutions, but this is inefficient, and in any case it does not generalize to nondet code without even more horrendous inefficiency and inconvenience. (You have to create a nondet closure and call it outside the promise_equivalent_solutions.) The solution I came up with is something is to have a construct that contains - a list of deconstructions on types with user-defined equality, - a goal, and - the list of outputs of that goal. The idea is that this would be transformed into a conjunction of the first and second items, and wrapped inside a special kind of conj that provides a scope for the implicit promise, which is that the set of solutions of the goal in the second item doesn't depend on what concrete terms the deconstructions in the first item return out of the set of concrete terms they *could* return. The deconstructions in the first item would be marked to tell determinism analysis to effectively ignore the fact that they involve user-defined equality. The actual addition of that construct is left for a future change, after we agree on the syntax. compiler/hlds_goal.m: Generalize the existing promise_equivalent_solutions scope to a promise_solutions scope with a flag that says whether in the source code it was originally the existing "promise_equivalent_solutions" construct or the new construct (which doesn't exist yet, but is indicated by the symbol "same_solutions" for now). Replace the conj and par_conj hlds_goal_exprs with a single goal expression: conj with an additional argument which is either plain_conj or parallel_conj. This was part of an earlier design in which a third kind of disjunction took the role now assigned to the new kind of promise_solutions scope, but turned out to be a good idea anyway, since in many places the compiler does treat the two kinds of conjunctions the same. This part of the change is responsible for the fact that this change results in a net *reduction* of about 40 lines. Move the most frequently used kinds of goal expressions to the front of the type declaration to allow the compiler to make better decisions about tag allocation. Add the goal marker we will add to the deconstructions in the first item. Replace the true_goal and fail_goal predicates with functions to make them easier to use, and rename their variants that take a context argument to avoid unnecessary ambiguity. compiler/*.m: Conform to the change in hlds_goal.m. Misc changes to make code more robust, e.g. replacing semidet predicates on goal expressions with functions returning bool. Misc cleanups, e.g. removal of unnecessary module qualifications that made lines too long, renaming predicates whose names include "disj" if they are also used to process parallel conjunctions (since in both parallel conjunctions and in disjunctions the goals are independent), and turning semidet predicates that switch on goal expressions into bool functions (to make similar changes more rebust in the future).	2006-02-24 05:49:43 +00:00
Zoltan Somogyi	5af71b60ac	Remove support for the Aditi backend. It is a pain to have to update it every ... Estimated hours taken: 2 Branches: main Remove support for the Aditi backend. It is a pain to have to update it every time a data structure changes when we don't see any benefit from it, and its presence makes compilation of the compiler directory take about 10% longer (since the Aditi backend modules are roughly 10% of the code in the compiler directory). Deleting the Aditi-specific data structures from the HLDS should also speed up compilation a little bit. I have spoken to Rao and he is fine with this step. Aditi users, if there are any, can continue to use the Aditi support in release 0.12.*. I also tagged the last version on the trunk to support aditi with the name "last_aditi". The need for modifications in this Aditi support is likely to be very rare to nonexistent, if the recent past is any guide: the Aditi backend hasn't seen a nontrivial modification in a year or more. This diff removes a net 31492 lines. compiler/add_aditi.m: compiler/aditi_backend.pp: compiler/aditi_builtin_ops.m: compiler/context.m: compiler/dnf.m: compiler/magic.m: compiler/magic_util.m: compiler/rl.m: compiler/rl_analyse.m: compiler/rl_block.m: compiler/rl_block_opt.m: compiler/rl_code.m: compiler/rl_dump.m: compiler/rl_exprn.m: compiler/rl_file.pp: compiler/rl_gen.m: compiler/rl_info.m: compiler/rl_key.m: compiler/rl_liveness.m: compiler/rl_loop.m: compiler/rl_opt.m: compiler/rl_out.pp: compiler/rl_relops.m: compiler/rl_sort.m: compiler/rl_stream.m: Remove these compiler modules, since they existed only to support the Aditi backend. compiler/hlds_goal.m: Delete the Aditi-specific components of goals (e.g. the aditi-builtin kind of generic calls and Aditi-evaluated lambdas). compiler/hlds_pred.m: Delete the Aditi-specific components of pred_infos. compiler/prog_data.m: Delete the Aditi-specific items. compiler/passes_aux.m: Don't worry about processing all procedures or just all non-Aditi procedures. compiler/add_clause.m: Add a predicate from a deleted module that is now used only here. compiler/*.m: Conform to the data structure changes above. compiler/notes/*.html: Remove references to the Aditi backend. tests/invalid/aditi.m: tests/invalid/aditi_errors.err_exp: tests/invalid/aditi_errors.m: tests/invalid/aditi_private_builtin.m: tests/invalid/aditi_state_errors.err_exp: tests/invalid/aditi_state_errors.m: tests/invalid/aditi_update_derived_relation.err_exp: tests/invalid/aditi_update_derived_relation.m: tests/invalid/aditi_update_errors.err_exp: tests/invalid/aditi_update_errors.m: tests/invalid/aditi_update_mode_errors.err_exp: tests/invalid/aditi_update_mode_errors.m: tests/valid/aditi.m: tests/valid/aditi_calls_mercury.m: tests/valid/aditi_error_bug.m: tests/valid/aditi_error_bug2.m: tests/valid/aditi_error_bug3.m: tests/valid/aditi_private_builtin.m: tests/valid/aditi_query.m: tests/valid/aditi_update.m: tests/valid/base_relation.m: tests/valid/base_relation2.m: tests/valid/ite_to_disj.m: Remove these Aditi-specific tests. tests/*/Mmakefile: Remove the references to these Aditi-specific tests.	2006-02-23 09:37:30 +00:00
Peter Wang	613ab045cd	Don't try to reanalyse suboptimal, non-local modules when using ... Estimated hours taken: 10 Branches: main compiler/make.program_target.m: Don't try to reanalyse suboptimal, non-local modules when using `--intermodule-analysis'. compiler/exception_analysis.m: compiler/trailing_analysis.m: compiler/unused_args.m: When looking up an analysis result, if the result is from a non-local module and is `suboptimal', just assume it is `optimal' since we can't make requests to or reanalyse the non-local module anyway. On the other hand, if we look up a result from a local module which doesn't yet exist, record the default (suboptimal) result that we are using into the module's analysis registry, so that when the module is reanalysed, if the answer pattern changes we will know that it changed and the modules which made use of the default result can be marked.	2006-02-22 00:32:14 +00:00
Julien Fischer	a165d5f743	Convert those optimization passes that make use of exception analysis ... Estimated hours taken: 10 Branches: main Convert those optimization passes that make use of exception analysis information to make use of the intermodule-analysis framework. Make preparations to do the same thing for the termination analyses. s/list(prog_var)/prog_vars/ s/list(hlds_goal)/hlds_goals/ Style cleanups and formatting fixes for these modules as necessary. compiler/exception_analysis.m: Export a predicate that allows optimizations to access exception analysis results without worrying about where they are stored. When using intermodule-analysis information about imported procedures is stored in the analysis registry, not in the exception_info table; with intermodule-optimization information about imported procedures is stored in the exception_info table. compiler/goal_form.m: Add a version of goal_cannot_throw that uses information from the intermodule-analysis framework. Mention that the existing versions of this predicate are deprecated and will eventually be deleted. compiler/goal_util.m: Provide alternative versions of the predicates can_reorder_goals and reordering_maintains_termination that can use information from the intermodule-analysis framework. We will eventually use these versions exclusively. compiler/simplify.m: compiler/constraint.m: Use information from the intermodule-analysis framework when performing these optimizations. compiler/accumulator.m: Mention that this module needs to be updated to use the intermodule-analysis framework. (I'll do this as separate change since it's probably going to require a fairly major rewrite of this module to do this.) compiler/deforest.m: compiler/pd_util.m: compiler/size_prof.m: Conform to the above changes.	2006-02-16 05:48:30 +00:00
Peter Wang	d202be54a0	This patch mainly adds the ability to perform intermodule analysis of modules ... Estimated hours taken: 20 Branches: main This patch mainly adds the ability to perform intermodule analysis of modules as a separate step from code generation. It makes a start on automatic reanalysis of modules if their .analysis files become invalid or suboptimal. analysis/analysis.file.m: analysis/analysis.m: Add a predicate `read_module_overall_status' to read just the overall status of an analysis file. Fix a bug where analysis results were being discarded (upon reading) if the module's overall status was `invalid'. We can't do that as then we wouldn't know which results changed after reanalysis. Touch a `FOO.analysis_date' file after module `FOO' is analysed. This is needed to indicate the time at which `FOO' was last analysed, as `FOO.analysis' can be modified at other times. Add a mutable boolean variable `debug_analysis' that can be set to enable debugging messages for the analysis framework. compiler/handle_options.m: compiler/options.m: Add new compiler options `--make-analysis-registry', `--debug-intermodule-analysis' and `--analysis-repeat'. compiler/make.dependencies.m: Add `.analysis' files as dependencies of compiled code files if `--intermodule-analysis' is used. compiler/make.m: compiler/make.module_target.m: compiler/make.program_target.m: compiler/make.util.m: Add a `FOO.analyse' pseudo-target to `mmc --make'. This produces all the `.analysis' files needed to compile the top-level module `FOO', reanalysing modules until none of the `.analysis' files are invalid. The `--analysis-repeat' option can also be used to force `suboptimal' modules to be reanalysed a number of times. Perform an analysis pass when building executables or libraries to make sure that compilation does not proceed with invalid analysis files. Treat `.analysis' files specially when checking whether they are out of date. Analysis files require looking at their contents to determine whether they are invalid (in which case they are out of date), or valid (in which case we look at the timestamp of the corresponding `.analysis_date' file). compiler/mercury_compile.m: Make `.analysis' be written out only when `--make-analysis-registry' is used, like `--make-transitive-optimization-interface'. `mmc --make' runs the compiler the `--make-analysis-registry' option as appropriate. compiler/exception_analysis.m: compiler/trailing_analysis.m: compiler/unused_args.m: Only record intermodule dependencies and analysis results when `--make-analysis-registry' is enabled, not when `--intermodule-analysis' is enabled. doc/user_guide.texi: Document `--debug-intermodule-analysis' and `--analysis-repeat'.	2006-02-06 05:39:45 +00:00
Julien Fischer	9e0eac872d	Convert the exception analysis so that it can use the intermodule-analysis ... Estimated hours taken: 10 Branches: main Convert the exception analysis so that it can use the intermodule-analysis framework. General cleanup of the exception analysis code, particularly the parts that analyse higher-order calls based on the results of closure analysis. TODO: - fix up the optimization passes so that they look up exception information in the correct place when --intermodule-analysis is enabled. Information about imported procedures will be stored in the analysis registry, not in the exception_info table as is the case when --intermodule-optimization is used. (The same thing needs to be done for the trail usage optimization.) compiler/exception_analysis.m: Support exception analysis using the intermodule analysis framework. Fix some layout problems Update the TODO list. compiler/mmc_analysis.m: Add `exception_analysis' to the list of supported analyses. compiler/hlds_module.m: Add a slot to store the exception analysis status for each procedure. compiler/add_pragma.m: compiler/goal_form.m: Conform to the above changes.	2006-02-01 04:02:46 +00:00
Julien Fischer	5f589e98fb	Various cleanups for the modules in the compiler directory. ... Estimated hours taken: 4 Branches: main Various cleanups for the modules in the compiler directory. The are no changes to algorithms except the replacement of some if-then-elses that would naturally be switches with switches and the replacement of most of the calls to error/1. compiler/*.m: Convert calls to error/1 to calls to unexpected/2 or sorry/2 as appropriate throughout most or the compiler. Fix inaccurate assertion failure messages, e.g. identifying the assertion failure as taking place in the wrong module. Add :- end_module declarations. Fix formatting problems and bring the positioning of comments into line with our current coding standards. Fix some overlong lines. Convert some more modules to 4-space indentation. Fix some spots where previous conversions to 4-space indentation have stuffed the formatting of the code up. Fix a bunch of typos in comments. Use state variables in more places; use library predicates from the sv* modules where appropriate. Delete unnecessary and duplicate module imports. Misc. other small cleanups.	2005-11-17 15:57:34 +00:00
Zoltan Somogyi	21685c9e22	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 6 Branches: main Improve the error messages generated for determinism errors involving committed choice contexts. Previously, we printed a message to the effect that e.g. a cc pred is called in context that requires all solutions, but we didn't say *why* the context requires all solutions. We now keep track of all the goals to the right that could fail, since it is these goals that may reject the first solution of a committed choice goal. The motivation for this diff was the fact that I found that locating the failing goal can be very difficult if the conjunction to the right is a couple of hundred lines long. This would have been a nontrivial problem, since (a) unifications involving values of user-defined types are committed choice goals, and (b) we can expect uses of user-defined types to increase. compiler/det_analysis.m: Keep track of goals to the right of the current goal that could fail, and include them in the error representation if required. compiler/det_report.m: Include the list of failing goals to the right in the representations of determinism errors involving committed committed choice goals. Convert the last part of this module that wasn't using error_util to use error_util. Make most parts of this module just construct error message specifications; print those specifications (using error_util) in only a few places. compiler/hlds_out.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: compiler/compiler_util.m: Error_util is still changing reasonably often, and yet it is included in lots of modules, most of which need only a few simple non-parse-tree-related predicates from it (e.g. unexpected). Move those predicates to a new module, compiler_util.m. This also eliminates some undesirable dependencies from libs to parse_tree. compiler/libs.m: Include compiler_util.m. compiler/notes/compiler_design.html: Document compiler_util.m, and fix the documentation of some other modules. compiler/*.m: Import compiler_util instead of or in addition to error_util. To make this easier, consistently use . instead of __ for module qualifying module names. tests/invalid/det_errors_cc.{m,err_exp}: Add this new test case to test the error messages for cc contexts. tests/invalid/det_errors_deet.{m,err_exp}: Add this new test case to test the error messages for unifications inside function symbols. tests/invalid/Mmakefile: Add the new test cases. tests/invalid/det_errors.err_exp: tests/invalid/magicbox.err_exp: Change the expected output to conform to the change in det_report.m, which is now more consistent.	2005-11-04 03:41:09 +00:00
Zoltan Somogyi	f9fe8dcf61	Improve the error messages generated for determinism errors involving committed ... Estimated hours taken: 8 Branches: main Improve the error messages generated for determinism errors involving committed choice contexts. Previously, we printed a message to the effect that e.g. a cc pred is called in context that requires all solutions, but we didn't say *why* the context requires all solutions. We now keep track of all the goals to the right that could fail, since it is these goals that may reject the first solution of a committed choice goal. The motivation for this diff was the fact that I found that locating the failing goal can be very difficult if the conjunction to the right is a couple of hundred lines long. This would have been a nontrivial problem, since (a) unifications involving values of user-defined types are committed choice goals, and (b) we can expect uses of user-defined types to increase. compiler/det_analysis.m: Keep track of goals to the right of the current goal that could fail, and include them in the error representation if required. compiler/det_report.m: Include the list of failing goals to the right in the representations of determinism errors involving committed committed choice goals. Convert the last part of this module that wasn't using error_util to use error_util. Make most parts of this module just construct error message specifications; print those specifications (using error_util) in only a few places. compiler/hlds_out.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: Add a function for use by the new code in det_report.m. compiler/error_util.m: compiler/compiler_util.m: Error_util is still changing reasonably often, and yet it is included in lots of modules, most of which need only a few simple non-parse-tree-related predicates from it (e.g. unexpected). Move those predicates to a new module, compiler_util.m. This also eliminates some undesirable dependencies from libs to parse_tree. compiler/libs.m: Include compiler_util.m. compiler/notes/compiler_design.html: Document compiler_util.m, and fix the documentation of some other modules. compiler/*.m: Import compiler_util instead of or in addition to error_util. To make this easier, consistently use . instead of __ for module qualifying module names. tests/invalid/det_errors_cc.{m,err_exp}: Add this new test case to test the error messages for cc contexts. tests/invalid/det_errors_deet.{m,err_exp}: Add this new test case to test the error messages for unifications inside function symbols. tests/invalid/Mmakefile: Add the new test cases. tests/invalid/det_errors.err_exp: tests/invalid/magicbox.err_exp: Change the expected output to conform to the change in det_report.m, which is now more consistent.	2005-10-28 02:11:03 +00:00
Zoltan Somogyi	b2012c0c0e	Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' ... Estimated hours taken: 8 Branches: main compiler/*.m: Rename the types 'type', 'inst' and 'mode' to 'mer_type', 'mer_inst' and 'mer_mode'. This is to avoid the need to parenthesize these type names in some contexts, and to prepare for the possibility of a parser that considers those words to be reserved words. Rename some other uses of those names (e.g. as item types in recompilation.m). Delete some redundant synonyms (prog_type, mercury_type) for mer_type. Change some type names (e.g. mlds__type) and predicate names (e.g. deforest__goal) to make them unique even without module qualification. Rename the function symbols (e.g. pure, &) that need to be renamed to avoid the need to parenthesize them. Make their replacement names more expressive. Convert some more modules to four space indentation. Avoid excessively long lines, such as those resulting from the automatic substitution of 'mer_type' for 'type'.	2005-10-24 04:14:34 +00:00
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
Mark Brown	881033facb	Introduce a distinction between variables that are typed according to the ... Estimated hours taken: 15 Branches: main Introduce a distinction between variables that are typed according to the external view of a procedure, in which the types may contain an existentially quantified type variable, and variables that are typed according to the internal view of a procedure, in which existentially quantified type variables may be bound to a known type. The distinction is maintained by adding "exists_cast" goals which assign an internal variable to its corresponding external variable. Any output head variable which is existentially typed and for which the external view differs from the internal view is replaced by a new variable. An exists_cast goal is added to the end of the procedure which casts the old headvar to the new one. We also do the same for any type_infos and typeclass_infos that are output. Exists casts are implemented as a variant on unsafe_cast generic calls. We also add other variants to distinguish the different kinds of casts: - equiv_casts for when the types are the same modulo equivalence types; - unsafe_type_casts for when the types are different but the insts are compatible; and - unsafe_type_inst_casts for when the type and inst are changed by the cast. The purpose of this change is to make it possible to include both the internal and external views in the rtti_varmaps structure. compiler/polymorphism.m: Perform the transformation on proc_infos to include the exists_cast goals. This is done at the end of the polymorphism transformation, when we recompute the argument types for the newly transformed procedure. The clauses_infos are left untouched by this transformation, since after this stage they should no longer be used. compiler/hlds_goal.m: Modify the generic_call type to include the type of cast. compiler/hlds_pred.m: Modify the generic_call_id type to include the type of cast. compiler/goal_util.m: Add an argument to `generate_unsafe_cast' which specifies the type of cast to generate. compiler/higher_order.m: Use the predicate in goal_util to generate the cast, instead of doing it manually. compiler/prog_rep.m: All variants of the cast generic call are represented in the same way. This is to avoid to the need to change the format of static data in programs compiled with full declarative debugging. If we do need the distinction to be made here, then that can be done as a separate change. compiler/purity.m: Calls to private_builtin.unsafe_type_cast are translated into unsafe_type_cast generic calls. compiler/aditi_builtin_ops.m: Use unsafe_type_inst_cast when casting between aditi_bottom_up closures and their transformed versions. compiler/common.m: Use unsafe_type_cast when generating assignments for variables whose types do not match exactly. compiler/unify_proc.m: Use equiv_type_cast when generating casts in unification, comparison and initialisation clauses for equivalence types. Use unsafe_type_cast when casting enum types to integers for the purposes of comparison or unification. compiler/*.m: Handle the new generic_calls.	2005-08-12 05:14:17 +00:00
Julien Fischer	1d527d1707	Add support for exception analysis through some generic_call sites. ... Estimated hours taken: 7 Branches: main Add support for exception analysis through some generic_call sites. At the moment this is restricted to higher-order calls, although we may eventually extend it to method calls as well. As with the recent change to generic_calls for termination analysis, this is currently of limited usefulness because the procedure dependency graph does not record information about higher-order calls. I'll some test cases when the dependency graph has been changed to include this information. compiler/exception_analysis.m: Use the results of closure analysis to perform exception analysis at generic_call sites.	2005-08-04 09:08:40 +00:00
Julien Fischer	72f60369ee	Make a number of minor cleanups to the exception analysis module. ... Estimated hours taken: 0.5 Branches: main Make a number of minor cleanups to the exception analysis module. There are no changes to any algorithms. compiler/exception_analysis.m: Use 4-space indentation throughout. Remove the comment about needing to add annotations for foreign_procs; they've been added. Remove some unnecessary imports. s/Module/ModuleInfo/ throughout. Other minor changes to formatting throughout.	2005-04-14 07:47:31 +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