136 Commits

Author	SHA1	Message	Date
Zoltan Somogyi	9d6c8d1780	Improve programming style. ... compiler/hlds_llds.m: Give some function symbols more meaningful names. compiler/code_loc_dep.m: Give some function symbols and variables more meaningful names. Replace list(prog_var) with set_of_progvar in the signatures of some predicates to express the invariant that the argument should not contain any duplicates. Provide a utility predicate for ite_gen.m. Generate more readable debug output. compiler/ite_gen.m: Factor out some common code. Optimize some tests. Break up a predicate to reduce the level of indentation. Add some module qualifications to reduce type ambiguity. compiler/var_locn.m: Separate the two use cases of init_var_locn_state_2, since one needs more work than the other. Factor out the parts that are common to both. compiler/llds.m: Define a bespoke type to control whether auto-comments are printed or not. compiler/code_gen.m: compiler/disj_gen.m: compiler/frameopt.m: compiler/hlds_out_goal.m: compiler/layout_out.m: compiler/live_vars.m: compiler/live_vars.m: compiler/liveness.m: compiler/liveness.m: compiler/llds_out_file.m: compiler/llds_out_instr.m: compiler/llds_out_util.m: compiler/lookup_switch.m: compiler/lookup_switch.m: compiler/opt_debug.m: compiler/optimize.m: compiler/use_local_vars.m: Conform to the changes above.	2020-07-17 10:48:13 +10:00
Zoltan Somogyi	ae4b736fdd	Implement warnings for suspicious recursion. ... compiler/simplify_goal_call.m: If the --warn-suspicious-recursion option is set, and if the warning isn't disabled, generate warnings for two different kinds of suspicious recursion. They are both related to, but separate from, the warning we have long generated for infinite recursion, which occurs when the input args of a recursive call are the same as the corresponding args in the clause head. Both kinds suspicious recursion look at the input args of a recursive call that are NOT the same as the corresponding args in the clause head. Both require these args to have non-unique modes. (If they have unique modes, then the depth of the recursion may be controlled by state outside the view of the Mercury compiler, which means that a warning would be likely to be misleading.) The first kind is when all these args use state variable notation. Most of the time, we use state var notation to denote the data structures updated by the recursive code; having variables using such notation *controlling* the recursion is much less common, and much more likely to be unintended. The motivation for the new option was this infinitely looping code, which resulted from neglecting to s/[X | Xs]/Xs/ after cutting-and-pasting the clause head to the recursive call. p([X | Xs], !S) :- ..., p([X | Xs], !S). The other kind of suspicious recursive call we warn about involve input arguments where the base names of the input arguments (the part before any numeric suffixes) seem be switched between the clause head and the recursive call, as here: q(As0, Bs0, ...) :- ..., q(Bs1, As, ...). compiler/mercury_compile_main.m: Disable style warnings when invoked with --make-optimization-interface or its transitive variant. Without this, warnings about suspicious recursion would get reported in such invocations. Move a test from a callee to a caller to allow the callee to be less indented. compiler/options.m: Export functionality to mercury_compile_main.m to make the above possible. library/string.m: Add a predicate to convert a string to *reverse* char list directly. Note a discrepancy between the documentation and the implementation of the old predicate the new one is based on (which converts a string to a forward char list). NEWS: Note the new predicate in string.m. compiler/cse_detection.m: compiler/ctgc.selector.m: compiler/dead_proc_elim.m: compiler/deforest.m: compiler/dep_par_conj.m: compiler/det_analysis.m: compiler/distance_granularity.m: compiler/frameopt.m: compiler/inst_util.m: compiler/lp_rational.m: compiler/matching.m: compiler/modes.m: compiler/old_type_constraints.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_arguments.m: compiler/recompilation.usage.m: compiler/stratify.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.indirect.m: compiler/typeclasses.m: compiler/use_local_vars.m: deep_profiler/callgraph.m: deep_profiler/canonical.m: library/bit_buffer.read.m: library/bit_buffer.write.m: library/calendar.m: library/diet.m: library/lexer.m: library/parser.m: library/parsing_utils.m: library/ranges.m: library/set_ctree234.m: library/set_tree234.m: library/string.parse_util.m: library/tree234.m: library/varset.m: mdbcomp/program_representation.m: mdbcomp/rtti_access.m: profiler/demangle.m: Avoid warnings for suspicious recursion. In most cases, do this by wrapping disable_warning scopes around the affected recursive calls; in a few cases, do this by changing the code. tests/warnings/suspicious_recursion.{m,exp}: A test case for the new warnings. tests/warnings/Mercury.options: tests/warnings/Mmakefile: Enable the new test case.	2019-05-01 21:29:05 +10:00
Zoltan Somogyi	d49f6eab84	Add missing imports of parent modules. ... These imports were missing from source files, but were included in imported modules' .int3 files. An upcoming change will delete these from those .int3 files.	2019-03-20 03:57:10 +11:00
Zoltan Somogyi	15aa457e12	Delete $module arg from calls to unexpected.	2018-04-07 18:25:43 +10:00
Zoltan Somogyi	b96dacdcac	Make a bunch of switches complete. ... compiler/exception_analysis.m: compiler/frameopt.m: compiler/get_dependencies.m: compiler/labelopt.m: compiler/ml_global_data.m: compiler/ml_optimize.m: compiler/options_file.m: compiler/parse_class.m: compiler/rtti.m: compiler/rtti_out.m: compiler/type_util.m: compiler/var_locn.m: As above. compiler/inst_match.m: Fix a stray piece of code. compiler/loop_inv.m: Add a module qualification. compiler/opt_util.m: Delete two unused predicates.	2017-03-09 13:43:48 +11:00
Zoltan Somogyi	4ebc3ffa04	Carve four modules out of prog_data.m. ... The prog_data.m module is imported by most modules of the compiler; by 359 modules out of 488, to be exact. Yet it has many parts that most of those 359 modules don't need. This diff puts those parts into four new modules. The number of imports of these modules: 348 modules import prog_data.m 84 modules import prog_data_foreign.m 62 modules import prog_data_pragma.m 12 modules import prog_data_event.m 5 modules import prog_data_used_modules.m compiler/prog_data_event.m: compiler/prog_data_foreign.m: compiler/prog_data_pragma.m: compiler/prog_data_used_modules.m: New modules. They contain the parts of the parse tree that deal respectively with the specification of events and event sets, interfacing to foreign languages, pragmas, and the sets of used (i.e. not unused) modules. compiler/prog_data.m: Delete the stuff that is now in the new modules. Put the remaining parts of the module into a logical order. compiler/parse_tree.m: compiler/notes/compiler_design.html: Include and document the new modules. compiler/globals.m: Move a type here from prog_data.m, since this is where it belongs. compiler/add_foreign_proc.m: compiler/add_mutable_aux_preds.m: compiler/add_pragma.m: compiler/add_solver.m: compiler/add_trail_ops.m: compiler/call_gen.m: compiler/code_gen.m: compiler/code_loc_dep.m: compiler/comp_unit_interface.m: compiler/compile_target_code.m: compiler/complexity.m: compiler/continuation_info.m: compiler/coverage_profiling.m: compiler/ctgc.datastruct.m: compiler/ctgc.livedata.m: compiler/ctgc.selector.m: compiler/deep_profiling.m: compiler/dep_par_conj.m: compiler/deps_map.m: compiler/det_analysis.m: compiler/det_report.m: compiler/elds_to_erlang.m: compiler/equiv_type.m: compiler/erl_call_gen.m: compiler/exception_analysis.m: compiler/export.m: compiler/fact_table.m: compiler/foreign.m: compiler/frameopt.m: compiler/get_dependencies.m: compiler/goal_form.m: compiler/goal_util.m: compiler/granularity.m: compiler/hlds_goal.m: compiler/hlds_module.m: compiler/hlds_out_goal.m: compiler/hlds_out_module.m: compiler/hlds_out_pred.m: compiler/hlds_pred.m: compiler/inlining.m: compiler/intermod.m: compiler/ite_gen.m: compiler/item_util.m: compiler/jumpopt.m: compiler/layout.m: compiler/layout_out.m: compiler/live_vars.m: compiler/livemap.m: compiler/llds.m: compiler/llds_out_file.m: compiler/llds_out_global.m: compiler/llds_out_instr.m: compiler/make.dependencies.m: compiler/make.module_dep_file.m: compiler/make_hlds.m: compiler/make_hlds_warn.m: compiler/mark_tail_calls.m: compiler/mercury_compile_llds_back_end.m: compiler/mercury_compile_main.m: compiler/ml_call_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_foreign_proc_gen.m: compiler/ml_proc_gen.m: compiler/ml_tailcall.m: compiler/ml_unify_gen.m: compiler/mlds.m: compiler/mlds_to_c.m: compiler/mlds_to_cs.m: compiler/mlds_to_java.m: compiler/modecheck_goal.m: compiler/module_imports.m: compiler/module_qual.m: compiler/module_qual.qualify_items.m: compiler/modules.m: compiler/opt_debug.m: compiler/par_conj_gen.m: compiler/parse_pragma.m: compiler/parse_tree_out_info.m: compiler/parse_tree_out_pragma.m: compiler/pd_cost.m: compiler/polymorphism.m: compiler/pragma_c_gen.m: compiler/proc_gen.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/prog_foreign.m: compiler/prog_item.m: compiler/prog_out.m: compiler/prog_util.m: compiler/purity.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.points_to_graph.m: compiler/simplify_goal_call.m: compiler/simplify_goal_scope.m: compiler/simplify_proc.m: compiler/smm_common.m: compiler/stack_layout.m: compiler/structure_reuse.analysis.m: compiler/structure_reuse.direct.choose_reuse.m: compiler/structure_reuse.direct.detect_garbage.m: compiler/structure_reuse.domain.m: compiler/structure_reuse.indirect.m: compiler/structure_sharing.analysis.m: compiler/structure_sharing.domain.m: compiler/table_gen.m: compiler/tabling_analysis.m: compiler/term_constr_build.m: compiler/term_constr_initial.m: compiler/term_constr_main.m: compiler/term_constr_main_types.m: compiler/term_constr_pass2.m: compiler/term_constr_util.m: compiler/term_errors.m: compiler/term_pass1.m: compiler/term_pass2.m: compiler/term_traversal.m: compiler/term_util.m: compiler/termination.m: compiler/trace_gen.m: compiler/trailing_analysis.m: compiler/type_constraints.m: compiler/typecheck.m: compiler/unique_modes.m: compiler/unused_args.m: compiler/unused_imports.m: compiler/use_local_vars.m: compiler/write_deps_file.m: Conform to the changes above.	2016-03-13 18:19:31 +11:00
Zoltan Somogyi	0d31eaf4c3	Convert (C->T;E) to (if C then T else E).	2015-09-21 05:47:55 +10:00
Zoltan Somogyi	1d109cc26b	Remove unused predicates.	2015-09-16 13:40:02 +10:00
Zoltan Somogyi	4bcfa09630	Speed up the compiler by 0.8% when generating low level C code ... Estimated hours taken: 0.5 Branches: main compiler/frameopt.m: compiler/jumpopt.m: compiler/labelopt.m: compiler/optimize.m: Speed up the compiler by 0.8% when generating low level C code by using 234 trees instead of lists to store sets of labels.	2012-04-24 04:43:31 +00:00
Julien Fischer	436e5a2616	Remove deprecated modules and (most) deprecated procedures from the standard ... Branches: main Remove deprecated modules and (most) deprecated procedures from the standard library. (The remaining deprecated procedures probably need to stick around for at least another release in order to give people time to adapt their code.) library/dir.m: library/list.m: library/stack.m: library/string.m: library/type_desc.m: Delete obsolete procedures. library/svarray.m: library/svbag.m: library/svbimap.m: library/sveqvclass.m: library/svmap.m: library/svmulti_map.m: library/svqueue.m: library/svset.m: library/svvarset.m: Delete these modules, they are no longer required since the original predicates now have their arguments in the state-variable friendly order. library/library.m: Delete the above modules. compiler/frameopt.m: compiler/par_loop_control.m: compiler/rbmm.region_transformation.m: browser/browser_test.m: extras/windows_installer_generator/wix_gui.m: samples/ultra_sub.m: tests/hard_coded/rnd.m: tests/hard_coded/type_spec_ho_term.m: tests/hard_coded/xmlable_test.m: Conform to the above changes.	2012-01-03 11:04:49 +00:00
Julien Fischer	8e7fe1075c	Delete LLDS support for nondet foreign code. ... Branches: main Delete LLDS support for nondet foreign code. compiler/llds.m: Remove support for save structs from the LLDS. compiler/dupproc.m: compiler/frameopt.m: compiler/llds_out_instr.m: compiler/opt_debug.m: compiler/peephole.m: compiler/proc_gen.m: Conform to the above change. compiler/.cvsignore: Ignore .compiler_tags; delete references to Aditi backend files.	2011-06-17 07:51:18 +00:00
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	9ae7fe6b70	Change the argument ordering of predicates in the set module. ... Branches: main Change the argument ordering of predicates in the set module. library/set.m: Change predicate argument orders to match the versions in the svset module. Group function definitions with the corresponding predicates rather than at the end of the file. Delete Ralph's comments regarding the argument order in the module interface: readers of the library reference guide are unlikely to be interested in his opinion of the argument ordering ten or so years ago. Add extra modes for set.map/3 and set.map_fold/5. library/svset.m: library/eqvclass.m: library/tree234.m: library/varset.m: browser/*.m: compiler/*.m: deep_profiler/*.m: mdbcomp/trace_counts.m: extras/moose/grammar.m: extras/moose/lalr.m: extras/moose/moose.m: tests/hard_coded/bitset_tester.m: Conform to the above change. NEWS: Announce the above changes.	2011-05-06 05:03:29 +00:00
Julien Fischer	2f67852a2d	Change the argument ordering of predicates in the eqvclass and queue modules in ... Branches: main Change the argument ordering of predicates in the eqvclass and queue modules in order to make the more conducive to the use of state variable notation. library/eqvclass.m: library/queue.m: Make the above changes. Shift function definitions so that they placed with the corresponding predicate definitions rather than all being grouped at the end of the module. library/sveqvclass.m: library/svqueue.m: compiler/common.m: compiler/ctgc.selector.m: compiler/dead_proc_elim.m: compiler/matching.m: compiler/modes.m: compiler/recompilation.usage.m: compiler/unify_proc.m:a tests/hard_coded/type_to_term_bug.m: Conform to the above change and remove dependencies on the sv{eqvclass,queue} modules. NEWS: Announce the change.	2011-05-03 05:12:05 +00:00
Julien Fischer	9f68c330f0	Change the argument order of many of the predicates in the map, bimap, and ... Branches: main Change the argument order of many of the predicates in the map, bimap, and multi_map modules so they are more conducive to the use of state variable notation, i.e. make the order the same as in the sv* modules. Prepare for the deprecation of the sv{bimap,map,multi_map} modules by removing their use throughout the system. library/bimap.m: library/map.m: library/multi_map.m: As above. NEWS: Announce the change. Separate out the "highlights" from the "detailed listing" for the post-11.01 NEWS. Reorganise the announcement of the Unicode support. benchmarks/*/*.m: browser/*.m: compiler/*.m: deep_profiler/*.m: extras/*/*.m: mdbcomp/*.m: profiler/*.m: tests/*/*.m: ssdb/*.m: samples/*/*.m slice/*.m: Conform to the above change. Remove any dependencies on the sv{bimap,map,multi_map} modules.	2011-05-03 04:35:04 +00:00
Zoltan Somogyi	1c3bc03415	Make the system compiler with --warn-unused-imports. ... Estimated hours taken: 2 Branches: main, release Make the system compiler with --warn-unused-imports. browser/*.m: library/*.m: compiler/*.m: Remove unnecesary imports as flagged by --warn-unused-imports. In some files, do some minor cleanup along the way.	2010-12-30 11:18:04 +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	4db9b2adbf	Until now, the only indexing we did for switches on strings was using a hash ... Estimated hours taken: 40 Branches: main Until now, the only indexing we did for switches on strings was using a hash table containing jump targets (represented as indices into a list of labels). This diff supplements this with - binary searches of tables containing jump targets, - binary searches of tables containing values (lookup tables), and - hash searches of tables containing values (lookup tables). For now, the new methods exist in the LLDS backend only. NEWS: Mention the new capability. compiler/string_switch.m: Add predicates that implement the new indexing methods on strings. Factor out code from existing predicates as required for this. compiler/switch_gen.m: Invoke the new predicates in string_switch.m when relevant. Avoid passing the constant "no" as the initial value of !MaybeEnd to predicates where we know this will ALWAYS happen. compiler/options.m: doc/user_guide.texi: Add an option to control when we use binary searches for switches on strings. compiler/lookup_switch.m: This module previously handled lookup switches on integers. Generalize it so that pieces of it are now also usable to help implement lookup switches on strings. Rename the predicates specific to switches on integers to make clear this specificity, and separate them from the predicates that help implement lookup switches on variables of all the supported types. Export some types, predicates and functions for use in string_switch.m. Fix the code so that it correctly handles det switches, which can happen e.g. if we know the possible set of values of the switched-on variable. Use tail-recursive code to handle the list of switch arms, to allow us to handle very large switches. Remove an obsolete comment from the top about a previously implemented optimization. compiler/lookup_util.m: Make set_liveness_and_end_branch update MaybeEnd, to account for the reservation of stack slots for holding the current and last rows in later solutions tables for model_non lookup switches. compiler/switch_util.m: Make the exported predicates of this module more general, making them usable for switches on strings as well as ints. Also make them easier to use. In one case this meant bundling two predicates that were always used together into one predicate. In another, it meant splitting one predicate into two, since some of its callers needed an intermediate result. In the case of a type, it means reordering its fields to make the order match the order of their use in the implementation. Add some predicates specifically for switches on strings. compiler/ml_lookup_switch.m: compiler/ml_string_switch.m: compiler/ml_switch_gen.m: Conform to the changes to switch_util.m. compiler/jumpopt.m: If the comment associated with a label ends with "nofulljump", then inhibit fulljump optimization of jumps to that label. That optimization would replace the jumps with the code starting at that label. This is avoids the overhead of jump instructions, and it is a good idea in the usual case of forward jumps. However, for the few backward jumps we generate, the block that replaces the jump instruction can actually END with the same jump instruction (which may be conditionally executed), which means that our usual repeated invocation of jumpopt can replace the original jump instruction with MANY copies of the block it jumps to. In some cases, such as those in hash switches, you get more copies than can ever be executed in any actual execution. Lookup switches therefore now mark the labels that are targets of backward jumps with this marker. compiler/llds.m: Document the new behavior of jumpopt. compiler/code_info.m: Export a predicate for use in improving the code we generate for lookup switches. Make some other predicates simpler and/or more efficient. compiler/builtin_ops.m: Add a builtin op for doing string comparisons by calling strcmp. This is to prevent the need for two traversals of the strings being compared in each iteration of binary search. compiler/bytecode.m: compiler/c_util.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/llds.m: compiler/llds_to_x86_64.m: Conform to the change in builtin_ops.m. compiler/disj_gen.m: Conform to the change in lookup_util.m compiler/frameopt.m: compiler/proc_gen.m: compiler/unify_gen.m: Take advantage of the change in fulljump optimization. compiler/opt_debug.m: Improve the string representation of rvals by recording the types of the operands of binary operations, and making the output a bit more consistent looking. compiler/dupproc.m: compiler/var_locn.m: Minor style fixes. runtime/mercury_string.h: Add a version of strcmp for use by our code generator. This version casts the arguments before calling the real strcmp. We need it since we usually specify the arguments as r1, r2 etc, which are declared as MR_Word, not char *. tests/hard_coded/lookup_disj.{m,exp}: tests/hard_coded/string_switch.{m,exp}: Make these existing tests significantly tougher by making them exercise a wider range of use scenarios. tests/hard_coded/string_switch{2,3}.{m,exp}: tests/hard_coded/Mercury.options While the string_switch test case tests the handling of jump switches, these two new test cases test the handling of binary search tables and hash tables respectively. Their code is identical to the code of the string_switch test case, but Mercury.options causes them to be compiled with different options. tests/hard_coded/int_switch.{m,exp}: A new test case, equivalent in structure to the string switch test cases, to test the handling of lookup switches on atomic values.	2010-11-01 04:03:06 +00:00
Zoltan Somogyi	bebf7562ba	Fix a performance problem in frameopt. Before this fix, the invocation ... Estimated hours taken: 4 Branches: main Fix a performance problem in frameopt. Before this fix, the invocation of frameopt on one small predicate (mlds_to_java.m's output_interface, in which interface_is_special was inlined) took about 6 seconds out of the compiler's entire runtime of 9.8 seconds, and the only thing frameopt do during those 6 seconds to was decide to change nothing. compiler/frameopt.m: When we decide that a basic block needs a stack frame, store that decision itself, but do NOT store a set of reasons that say WHY the block needs the stack frame. The 6 seconds was almost entirely taken up by the code managing these sets of reasons, because (a) for many blocks, there were many reasons, and (b) the reasons themselves contained other (sets of) reasons, so they were big. compiler/mlds_to_java.m: Improve the style of output_interface. compiler/optimize.m: If the user asks for detail (per-pass) statistics, print them out more frequently. This was needed to diagnose this problem.	2010-07-30 05:32:54 +00:00
Zoltan Somogyi	9bdc5db590	Try to work around the Snow Leopard linker's performance problem with ... Estimated hours taken: 20 Branches: main Try to work around the Snow Leopard linker's performance problem with debug grade object files by greatly reducing the number of symbols needed to represent the debugger's data structures. Specifically, this diff groups all label layouts in a module, each of which previously had its own named global variable, into only a few (one to four) global variables, each of which is an array. References to the old global variables are replaced by references to slots in these arrays. This same treatment could also be applied to other layout structures. However, most layouts are label layouts, so doing just label layouts gets most of the available benefit. When the library and compiler are compiled in grade asm_fast.gc.debug, this diff leads to about a 1.5% increase in the size of their generated C source files (from 338 to 343 Mb), but a more significant reduction (about 17%) in the size of the corresponding object files (from 155 to 128 Mb). This leads to an overall reduction in disk requirements from 493 to 471 Mb (about 4.5%). Since we generate the same code and data as before, with the data just being arranged differently, the decrease in object file sizes is coming from the reduction in relocation information, the information processed by the linker. This should speed up the linker. compiler/layout.m: Make the change described above. We now define up to four arrays: one each for label layouts with and without information about variables, one for the layout structures of user events, and one for the variable number lists of user events. compiler/layout_out.m: Generate the new arrays that the module being compiled needs. Use purpose-specific types instead of booleans. compiler/trace_gen.m: Use a new field in foreign_proc_code instructions to record the identity of any labels whose layout structures we want to refer to, even though layout structures have not been generated yet. The labels will be looked up in a map (generated together with the layout structures) by llds_out.m. compiler/llds.m: Add this extra field to foreign_proc_code instructions. Add the map (which is actually in two parts) to the c_file type, which is the data structure representing the entire LLDS. Also add to the c_file type some other data structures that previously we used to hand around alongside it. Some of these data structures used to conmingle layout structures that we now separate. compiler/stack_layout.m: Generate array slots instead of separate structures for label layouts. Return the different arrays separately. compiler/llds_out.m: Order the output of layout structures to require fewer forward declarations. The forward declarations of the few arrays holding the label layout structures replace a lot of the declarations previously needed. Include the information needed by layout_out.m in the llds_out_info, and conform to the changes above. As a side-effect of all these changes, we now generate proc layout structures in the same order as the procedures' appearence in the HLDS, which is the same as their order in the source code, modulo any procedures added by the compiler itself (for lambdas, unification predicates, etc). compiler/code_info.m: compiler/dupelim.m: compiler/dup_proc.m: compiler/exprn_aux.m: compiler/frameopt.m: compiler/global_data.m: compiler/ite_gen.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_to_x86_64.m: compiler/mercury_compile_llds_back_end.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/pragma_c_gen.m: compiler/proc_gen.m: compiler/reassign.m: compiler/use_local_vars.m: Conform to the changes above. runtime/mercury_goto.h: Add the macros used by the new code in layout_out.m and llds_out.m. We need new macros because the old ones assumed that the C preprocessor can construct the address of a label's layout structure from the name of the label, which is obviously no longer possible. Make even existing families of macros handle in bulk up to 10 labels, up from the previous 8. runtime/mercury_stack_layout.h: Add macros for use by the new code in layout.m. tests/debugger/*.{inp,exp}: tests/debugger/declarative/*.{inp,exp}: Update these test cases to account for the new (and better) order of proc layout structures. Where inputs changed, this was to ensure that we still select the same procedures from lists of procedures, e.g. to put a breakpoint on.	2009-10-21 06:36:37 +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	f60a0ab285	Add a mechanism that can help debug the compiler itself, specifically ... Estimated hours taken: 2 Branches: main Add a mechanism that can help debug the compiler itself, specifically (but not only) the code generator. I used this mechanism a while ago to locate a hard-to-find bug, and it may be useful again in the future. compiler/hlds_desc.m: A new module whose job is to write out goals in a form that is suitable for use in progress messages from compiler passes (the predicates in hlds_out.m write out far too much for this). compiler/hlds.m: compiler/notes/compiler_design.html: Add the new module. compiler/options.m: Add a developer-only option that selects the predicate whose code generation should be traced. compiler/code_gen.m: compiler/code_info.m: compiler/ite_gen.m: Print progress messages if the compiler is compiled with the right compile-time trace flag and the new option says we should. compiler/opt_debug.m: Change the interfaces of the procedures in this module slightly to make them usable in progress messages. compiler/frameopt.m: compiler/optimize.m: Conform to the changes to opt_debug. compiler/ll_backend.m: Fix comments.	2008-11-28 06:37:04 +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
Zoltan Somogyi	b48eaf8073	Add a first draft of the code generator support for region based memory ... Estimated hours taken: 30 Branches: main Add a first draft of the code generator support for region based memory management. It is known to be incomplete; the missing parts are marked by XXXs. It may also be buggy; it will be tested after Quan adds the runtime support, i.e. the C macros invoked by the new LLDS instructions. However, the changes in this diff shouldn't affect non-RBMM operations. compiler/llds.m: Add five new LLDS instructions. Four are specific to RBMM operations. RBMM embeds three new stacks in compiler-reserved temp slots in procedure's usual Mercury stack frames, and the new LLDS instructions respectively (i) push those stack frames onto their respective stacks, (ii) fill some variable parts of those stack frames, (iii) fill fixed slots of those stack frames, and (iv) use the contents of and/or pop those stack frames. (The pushing and popping affect only the new embedded stacks, not the usual Mercury stacks.) The last instruction is a new variant of the old assign instruction. It has identical semantics, but restricts optimization. An assign (a) can be deleted if its target lval is not used, and (b) its target lval can be changed (e.g. to a temp register) as long as all the later instructions referring to that lval are changed to use the new lval instead. Neither is permitted for the new keep_assign instruction. This is required because in an earlier draft we used it to assign to stack variables (parts of the embedded stack frames) that aren't explicitly referred to in later LLDS code, but are nevertheless implicitly referred to by some instructions (specifically iv above). We now use a specialized instruction (iii above) for this (since the macro it invokes can refer to C structure names, this makes it easier to keep the compiler in sync with the runtime system), but given that keep_assign is already implemented, may be useful later and shouldn't cause appreciable slowdown of the compiler, this diff keeps it. Extend the type that describe the contents of lvals to allow it to describe the new kinds of things we can now store in them. Add types to manage and describe the new embedded stack frames, and some utility functions. Change some existing utility functions to make all this more conceptually consistent. compiler/ite_gen.m: Surround the code we generate for the condition of if-then-elses with the code required to ensure that regions that are logically removed in the condition aren't physically destroyed until we know that the condition succeeds (since the region may still be needed in the else branch), and to make sure that if the condition fails, all the memory allocated since the entry into the condition is reclaimed instantly. compiler/disj_gen.m: Surround the code we generate for disjunctions with the code required to ensure that regions that are logically removed in a disjunct aren't physically destroyed if a later disjunct needs them, and to make sure that at entry into a non-first disjunct, all the memory allocated since the entry into the disjunction is reclaimed instantly. compiler/commit_gen.m: compiler/code_info.m: The protection against destruction offered by a disjunction disappears when a commit cuts away all later alternatives in that disjunct, so we must undo that protection. We therefore surround the scope of a commit goal with goal that achieves that objective. Add some new utility predicates to code_info. Remove some old utility functions that are now in llds.m. compiler/continuation_info.m: Extend the type that describe the contents of stack slots to allow it to describe the new kinds of things we can now store in them. Rename the function symbols of that type to eliminate some ambiguities. compiler/code_gen.m: Remember the set of variables live at the start of the goal (before the pre_goal_update updates it), since the region operations need to know this. Leave the lookup of AddTrailOps (and now AddRegionOps) to the specific kinds of goals that need it (the most frequent goals, unify and call, do not). Make both AddTrailOps and AddRegionOps use a self-explanatory type instead of a boolean. compiler/lookup_switch.m: Conform to the change to AddTrailOps. Fix some misleading variable names. compiler/options.m: Add some options to control the number of stack slots needed for various purposes. These have to correspond to the sizes of some C structures in the runtime system. Eventually these will be constants, but it is handy to keep them easily changeable while the C data structures are still being worked on. Add an option for optimizing away region ops whereever possible. The intention is that these should be on all the time, but we will want to turn them off for benchmarking. compiler/dupelim.m: compiler/dupproc.m: compiler/exprn_aux.m: compiler/frameopt.m: compiler/global_data.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/llds_to_x86_64.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/par_conj_gen.m: compiler/reassign.m: compiler/stack_layout.m: compiler/stdlabel.m: compiler/trace_gen.m: compiler/use_local_vars.m: Conform to the changes above, which mostly means handling the new LLDS instructions. In some cases, factor out existing common code, turn if-then-elses into switches, group common cases in switches, rationalize argument orders or variable names, and/or put code in execution order. In reassign.m, fix some old oversights that could (in some unlikely cases) cause bugs in the generated code. compiler/pragma_c_gen.m: Exploit the capabilities of code_info.m. compiler/prog_type.m: Add a utility predicate.	2007-07-31 01:56:41 +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	d66ed699a1	Add fields to structures representing the C code itself that says whether ... Estimated hours taken: 4 Branches: main Add fields to structures representing the C code itself that says whether or not the C code affects the liveness of lvals. This is intended as the basis for future improvements in the optimization of such code. Implement a new foreign_proc attribute that allows programmers to set the value of this field. Eliminate names referring to `pragma c_code' in the LLDS backend in favor of names referring to foreign_procs. compiler/llds.m: Make the changes described above. Consistently put the field containing C code last in the function symbols that contain them. compiler/prog_data.m: Make the changes described above. Rename some other function symbols to avoid ambiguity. compiler/prog_io_pragma.m: Parse the new foreign_proc attribute. doc/reference_manual.texi: Document the new attribute. compiler/pragma_c_gen.m: Rename the main predicates. compiler/opt_util.m: Change some predicates into functions, for more convenient invocation. compiler/livemap.m: Rename the predicates in this module to avoid ambiguity and the need for module qualification. compiler/*.m: Conform to the changes above.	2007-01-03 07:20:47 +00:00
Zoltan Somogyi	b3d4ab1760	For disjunctions in which all disjuncts are just facts, generate code ... Estimated hours taken: 12 Branches: main For disjunctions in which all disjuncts are just facts, generate code that does table lookup. compiler/disj_gen.m: Implement lookup disjunctions. The new code based on the code in lookup_switch.m for generating switches in which some some switch arms are disjunctions. The code we generate is a specialized version we would generate for such switch arms. compiler/lookup_switch.m: compiler/lookup_util.m: Move some predicates from lookup_switch.m to lookup_util.m, to allow disj_gen.m to call them also. Reorder some argument lists to group related arguments together. Give some predicates more descriptive names. In lookup_switch.m, improve some comments. In lookup_util.m, avoid computing ExprnOpts many times. compiler/switch_gen.m: Fix some obsolete some comments. compiler/continuation_info.m: Provide for a description of the stack slot used by the new code in disj_gen.m. compiler/opt_debug.m: Pass a maybe(proc_label) argument to the predicates that dump rvals and things that may contain rvals, so that rvals that are code constants may be printed in the short, user-friendly format (e.g. local_1, instead of the full, usually very long label name). This was helpful in debugging the change to disj_gen.m. Remove the old predicates whose sole purpose was to supply a proc_label for this purpose (e.g. dump_label_for_proc), since now even the predicates they are based on (e.g. dump_label) can now be given a proc_label. compiler/frameopt.m: compiler/use_local_vars.m: compiler/switch_gen.m: Conform to the change to opt_debug.m. tests/hard_coded/lookup_disj.{m,exp}: New test case to test the handling of the lookup tables. Existing test cases, specifically do_while, nasty_nondet, and nondet_ite* in general, and pretty_printing in hard_coded, are already tough tests of the handling of the code generator's internal data structures (such as the failure stack and the set of reserved stack slots). tests/hard_coded/Mmakefile: Enable the new test case.	2006-12-11 04:10:46 +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	ecf1ee3117	Add a mechanism for growing the stacks on demand by adding new segments ... Estimated hours taken: 20 Branches: main Add a mechanism for growing the stacks on demand by adding new segments to them. You can ask for the new mechanism via a new grade component, stseg (short for "stack segments"). The mechanism works by adding a test to each increment of a stack pointer (sp or maxfr). If the test indicates that we are about to run out of stack, we allocate a new stack segment, allocate a placeholder frame on the new segment, and then allocate the frame we wanted in the first place on top of the placeholder. We also override succip to make it point code that will (1) release the new segment when the newly created stack frame returns, and then (2) go to the place indicated by the original, overridden succip. For leaf procedures on the det stack, we optimize away the check of the stack pointer. We can do this because we reserve some space on each stack for the use of such stack frames. My intention is that doc/user_guide.texi and NEWS will be updated once we have used the feature ourselves for a while and it seems to be stable. runtime/mercury_grade.h: Add the new grade component. runtime/mercury_conf_param.h: Document the new grade component, and the option used to debug stack segments. runtime/mercury_context.[ch]: Add new fields to contexts to hold the list of previous segments of the det and nondet stacks. runtime/mercury_memory_zones.[ch]: Include a threshold in all zones, for use in stack segments. Set it when a zone is allocated. Restore the previous #ifdef'd out function MR_unget_zone, for use when freeing stack segments execution has fallen out of. runtime/mercury_debug.[ch]: When printing the offsets of pointers into the det and nondet stacks, print the number of the segment the pointer points into (unless it is the first, in which case we suppress this in the interest of brevity and simplicity). Make all the functions in this module take a FILE * as an input argument; don't print to stdout by default. runtime/mercury_stacks.[ch]: Modify the macros that allocate stack frames to invoke the code for adding new stack segments when we are about to run out of stack. Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. Conform to the changes in mercury_debug.c. runtime/mercury_stack_trace.c: When traversing the stack, step over the placeholder stack frames at the bottoms of stack segments. Conform to the changes in mercury_debug.c. runtime/mercury_wrapper.[ch]: Make the default stack size small in grades that support stack segments. Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. Conform to the changes in mercury_debug.c. runtime/mercury_memory.c: Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. runtime/mercury_engine.[ch]: runtime/mercury_overflow.h: Standardize on "nondet" over "nond" as the abbreviation referring to the nondet stack. Convert these files to four-space indentation. runtime/mercury_minimal_model.c: trace/mercury_trace.c: trace/mercury_trace_util.c: Conform to the changes in mercury_debug.c. compiler/options.m: Add the new grade option for stack segments. compiler/compile_target_code.m: compiler/handle_options.m: Add the new grade component, and handle its exclusions with other grade components and optimizations. compiler/llds.m: Extend the incr_sp instruction to record whether the stack frame is for a leaf procedure. compiler/llds_out.m: Output the extended incr_sp instruction. compiler/proc_gen.m: Fill in the extra slot in incr_sp instructions. compiler/goal_util.m: Provide a predicate for testing whether a procedure body is a leaf. compiler/delay_slot.m: compiler/dupelim.m: compiler/dupproc.m: compiler/exprn_aux.m: compiler/frameopt.m: compiler/global_data.m: compiler/jumpopt.m: compiler/middle_rec.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/peephole.m: compiler/reassign.m: compiler/use_local_vars.m: Conform to the change in llds.m. scripts/canonicate_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: scripts/final_grade_options.sh-subr: scripts/mgnuc.in: Handle the new grade component. Convert parse_grade_options.sh-subr to four-space indentation. Mmake.workspace: Fix an old bug that prevented bootcheck from working in the new grade: when computing the gc grade, use the workspace's version of ml (which in this case understands the new grade components), rather than the installed ml (which does not). (This was a devil to track down, because neither make --debug nor strace on make revealed how the installed ml was being invoked, and there was no explicit invocation in the Makefile either; the error message appeared to come out of thin air just before the completion of the stage 2 library. It turned out the invocation happened implicitly, as a result of expanding a make variable.)	2006-11-01 02:31:19 +00:00
Zoltan Somogyi	e21193c283	Rename a bunch of predicates and function symbols to eliminate ... Estimated hours taken: 6 Branches: main browser/*.m: compiler/*.m: Rename a bunch of predicates and function symbols to eliminate ambiguities. The only real change is factoring out some common code in the mlds and llds code generators, replacing them with single definitions in switch_util.m.	2006-10-15 23:26:56 +00:00
Zoltan Somogyi	f9cac21e3e	Get rid of a bunch more ambiguities by renaming predicates, mostly ... Estimated hours taken: 8 Branches: main Get rid of a bunch more ambiguities by renaming predicates, mostly in polymorphism.m, {abstract,build,ordering}_mode_constraints.m, prog_type.m, and opt_debug.m in the compiler directory and term_io.m, term.m, parser.m, and string.m in the library. In some cases, when the library and the compiler defined the same predicate with the same code, delete the compiler's copy and give it access to the library's definition by exporting the relevant predicate (in the undocumented part of the library module's interface). NEWS: Mention that the names of some library functions have changed. library/*.m: compiler/*.m: mdbcomp/*.m: browser/*.m: Make the changes mentioned above, and conform to them. test/general/string_test.m: test/hard_coded/string_strip.m: test/hard_coded/string_strip.exp: Conform to the above changes.	2006-09-20 09:42:28 +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	469f1dc09b	This diff contains no algorithmic changes. ... Estimated hours taken: 1.5 Branches: main This diff contains no algorithmic changes. compiler/llds.m: compiler/mlds.m: Rename some function symbols and field names to avoid ambiguities with respect to language keywords. compiler/*.m: Conform to the changes in llds.m and mlds.m.	2006-07-28 05:08:15 +00:00
Zoltan Somogyi	d5d5986472	Implement lookup switches in which a switch arm may contain more than one ... Estimated hours taken: 40 Branches: main Implement lookup switches in which a switch arm may contain more than one solution, such as this code here: p(d, "four", f1, 4.4). p(e, "five", f2, 5.5). p(e, "five2", f3(5), 55.5). p(f, "six", f4("hex"), 6.6). p(g, "seven", f5(77.7), 7.7). p(g, "seven2", f1, 777.7). p(g, "seven3", f2, 7777.7). Such code occurs frequently in benchmark programs used to evaluate the performance of tabled logic programming systems. Change frameopt.m, which previously worked only on det and semidet code, to also work for nondet code. For predicates such as the one above, frameopt can now arrange for the predicate's nondet stack frame to be created only when a switch arm that has more than one solution is selected. compiler/lookup_switch.m: Extend the existing code for recognizing and implementing lookup switches to recognize and implement them even if they are model_non. compiler/lookup_util.m: New module containing utility predicates useful for implementing both lookup switches, and in the future, lookup disjunctions (i.e. disjunctions that correspond to a nondet arm of a lookup switch). compiler/ll_backend.m: Include the new module. compiler/notes/compiler_design.html: Mention the new module. compiler/global_data.m: Move the job of filling in dummy slots to our caller, in this case lookup_switch.m. compiler/frameopt.m: Generalize the existing code for delaying stack frame creation, which worked only on predicates that live on the det stack, to work also on predicates that live on the nondet stack. Without this, predicates whose bodies are model_non lookup switches would create a nonstack stack frame before the switch is ever entered, which is wasteful if the selected switch arm has at most one solution. Since the structure of model_non predicates is more complex (you can cause a branch to a label by storing its address in a redoip slot, you can succeed from the frame without removing the frame), this required considerable extra work. To make the new code debuggable, record, for each basic block that needs a stack frame, *why* it needs that stack frame. compiler/opt_util.m: Be more conservative about what refers to the stack. Export some previously internal functionality for frameopt. Turn some predicates into functions, and rename them to better reflect their purpose. compiler/opt_debug.m: Print much more information about pragma_c and call LLDS instructions. compiler/prog_data.m: Add an extra attribute to foreign_procs that says that the code of the foreign_proc assumes the existence of a stack frame. This is needed to avoid frameopt optimizing the stack frame away. compiler/add_pragma.m: When processing fact tables, we create foreign_procs that assume the existence of the stack frame, so set the new attribute. compiler/pragma_c_gen.m: When processing foreign_procs, transmit the information in the attribute to the generated LLDS code. compiler/llds.m: Rename the function symbols referring to the fixed slots in nondet stack frames to make them clearer and to avoid overloading function symbols such as curfr and succip. Rename the function symbols of the call_model type to avoid overloading the function symbols of the code_model type. Add a new field to the c_procedure type giving the code_model of the procedure, and give names to all the fields. Describe the stack slots used by lookup switches to the debugger and native gc. compiler/options.m: doc/user_guide.texi: Add a new option, --debug-opt-pred-name, that does when the existing --debug-opt-pred-id options does, but taking a user-friendly predicate name rather than a pred_id as its argument. compiler/handle_options.m: Process --debug-opt-pred-name, and make --frameopt-comments imply --auto-comments, since it is not useful without it. Reformat some existing comments that were written in the days of 8-space indentation. compiler/optimize.m: Implement the new option. Use the new field of the c_procedure type to try only the version of frameopt appropriate for the code model of the current procedure. Do a peephole pass after frameopt, since frameopt can generate code sequences that peephole can optimize. Make the mechanism for recording the process of optimizing procedure bodies more easily usable by including the name of the optimization that created a given version of the code in the name of the file that contains that version of the code, and ensuring that all numbers are two characters long, so that "vi procname*.opt*" looks at the relevant files in the proper chronological sequence, instead of having version 11 appear before version 2. compiler/peephole.m: Add a new optimization pattern: a "mkframe, goto fail" pair (which can be generated by frameopt) should be replaced by a simple "goto redo". compiler/code_gen.m: Factor out some common code. compiler/llds_out.m: Ensure that C comments nested inside comment(_) LLDS instructions aren't emitted as nested C comments, since C compilers cannot handle these. compiler/code_info.m: compiler/code_util.m: compiler/continuation_info.m: compiler/dupelim.m: compiler/exprn_aux.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/mercury_compile.m: compiler/middle_rec.m: compiler/ml_code_gen.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/peephole.m: compiler/stack_layout.m: compiler/transform_llds.m: compiler/var_locn.m: Conform to the change to prog_data.m, opt_util.m and/or llds.m. compiler/handle_options.m: Don't execute the code in stdlabel.m if doing so would cause a compiler abort. tests/hard_coded/dense_lookup_switch_non.{m,exp}: New test case to exercise the new algorithm. tests/hard_coded/Mmakefile: Enable the new test case. tests/hard_coded/cycles.m: Make this test case conform to our coding convention.	2006-04-26 03:06:29 +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	3ebda6545f	Move the stuff currently in hlds_pred.m that deals with clauses into a new ... Estimated hours taken: 1.5 Branches: main Move the stuff currently in hlds_pred.m that deals with clauses into a new module, hlds_clauses.m. Move the stuff currently in hlds_pred.m that deals with RTTI into a new module, hlds_rtti.m. Move the stuff currently in hlds_module.m that deals with predicate tables into a new module, pred_table.m. These changes make hlds_pred.m and hlds_module.m much more cohesive, but there are no changes in algorithms. compiler/hlds_clauses.m: compiler/hlds_rtti.m: compiler/pred_table.m: New modules as described above. In some cases, fix mixleading or ambiguous predicate names in the process, and convert a few predicates to functions. compiler/hlds_pred.m: compiler/hlds_module.m: Delete the stuff moved to other modules. compiler/*.m: In modules that need the functionality moved a new module, import the new module. It is rare for all the new modules to be needed, and many modules don't need any of the new modules at all. (For example, of the 200+ modules that import hlds_module.m, only about 40 need pred_table.m.) Conform to the few minor changes to e.g. predicate names. compiler/notes/compiler_design.html: Document the new modules.	2006-03-24 03:04:20 +00:00
Zoltan Somogyi	be5b71861b	Convert almost all the compiler modules to use . instead of __ as ... Estimated hours taken: 6 Branches: main compiler/*.m: Convert almost all the compiler modules to use . instead of __ as the module qualifier. In some cases, change the names of predicates and types to make them meaningful without the module qualifier. In particular, most of the types that used to be referred to with an "mlds__" prefix have been changed to have a "mlds_" prefix instead of changing the prefix to "mlds.". There are no algorithmic changes.	2006-03-17 01:40:46 +00:00
Julien Fischer	45fdb6c451	Use expect/3 in place of require/2 throughout most of the ... Estimated hours taken: 4 Branches: main compiler/*.m: Use expect/3 in place of require/2 throughout most of the compiler. Use unexpected/2 (or sorry/2) in place of error/1 in more places. Fix more dodgy assertion error messages. s/map(prog_var, mer_type)/vartypes/ where the latter is meant.	2005-11-28 04:11:59 +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	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	9dd20a42e9	By optimizing away frames in some frequently used predicates such as ... Estimated hours taken: 1 Branches: main By optimizing away frames in some frequently used predicates such as tree234__search and list__member, this diff speeds up the compiler by 0.5%. compiler/frameopt.m: Previously, if the procedure had any tail calls to itself, we always kept the procedure's stack frame, preferring to optimize away the stack frame teardown just before the tail call and the stack frame allocation just after it. However, there is no point in doing this transformation if none of the procedure's blocks actually needs a stack frame, so after this diff, in such situations we will now optimize the frame away. Ideally, if a procedure (such as the deriv benchmark) has (1) some paths through it that don't need a stack frame, AND (2) some paths through it that do need a stack frame and jump back to the start of the procedure, making it profitable to reuse the stack frame, we should do something (such as duplicating the procedure body) to make both possible. However, that is future work.	2005-09-09 02:43:09 +00:00
Zoltan Somogyi	f0dbbcaa34	Generate better code for base relations such as the ones in the transitive ... Estimated hours taken: 16 Branches: main Generate better code for base relations such as the ones in the transitive closure benchmarkings in the paper on minimal model tabling. These improvements yield speedups ranging from 5 to 25% on those benchmarks. compiler/use_local_vars.m: Make this optimization operate on extended basic blocks instead of plain basic blocks. The greater length of extended basic blocks allows the local variables to have maximum scope possible. The price is that the test for whether assignment to a given lvalue can be avoided or not is now dependent on which of the constituent basic blocks of extended basic block contains the assignment, and thus the test has to be evaluate once for each assignment we try to optimize instead of once per block. Don't allocate temporary variables if the optimization they are intended for turns out not to be allowed. This change avoids having declarations for unused temporary variables in the resulting C code. If --auto-comments is set, insert use_local_vars.m's main data structure, the livemap, into the generated LLDS code as a comment. compiler/peephole.m: Look for the pattern mkframe(Size, Redoip) <straight line instructions that don't use stack slots> succeed and optimize away the mkframe. This pattern always arises for procedures that are actually semidet but are declared nondet (such as the base relations in the tabling benchmarks), and may also arise for semidet branches of nondet procedures. compiler/llds.m: Allow an existing peephole pattern to work better. The pattern is mkframe(Seize, do_fail) <straight line instructions> redoip(curfr) = Redoip Previously, if some compiler-generated C code was among the straight line instructions, the pattern couldn't be applied, since peephole.m couldn't know whether it branched away through the redoip slot of the frame. This diff adds an extra slot to the relevant pragma_c component that tells peephole.m (actually, the predicate in opt_util.m that peephole relies on) whether this is the case. compiler/basic_block.m: Provide functionality for merging basic blocks into extended basic blocks. compiler/dupelim.m: Conform to the change in basic_block.m's interface. Convert to four-space indentation, and fix departures from our style guidelines. compiler/opt_util.m: Provide extra information now needed by use_local_vars. Convert to four-space indentation, and fix departures from our style guidelines. compiler/opt_debug.m: Show the user friendly versions of label names when dumping livemaps and instructions. Shorten the dumped descriptions of registers and stack slots. Dump instructions inside blocks. compiler/frameopt.m: Conform to the changes in opt_util and opt_debug's interfaces. compiler/optimize.m: Use the facilities of opt_debug instead of llds_out when dumping the LLDS after each optimization, since these are now more compact and thus reader friendly. Print unmangled names when writing progress messages. Put the dump files we generate with --opt-debug in a separate subdirectory, since when compiling e.g. tree234.m, the process can generate more than a thousand files. Give the dump files minimally mangled names. compiler/code_gen.m: compiler/pragma_c_gen.m: Convert to four-space indentation, and fix departures from our style guidelines. Conform to the change in llds.m. compiler/code_info.m: compiler/exprn_aux.m: compiler/ite_gen.m: compiler/jumpopt.m: compiler/livemap.m: compiler/llds_out.m: compiler/middle_rec.m: compiler/trace.m: Conform to the change in llds.m.	2005-09-07 06:51:57 +00:00
Zoltan Somogyi	828d969e67	Significantly improve the capabilities of the LLDS optimization that tries ... Estimated hours taken: 20 Branches: main Significantly improve the capabilities of the LLDS optimization that tries to delay the creation of the stack frame, in the hope that on some computation paths the frame won't need to be created at all. Previously, the delayed setup of the stack frame could take place only when a block without a stack frame fell through to a block that needed a stack frame. If block B1 jumped to another block B2 that needed a frame, this was taken as meaning that B1 also had to have a frame. This was a problem, because if B1 ends with a computed goto, some of whose targets need stack frames and some do not, this limitation effectively gave all of them a stack frame, whether they wanted it or not, and thus required them to execute the stack frame teardown code. This diff removes the limitation, optimization allows B1 in this case to not have a stack frame. Instead of jumping to B2, B1 will not jump to a label B3 it inserts immediately before B2, the code at B3 setting up the stack frame and falling through to B2. (We also insert code to jump around B3 if the code immediately preceding it could fall into it accidentally.) The new code in frameopt is conceptually cleaner than it was before, because we now handle transitions from blocks that don't have a stack stack to blocks that do in a much more uniform manner. Most of the changes to other modules are to make the change to frameopt.m easier to debug. The motivation for the change was that we were beaten by YAP (Yet Another Prolog) on the deriv benchmark due to the limitation of frameopt. I haven't measured against YAP yet, but the runtime for 1.5 million iterations has been reduced from about 20 seconds to about 13. Since the compiler doesn't have any predicates that are both frequently used and can benefit from the removal of that old limitation (which is why the limitation wasn't really noticed before), there is no measurable effect on the speed of the compiler itself. compiler/frameopt.m: Effectively rewrite the optimization that delays stack frame creation along the lines above. The code for the optimization that keeps the stack frame for recursive calls if possible is unaffected. If the new option --frameopt-comments is specified, insert into the generated LLDS code a nicely formatted description of the main frameopt.m data structures. These are much easier to read that the term browser in the debugger. compiler/options.m: Add the new developer-only option --frameopt-comments. compiler/llds_out.m: Change the way we output comments to make the coments generated by frameopt.m easier to read. (We output comments only if --auto-comments is given, which it usually isn't.) compiler/opt_debug.m: Provide the functionality of printing local labels in an easier-to-read form that doesn't repeat the (possibly long) procedure name. Local labels can now be printed as e.g. local_15. Rewrite the module to use functions instead of predicates for appending strings, since this makes the code shorter, easier to use and to read. The original code was written before Mercury had functions. compiler/switch_util.m: When gathering information about switches, return the cons_id with each goal. Switch to four-space indentation. compiler/tag_switch.m: When generating code for switches, insert a comment at the start of each case saying what cons_id it is for, using the new information from switch_util. This is to make the generated code easier to understand. Switch to four-space indentation. compiler/ml_tag_switch.m: Conform to the change in switch_util. compiler/optimize.m: Conform to the slightly modified interface of frameopt.m. Switch to four-space indentation. compiler/peephole.m: Switch to four-space indentation, and fix some coding style issues. compiler/basic_block.m: When dividing a procedure body into basic blocks, remember for each block whether it could be fallen into. This modification is not strictly required for this change, since frameopt has its own (specialized) code for creating basic blocks, but it could be useful in the future. compiler/dupelim.m: compiler/use_local_vars.m: Conform to the change in basic_block.m.	2005-08-25 03:19:48 +00:00
Zoltan Somogyi	36c78eaf98	Conform to the standard format for comments. ... Estimated hours taken: 0.1 Branches: main compiler/frameopt.m: Conform to the standard format for comments. Change to four-space indentation to reduce the number of bad line breaks. There are no algorithmic changes.	2005-08-05 05:01:30 +00:00
Zoltan Somogyi	c08ca7fbc8	Import only one module per line in the modules of the compiler ... Estimated hours taken: 3 Branches: main compiler/*.m: Import only one module per line in the modules of the compiler where my previous diff did not already do so. Misc other cleanups. Where relevant, use the new mechanism in tree.m. compiler/tree.m: Fix a performance problem I noticed while update :- import_module items. Instead of supplying a function to convert lists of trees to a tree, make the tree data structure able to hold a list of subtrees directly. This reduces the number of times where we have to convert list of trees to trees that are sticks just to stay within the old definition of what a tree is.	2005-03-24 02:00:43 +00:00
Peter Wang	59d2d4a573	This adds a module mdbcomp__trace_counts that reads in the ... Estimated hours taken: 17 Branches: main This adds a module mdbcomp__trace_counts that reads in the .mercury_trace_counts files produced by the compiler's trace mechanism. The format of said files was slightly changed. As the new module is to be used by the compiler and the debugger, it is placed in the mdbcomp module. This required bringing some types from the compiler into a new module within mdbcomp. browser/trace_counts.m: New module for reading execution trace summaries. browser/prim_data.m: New module holding types and predicates moved in from the compiler. Types: pred_or_func, sym_name, module_name, proc_label, special_pred_id, trace_port Predicates: string_to_sym_name, insert_module_qualifier The mode field of proc_label is now an int instead of a proc_id to avoid pulling proc_id into mdbcomp. browser/mdbcomp.m: Add trace_counts and prim_data to the mdbcomp module. browser/declarative_execution.m: Renamed mdb's definition of module_name to flat_module_name to avoid conflicts with the definition in mdbcomp__prim_data. runtime/mercury_trace_base.c: In the format of .mercury_trace_counts, write module and predicate names now use quoted atom syntax so that names with spaces and non-printable characters can be machine-parsed. browser/: compiler/: Many changes to account for movement of types, and the change to proc_label.	2005-01-19 03:11:22 +00:00
Zoltan Somogyi	885fd4a387	Remove almost all dependencies by the modules of parse_tree.m on the modules ... Estimated hours taken: 12 Branches: main Remove almost all dependencies by the modules of parse_tree.m on the modules of hlds.m. The only such dependencies remaining now are on type_util.m. compiler/hlds_data.m: compiler/prog_data.m: Move the cons_id type from hlds_data to prog_data, since several parts of the parse tree data structure depend on it (particularly insts). Remove the need to import HLDS modules in prog_data.m by making the cons_ids that refer to procedure ids refer to them via a new type that contains shrouded pred_ids and proc_ids. Since pred_ids and proc_ids are abstract types in hlds_data, add predicates to hlds_data to shroud and unshroud them. Also move some other types, e.g. mode_id and class_id, from hlds_data to prog_data. compiler/hlds_data.m: compiler/prog_util.m: Move predicates for manipulating cons_ids from hlds_data to prog_util. compiler/inst.m: compiler/prog_data.m: Move the contents of inst.m to prog_data.m, since that is where it belongs, and since doing so eliminates a circular dependency. The separation doesn't serve any purpose any more, since we don't need to import hlds_data.m anymore to get access to the cons_id type. compiler/mode_util.m: compiler/prog_mode.m: compiler/parse_tree.m: Move the predicates in mode_util that don't depend on the HLDS to a new module prog_mode, which is part of parse_tree.m. compiler/notes/compiler_design.m: Mention prog_mode.m, and delete the mention of inst.m. compiler/mercury_to_mercury.m: compiler/hlds_out.m: Move the predicates that depend on HLDS out of mercury_to_mercury.m to hlds_out.m. Export from mercury_to_mercury.m the predicates needed by the moved predicates. compiler/hlds_out.m: compiler/prog_out.m: Move predicates for printing parts of the parse tree out of hlds_out.m to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/purity.m: compiler/prog_out.m: Move predicates for printing purities from purity.m, which is part of check_hlds.m, to prog_out.m, since mercury_to_mercury.m needs to use them. compiler/passes_aux.m: compiler/prog_out.m: Move some utility predicates (e.g. for printing progress messages) from passes_aux.m to prog_out.m, since some predicates in submodules of parse_tree.m need to use them. compiler/foreign.m: compiler/prog_data.m: Move some types from foreign.m to prog_data.m to allow the elimination of some dependencies on foreign.m from submodules of parse_tree.m. compiler/*.m: Conform to the changes above, mostly by updating lists of imported modules and module qualifications. In some cases, also do some local cleanups such as converting predicate declarations to predmode syntax and fixing white space.	2004-06-14 04:17:03 +00:00