Minor cleanups before work on bug 311.

compiler/delay_partial_inst.m:
    Avoid unnecessarily splitting a predicate in two.

    Eliminate a number of unnecessary accesses and updates to the module
    info.

    Return the list of changed pred ids in order.

    Add conditional trace goals to write out procedure bodies
    if this pass changes them.
Add the fused multiply-add operation to the math module.

Support the fused multiply-add operation in C grades, where the underlying math
library provides it.  Add a predicate that allows program to test for the
presence of this operation.
(The non-C target languages do not currently provide this operation.)

library/math.m:
	Add the function fma/3.

	Add the predicate have_fma/0 which can be used to test for the
	presence of fma operation in the current grade / platform.

configure.ac:
runtime/mercury_conf.h.in:
	Check whether the C99 fma() function is available.

NEWS:
	Announce the above.
Replace simplify.m (which had 4500 lines) with several submodules.

The objective of this change is to improve module cohesion, with each
of the new modules doing only one task, or two or three closely related tasks.
Moving common.m into the new simplify package also improves information hiding,
since the details of the simplify_info data structure that common.m needs
aren't exposed to the rest of the compiler anymore.

This change mostly moves code around. There are no algorithmic changes.
In several places I did

- make predicate names more meaningful,
- reordered predicate definitions to put related predicates together
  (previously, the predicates involved in simplifying a particular kind of goal
  were often interspersed with predicates that worked only on other kinds of
  goals), and
- improved documentation (in some places expanding it, in some places
  correcting comments that suffered bit-rot and were out-of-date).

compiler/simplify.m:
    This file is now a package, including its submodules,
    but no code anymore.

compiler/simplify_goal.m:
    New submodule containing generic processing of goals.

compiler/simplify_goal_call.m:
compiler/simplify_goal_unify.m:
compiler/simplify_goal_conj.m:
compiler/simplify_goal_disj.m:
compiler/simplify_goal_switch.m:
compiler/simplify_goal_ite.m:
compiler/simplify_goal_scope.m:
    New submodules containing goal-type-specific processing of goals.
    Each of these modules is much more cohesive than the original simplify.m
    ever was; most export only one predicate per handled goal type.

compiler/simplify_info.m:
    New submodule containing the definition of simplify_info
    and its access predicates.

compiler/simplify_tasks.m:
    New submodule listing the tasks that the simplification pass
    may be asked to perform.

compiler/simplify_proc.m:
    New submodule containing the top-level processing of procedures.

compiler/common.m:
    Make this module a part of the simplify package. It is only ever invoked
    by simplification, and leaving it outside the package would require
    exporting more than a few internal details of simplify_info.

compiler/format_call.m:
    Make this module a part of the simplify package. It does its job during
    simplification, even though the need for it is noted during determinism
    analysis.

compiler/check_hlds.m:
    Remove common.m and format_call.m from the list of direct submodules
    of check_hlds.m. (They are now indirect submodules, through
    check_hlds.simplify.)

compiler/notes/compiler_design.html:
    Document the new modules, and the new status of common and format_call..

compiler/pd_util.m:
    Move some code from here to the new simplify_proc.m, since it allows us
    to avoid exposing internal details of how simplification works.

compiler/mercury_compile_front_end.m:
    Move a predicate here from the old simplify.m, since the job it does
    belongs here.

    Remove the ability to disable the invocation of cse_detection.
    This capability was only ever needed when measuring the effectiveness
    of determinism analysis for a paper; it hasn't been needed in a decade.

compiler/cse_detection.m:
    Improve the top level comment.

compiler/options.m:
doc/user_guide.texi:
    Remove the option that used to control the invocation of cse_detection.

compiler/*.m:
    Conform to the split of simplify.m, importing its submodules where needed.
Add thread_safe attribute to store procedures.

The mutvar procedures are not truly thread-safe but neither does
obtaining a global lock make them become thread-safe in a useful way,
except perhaps avoiding data races.  On the other hand, the global lock
inhibits parallelism in programs that do use mutvars in a thread-safe
manner.

library/store.m:
	As above.

NEWS:
	Announce change.
Use mutvar in benchmarking.

library/benchmarking.m:
	Use store mutvar type in `benchmark_nondet_loop'.

	Delete redundant implementation of a reference type.
Add thread_safe and not_thread_safe attributes.

library/benchmarking.m:
library/bit_buffer.m:
library/exception.m:
library/gc.m:
library/io.m:
library/library.m:
library/thread.m:
library/time.m:
	Add `thread_safe' or `not_thread_safe' to foreign procs
	where it is clear which is correct.
Delete unused type io.stream_putback.

library/io.m:
	As above.
Fix type of MR_compare_tuple_pred for high-level C grades.

runtime/mercury_ho_call.h:
	Fix the type of MR_compare_tuple_pred function pointer
	for high-level C grades.
Put "task" in the name of the types that define simplify's tasks.

compiler/simplify_tasks.m:
    As above.

compiler/*.m:
    Conform to the change to simplify_tasks.m.
Simplify the code that simplifies conjunctions.

compiler/simplify_conj.m:
    As above. Use a cord to store the sequence of already processed conjuncts,
    instead of reversing and rereversing lists of goals. (The original code
    was written before cords were available.)
Do not hardcode quoting style in error messages.

Replace spots in error message specs. where single quotes are hardcoded as `' with
the error_util library's quote/1 constructor.

Fix minor issues with some error messages and add a couple of XXX comments
about some others.

compiler/accumulator.m:
compiler/add_clause.m:
compiler/add_pragma.m:
compiler/add_pred.m:
compiler/add_type.m:
compiler/det_analysis.m:
compiler/det_report.m:
compiler/goal_expr_to_goal.m:
compiler/make_hlds_error.m:
compiler/mercury_compile.m:
compiler/mode_errors.m:
compiler/modes.m:
compiler/modules.m:
compiler/options_file.m:
compiler/post_typecheck.m:
compiler/prog_io.m:
compiler/prog_io_pragma.m:
compiler/simplify_goal.m:
compiler/simplify_proc.m:
compiler/term_constr_errors.m:
compiler/term_errors.m:
compiler/termination.m:
compiler/typecheck.m:
compiler/typecheck_errors.m:
	As above.

tests/invalid/errors.err_exp:
tests/invalid/missing_det_decl.err_exp:
tests/invalid/no_exports.err_exp:
tests/invalid/predmode.err_exp:
tests/invalid/undef_type.err_exp:
	Conform to the above changes.
Changes that function as a post-commit review of Julien's previous change.

compiler/add_clause.m:
compiler/det_report.m:
compiler/mode_errors.m:
compiler/modes.m:
    Use the sym_name_and_arity format component where appropriate.

compiler/term_constr_errors.m:
    Fix whitespace.

tests/invalid/invalid_main.err_exp:
    Conform to the above.
Use mmap for Boehm GC in threaded grades on Linux.

The glibc implementation of malloc (commonly used on Linux) can use sbrk
to acquire more memory, and so does Boehm GC in its default configuration
on Linux.  When both allocators are invoked simultaneously from different
threads then memory corruption may result.

configure.ac:
	Add --enable-gc-mmap option.

	Make --enable-gc-munmap imply --enable-gc-mmap.

	Detect mmap and set MR_HAVE_MMAP.

	Detect sbrk and set MR_HAVE_SBRK.

	On Linux (and potentially other platforms), build Boehm GC for
	threaded grades with -DUSE_MMAP if mmap was found.

Mmake.common.in:
	Add ENABLE_BOEHM_USE_MMAP.

runtime/mercury_conf.h.in:
	Add MR_HAVE_MMAP, although it is not used anywhere yet.

	Add MR_HAVE_SBRK.  It is only for used by the test program.

tests/hard_coded/Mmakefile:
tests/hard_coded/thread_sbrk.exp:
tests/hard_coded/thread_sbrk.exp2:
tests/hard_coded/thread_sbrk.m:
	Add test program.

NEWS:
	Announce changes.
Delete the LLDS->x86_64 asm backend.

No progress has been made on the LLDS->x86_64 backend since the initial work on
it and it is now more have a maintenance headache then anything else.

compiler/llds_to_x86_64.m:
compiler/llds_to_x86_64_out.m:
compiler/x86_64_instrs.m:
compiler/x86_64_out.m:
compiler/x86_64_regs.m:
	Delete these modules.

compiler/globals.m:
	Delete the x86_64 target type.

compiler/*.m:
	Conform to the above changes.
Improve consistency of error and warning messages.

Add two new format components to the error_util library: decl/1 and
pragma_decl/1.  These are converted into strings as follows:

   decl(<Decl>)        ==> `:- <Decl>'
   pragma_decl(<Decl>) ==> `:- pragma <Decl>'

The motivation for this change is that error messages about declarations
often contain text similar to:

    ... in `:- foo' declaration ...

At least that is what occurs most of the time; in some cases the `:-' part is
omitted, in other cases the quotes are omitted.  Using the new format
components makes these consistency problems less likely to occur.  The error
specs are also more concise as well.

This commit also addresses a number of other minor issues related to error.

compiler/error_util.m:
	Add the two new format components describe above.

	Use add_quotes/1 as a single point of control for how single quotes
	are added where possible in this module.

	Call unexpected/3 in preference to error/1.

compiler/goal_expr_to_goal.m;
	Quote the word 'else' when referring the 'else' part of a try goal
	in an error message.

compiler/hlds_out_util.m:
	Add an XXX comment about cons_ids being incorrectly quoted in
	error messages.

compiler/det_report.m:
	Pass the message description to report_determinism_problem/7 as a list
	of format_components rather than as a string.

compiler/make_hlds_warn.m:
	Capitalize the word "Warning" when it occurs at the beginning of a warning.

compiler/typecheck_errors.m:
compiler/modules.m:
	Fix problems I noticed during my previous change.

compiler/add_pragma.m:
compiler/add_type.m:
compiler/det_analysis.m:
compiler/make_hlds_passes.m:
compiler/modules.m:
compiler/oisu_check.m:
compiler/prog_io.m:
compiler/prog_io_mode_defn.m:
compiler/prog_io_mutable.m:
compiler/prog_io_pragma.m:
compiler/prog_io_sym_name.m:
compiler/term_constr_errors.m:
compiler/term_errors.m
compiler/termination.m:
compiler/typecheck_errors.m:
	Conform to the above changes.

tests/invalid/bad_finalise_decl.err_exp:
tests/invalid/bad_initialise_decl.err_exp:
tests/invalid/bad_mutable.err_exp:
tests/invalid/bug83.err_exp:
tests/invalid/ee_invalid.err_exp:
tests/invalid/foreign_enum_import.err_exp:
tests/invalid/foreign_enum_invalid.err_exp:
tests/invalid/foreign_type_missing.err_exp:
tests/invalid/hawkins_mm_fail_reset.err_exp:
tests/invalid/loopcheck.err_exp:
tests/invalid/nested_impl_in_int.err_exp:
tests/invalid/oisu_check_add_pragma_errors.err_exp:
tests/invalid/oisu_check_semantic_errors.err_exp:
tests/invalid/reserve_tag.err_exp:
tests/invalid/try_io_else.err_exp:
tests/warnings/foreign_term_invalid.exp:
tests/warnings/warn_return.exp*:
tests/warnings/warn_succ_ind.exp*:
	Update expected (error) outputs to conform to the above.
Fix mantis bug 311.

compiler/simplify_goal_disj.m:
    Look for the conditions that lead to the bug (a disjunction that
    further instantiates an already partially instantiated variable).
    Generate an error message when found, PROVIDED that this happens
    in a context in which the surrounding procedure can succeed
    more than once. (If it cannot, then you cannot invoke an all-solutions
    predicate on it, and the bug cannot happen.)

    This condition (a model_non surrounding procedure) was motivated
    by mdbcomp/feedback.m, which does not compile without it.

compiler/simplify_info.m:
    The simplify_info type used to contain four different kinds of fields:

    1 static fields; set and then never changed, such as the id of the
      containing procedure
    2 global information, such as the varset and vartypes, which are updated
      as new variable are added, and whose updates need to be kept regardless
      of what part of the procedure is analyzed next
    3 information about the context surrounding the goal currently being
      analyzed, such as the number of lambda expressions we are inside
    4 information about the point in the code before the goal currently being
      analyzed, such as the set of equivalences that currently hold between
      variables (part of common_info).

    The code of the simplify_goal*.m modules used to have jump through hoops
    to handle 3 and 4 properly, given that the simplify_info was being
    threaded through code in a way that was suitable only for 1 and 2.

    This change takes categories 3 and 4 out of the simplify_info.
    It creates a new type, simplify_nested_context, for category 3,
    and adds information about the ability of the procedure surrounding
    the current point to succeed more than once (needed for the bug311 fix)
    to this new type.

compiler/simplify_tasks.m:
    Rename the do_once task to mark_code_model_changes, since this
    expresses what the task is much less ambiguously.

compiler/simplify_goal*.m:
compiler/simplify_proc.m:
compiler/common.m:
compiler/mercury_compile_front_end.m:
compiler/mercury_compile_llds_back_end.m:
    Conform to the changes to simplify_info (and simplify_tasks).
    Pass the current instmap and common_info (the two category 4 fields)
    separately.

    Mark some places that could be improved.

compiler/hlds_out_mode.m:
    Generate easier-to-understand debugging output. I needed this to track
    down a bug in my initial fix.

compiler/inst_match.m:
    Remove a redundant unification that couldn't fail (since it was invoked
    only if the exact same unification succeeded a few lines earlier).
    Apply another minor optimizations.

compiler/instmap.m:
    Remove references to the alias branch. It won't be coming back.

compiler/error_util.m:
    Fix some documentation.

mdbcomp/feedback.m:
    Put related stuff together.

tests/warnings/bug311.{m,err_exp}:
    New test case for the bug.

tests/warnings/Mmakefile:
    Enable the new test case.
Merge branch 'master' of https://github.com/Mercury-Language/mercury
Further consistency improvements for error and warning messages.

The two main changes in this commit are:

(1) Use the error_util library's decl/1 and pramga_decl/1 format components in more
places.

(2) Quote type variables that appear in error messages.

compiler/error_util.m:
	Add a version of list_to_pieces/1 that places each of the strings in
	the input list in single quotes.

compiler/prog_io_type_defn.m:
	Quote type variables names in error messages.

compiler/add_class.m:
compiler/add_pragma.m:
compiler/add_pred.m:
compiler/check_typeclass.m:
compiler/make_hlds_error.m:
compiler/post_typecheck.m:
compiler/prog_io.m:
	Use the error_util library's decl/1 and pragma_decl/1 format components
	in more places.

compiler/mode_errors.m:
	Quote program variables and insts in some error messages.

compiler/post_term_analysis.m:
	Format a type ctor and arity in an error message properly.

tests/invalid/*.err_exp:
tests/warnings/*.exp:
	Conform to the above changes.
Improve more error messages.

Make consistency improvements to error messages concerning initialise, finalise
and mutable declarations.

compiler/make_hlds_error.m:
	Pass a list of format_components to error_if_exported/5 and
	error_is_exported/4 as the item description instead of a string.

compiler/add_pragma.m:
compiler/make_hlds_passes.m:
	Conform to the above change.

compiler/modes.m:
	Use the pragma_decl/1 format component in a couple of spots.

tests/invalid/bad_finalise_decl.err_exp:
tests/invalid/bad_initialise_decl.err_exp:
tests/invalid/bad_mutable.err_exp:
tests/invalid/imported_mode.err_exp:
tests/invalid/not_in_interface.err_exp:
tests/invalid/uniq_mutable.err_exp:
	Conform to the above changes.
Use a thread pool to manage threads on the Java backend

Thread pools are often used to reduce poor performance on embarrassingly
parallel work loads.  This isn't immediately necessary on the Java backend
however I've implemented it because:
    + It will be required when we implement parallel conjunctions for the
      Java backend.
    + I want to implement parallel profiling on the Java backend and don't
      want to have to implement this once now, and then re-implement it after
      introducing thread pools later.

We want the thread pool to generally restrict the number of threads that are
in use, this reduces overheads.  However, when one or more tasks become
blocked then it can be desirable to create extra threads, this helps ensure
that all processors are kept busy and that thread pooling doesn't contribute
to any deadlocks itself.  The implementation is a work in prograss and
currently does not implement this second feature.

Java's API provides several different thread pools, see
java.util.concurrent.Executors, none of which are suitable.  Specifically
the fixed thread pool is unsuitable as we want to be able to temporarily
exceed the normal number of threads as explained above; and the cached
thread pools, which are also very similar to the ThreadPoolExecutor class,
do not implement the correct algorithm for determining when a new thread
should be created (they can still perform poorly for embarassingly parallel
workloads).  Additionally we cannot instrument this code as easily for
parallel profiling.

These changes alter the behaviour of Mercury threads on the Java backend in
two ways, they now behave more correctly and more like threads on the C
backends.
    + If a thread throws an exception it is now reported and the program is
      aborted.  Previously it was ignored and let pass to the Java runtime
      where I assume it was reported.
    + The program now exits only after all threads have exited.

The ThreadPool will automatically detect the number of threads to use, or if
the -P flag is given in the MERCURY_OPTIONS environment variable it will
honor that.

java/runtime/MercuryThread.java:
java/runtime/MercuryThreadPool.java:
java/runtime/MercuryWorkerThread.java:
java/runtime/Task.java:
java/runtime/ThreadStatus.java:
    These new classes make up the thread pool.  A MercuryThread is an
    abstract class for Mercury threads, MercuryWorkerThread is a concrete
    subclass of MercuryThread which includes the worker thread behaviour.
    A Task is a computation/closure that has not yet been started, it
    provides some methods not available in Java's generic Runnable and
    Callable classes.  The others should be self-explanatory and all files
    contain documentation.

java/runtime/Getopt.java:
java/runtime/MercuryOptions.java:
    Parse the MERCURY_OPTIONS environment variable for the -P flag.

java/runtime/JavaInternal.java:
    Add support for handling Mercury exceptions, this is used in case a
    worker thread's task (a Mercury thread) throws an exception.

compiler/mlds_to_java.m:
    The main method of the main Java class of an application now starts and
    uses the thread pool to execute main/2.

library/exception.m:
    Export exception reporting code to the Java runtime system.

library/thread.m:
    Use the thread pool for thread.spawn.