mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-16 06:14:59 +00:00
caa865fd92dd2806a074b79ee32ec0bda41f951b
134 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
Simon Taylor
|
82c6cdb55e |
Make definitions of abstract types available when generating
Estimated hours taken: 100
Branches: main
Make definitions of abstract types available when generating
code for importing modules. This is necessary for the .NET
back-end, and for `:- pragma export' on the C back-end.
compiler/prog_data.m:
compiler/modules.m:
compiler/make.dependencies.m:
compiler/recompilation.version.m:
Handle implementation sections in interface files.
There is a new pseudo-declaration `abstract_imported'
which is applied to items from the implementation
section of an interface file. `abstract_imported'
items may not be used in the error checking passes
for the curent module.
compiler/equiv_type_hlds.m:
compiler/notes/compiler_design.html:
New file.
Go over the HLDS expanding all types fully after
semantic checking has been run.
compiler/mercury_compile.m:
Add the new pass.
Don't write the `.opt' file if there are any errors.
compiler/instmap.m:
Add a predicate instmap_delta_map_foldl to apply
a procedure to all insts in an instmap.
compiler/equiv_type.m:
Export predicates for use by equiv_type_hlds.m
Reorder arguments so state variables and higher-order
programming can be used.
compiler/prog_data.m:
compiler/prog_io_pragma.m:
compiler/make_hlds.m:
compiler/mercury_to_mercury.m:
Handle `:- pragma foreign_type' as a form of type
declaration rather than a pragma.
compiler/hlds_data.m:
compiler/*.m:
Add a field to the type_info_cell_constructor cons_id
to identify the type_ctor, which is needed by
equiv_type_hlds.m.
compiler/module_qual.m:
Donn't allow items from the implementation section of
interface files to match items in the current module.
compiler/*.m:
tests/*/*.m:
Add missing imports which only became apparent with
the bug fixes above.
Remove unnecessary imports which only became apparent with
the bug fixes above.
tests/hard_coded/Mmakefile:
tests/hard_coded/export_test2.{m,exp}:
Test case.
tests/invalid/Mmakefile:
tests/invalid/missing_interface_import2.{m,err_exp}:
Test case.
|
||
|
Peter Ross
|
cea3c7294e |
Fix a bug where the type_ctor_info for type_info/1 and
Estimated hours taken: 2 Branches: main Fix a bug where the type_ctor_info for type_info/1 and type_ctor_info/1 weren't being generated. compiler/type_ctor_info.m: Also have to generate a type_ctor_info for those types which have hand defined rtti due to having a fake type body. compiler/type_util.m: Rename builtin_type_ctors_with_no_type_defn as builtin_type_ctors_with_no_hlds_type_defn as the former name was misleading, and remove an incorrect comment about which type_ctors this function returns. compiler/make_hlds.m: compiler/typecheck.m: Changes due to the renaming of builtin_type_ctors_with_no_hlds_type_defn. |
||
|
Peter Ross
|
368eaf2d11 |
Address review comments of fjh about my change to generate type_ctor and
Estimated hours taken: 1.5 Branches: main Address review comments of fjh about my change to generate type_ctor and special preds for the builtin types which don't have an abstract type declaration. compiler/make_hlds.m: Change parse_tree_to_hlds to use the state variable syntax. compiler/type_util.m: s/builtin_type_ctors/builtin_type_ctors_with_no_type_defn/ which better reflects which type ctors this function returns. compiler/type_ctor_info.m: Improve the documentation of how the code determines whether or not a type_ctor_info needs to be generated. compiler/typecheck.m: Use builtin_type_ctors_with_no_type_defn and make the documentation more explicit. |
||
|
Peter Ross
|
22e4692ac5 |
Rather than declare the builtin types as abstract types in builtin.m
Estimated hours taken: 4 Branches: main Rather than declare the builtin types as abstract types in builtin.m special case their handling in the compiler to ensure that the special preds and the type_ctor_infos are generated when needed. compiler/type_util.m: Add a utility predicate which returns the list of type_ctors which represent types which are special builtins (ie they have no type declaration, even an abstract one). compiler/make_hlds.m: Add the special preds for the special builtins if we are generating the rtti for the builtins. compiler/type_ctor_info.m: Add type_ctor_infos for the special builtins if we are generating the rtti for the builtins. compiler/typecheck.m: The special predicates for the special builtins don't require typechecking. library/builtin.m: Remove the special builtins as they are no longer needed for generating the type_ctor_infos for a type. |
||
|
Zoltan Somogyi
|
a2bf36e49a |
This diff contains no changes in algorithms whatsoever.
Estimated hours taken: 4 Branches: main This diff contains no changes in algorithms whatsoever. browser/*.m: compiler/*.m: library/*.m: Replace old-style lambdas with new-style lambdas or with named procedures. |
||
|
Zoltan Somogyi
|
03cbbf4fc0 |
Improve the clarity of polymorphism.m further.
Estimated hours taken: 2 Branches: main Improve the clarity of polymorphism.m further. compiler/polymorphism.m: When a data structure involving type variables has several versions which differ in which tvarset those type variables come from (the raw tvarset of a called predicate's pred_info, the renamed-apart version in which those type variables have been lifted into the caller's newly expanded tvarset, and the version in which the type variables in the types of the formal parameters been replaced with the actual (possibly polymorphic) types from the actual arguments), use a mnemonic prefix to distinguish them, not a numerical suffix of the kind we use for other kinds of transformations. Put the code handling foreign_procs into its own predicate, to make debugging easier. compiler/prog_data.m: Add field names to the class_constraints type, for use in polymorphism.m. compiler/type_util.m: Add a utility predicate, factoring out repeated code from polymorphism.m. library/varset.m: Clarify the documentation of varset__merge_subst. |
||
|
Zoltan Somogyi
|
8693e293a2 |
This diff makes hlds_pred.m and many callers of its predicates easier to read
Estimated hours taken: 4 Branches: main This diff makes hlds_pred.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/hlds_pred.m: Bring this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. Standardize indentation. compiler/*.m: Conform to the changes in hlds_pred.m. This mostly means using the new argument orders of predicates exported by hlds_pred.m. Where this is now conveniently possible, change predicates to use state variable notation. In some modules, using state variable notation required changing the orders of arguments in the module's top predicate. compiler/passes_aux.m: Change the order of arguments in the calls this module makes to allow the callees to use state variable notation. Convert this module to state variable notation too. |
||
|
Zoltan Somogyi
|
f007b45df8 |
Implement the infrastructure for term size profiling.
Estimated hours taken: 400
Branches: main
Implement the infrastructure for term size profiling. This means adding two
new grade components, tsw and tsc, and implementing them in the LLDS code
generator. In grades including tsw (term size words), each term is augmented
with an extra word giving the number of heap words it contains; in grades
including tsc (term size cells), each term is augmented with an extra word
giving the number of heap cells it contains. The extra word is at the start,
at offset -1, to leave almost all of the machinery for accessing the heap
unchanged.
For now, the only way to access term sizes is with a new mdb command,
"term_size <varspec>". Later, we will use term sizes in conjunction with
deep profiling to do experimental complexity analysis, but that requires
a lot more research. This diff is a necessary first step.
The implementation of term size profiling consists of three main parts:
- a source-to-source transform that computes the size of each heap cell
when it is constructed (and increments it in the rare cases when a free
argument of an existing heap cell is bound),
- a relatively small change to the code generator that reserves the extra
slot in new heap cells, and
- extensions to the facilities for creating cells from C code to record
the extra information we now need.
The diff overhauls polymorphism.m to make the source-to-source transform
possible. This overhaul includes separating type_ctor_infos and type_infos
as strictly as possible from each other, converting type_ctor_infos into
type_infos only as necessary. It also includes separating type_ctor_infos,
type_infos, base_typeclass_infos and typeclass_infos (as well as voids,
for clarity) from plain user-defined type constructors in type categorizations.
This change needs this separation because values of those four types do not
have size slots, but they ought to be treated specially in other situations
as well (e.g. by tabling).
The diff adds a new mdb command, term_size. It also replaces the proc_body
mdb command with new ways of using the existing print and browse commands
("print proc_body" and "browse proc_body") in order to make looking at
procedure bodies more controllable. This was useful in debugging the effect
of term size profiling on some test case outputs. It is not strictly tied
to term size profiling, but turns out to be difficult to disentangle.
compiler/size_prof.m:
A new module implementing the source-to-source transform.
compiler/notes/compiler_design.html:
Mention the new module.
compiler/transform_hlds.m:
Include size_prof as a submodule of transform_hlds.
compiler/mercury_compile.m:
If term size profiling is enabled, invoke its source-to-source
transform.
compiler/hlds_goal.m:
Extend construction unifications with an optional slot for recording
the size of the term if the size is a constant, or the identity of the
variable holding the size, if the size is not constant. This is
needed by the source-to-source transform.
compiler/quantification.m:
Treat the variable reference that may be in this slot as a nonlocal
variable of construction unifications, since the code generator needs
this.
compiler/compile_target_code.m:
Handle the new grade components.
compiler/options.m:
Implement the options that control term size profiling.
doc/user_guide.texi:
Document the options and grade components that control term size
profiling, and the term_size mdb command. The documentation is
commented out for now.
Modify the wording of the 'u' HLDS dump flag to include other details
of unifications (e.g. term size info) rather than just unification
categories.
Document the new alternatives of the print and browse commands. Since
they are for developers only, the documentation is commented out.
compiler/handle_options.m:
Handle the implications of term size profiling grades.
Add a -D flag value to print HLDS components relevant to HLDS
transformations.
compiler/modules.m:
Import the new builtin library module that implements the operations
needed by term size profiling automatically in term size profiling
grades.
Switch the predicate involved to use state var syntax.
compiler/prog_util.m:
Add predicates and functions that return the sym_names of the modules
needed by term size profiling.
compiler/code_info.m:
compiler/unify_gen.m:
compiler/var_locn.m:
Reserve an extra slot in heap cells and fill them in in unifications
marked by size_prof.
compiler/builtin_ops.m:
Add term_size_prof_builtin.term_size_plus as a builtin, with the same
implementation as int.+.
compiler/make_hlds.m:
Disable warnings about clauses for builtins while the change to
builtin_ops is bootstrapped.
compiler/polymorphism.m:
Export predicates that generate goals to create type_infos and
type_ctor_infos to add_to_construct.m. Rewrite their documentation
to make it more detailed.
Make orders of arguments amenable to the use of state variable syntax.
Consolidate knowledge of which type categories have builtin unify and
compare predicates in one place.
Add code to leave the types of type_ctor_infos alone: instead of
changing their types to type_info when used as arguments of other
type_infos, create a new variable of type type_info instead, and
use an unsafe_cast. This would make the HLDS closer to being type
correct, but this new code is currently commented out, for two
reasons. First, common.m is currently not smart enough to figure out
that if X and Y are equal, then similar unsafe_casts of X and Y
are also equal, and this causes the compiler do not detect some
duplicate calls it used to detect. Second, the code generators
are also not smart enough to know that if Z is an unsafe_cast of X,
then X and Z do not need separate stack slots, but can use the same
slot.
compiler/type_util.m:
Add utility predicates for returning the types of type_infos and
type_ctor_infos, for use by new code in polymorphism.m.
Move some utility predicates here from other modules, since they
are now used by more than one module.
Rename the type `builtin_type' as `type_category', to better reflect
what it does. Extend it to put the type_info, type_ctor_info,
typeclass_info, base_typeclass_info and void types into categories
of their own: treating these types as if they were a user-defined
type (which is how they used to be classified) is not always correct.
Rename the functor polymorphic_type to variable_type, since types
such as list(T) are polymorphic, but they fall into the user-defined
category. Rename user_type as user_ctor_type, since list(int) is not
wholly user-defined but falls into this category. Rename pred_type
as higher_order_type, since it also encompasses functions.
Replace code that used to check for a few of the alternatives
of this type with code that does a full switch on the type,
to ensure that they are updated if the type definition ever
changes again.
compiler/pseudo_type_info.m:
Delete a predicate whose updated implementation is now in type_util.m.
compiler/mlds_to_c.m:
compiler/mlds_to_gcc.m:
compiler/mlds_to_il.m:
compiler/mlds_to_java.m:
Still treat type_infos, type_ctor_infos, typeclass_infos and
base_typeclass_infos as user-defined types, but prepare for when
they won't be.
compiler/hlds_pred.m:
Require interface typeinfo liveness when term size profiling is
enabled.
Add term_size_profiling_builtin.increase_size as a
no_type_info_builtin.
compiler/hlds_out.m:
Print the size annotations on unifications if HLDS dump flags call
for unification details. (The flag test is in the caller of the
modified predicate.)
compiler/llds.m:
Extend incr_hp instructions and data_addr_consts with optional fields
that allow the code generator to refer to N words past the start of
a static or dynamic cell. Term size profiling uses this with N=1.
compiler/llds_out.m:
When allocating memory on the heap, use the macro variants that
specify an optional offset, and specify the offset when required.
compiler/bytecode_gen.m:
compiler/dense_switch.m:
compiler/dupelim.m:
compiler/exprn_aux.m:
compiler/goal_form.m:
compiler/goal_util.m:
compiler/higher_order.m:
compiler/inst_match.m:
compiler/intermod.m:
compiler/jumpopt.m:
compiler/lambda.m:
compiler/livemap.m:
compiler/ll_pseudo_type_info.m:
compiler/lookup_switch.m:
compiler/magic_util.m:
compiler/middle_rec.m:
compiler/ml_code_util.m:
compiler/ml_switch_gen.m:
compiler/ml_unify_gen.m:
compiler/mlds.m:
compiler/mlds_to_c.m:
compiler/mlds_to_gcc.m:
compiler/mlds_to_il.m:
compiler/mlds_to_java.m:
compiler/modecheck_unify.m:
compiler/opt_debug.m:
compiler/opt_util.m:
compiler/par_conj_gen.m:
compiler/post_typecheck.m:
compiler/reassign.m:
compiler/rl.m:
compiler/rl_key.m:
compiler/special_pred.m:
compiler/stack_layout.m:
compiler/static_term.m:
compiler/string_switch.m:
compiler/switch_gen.m:
compiler/switch_util.m:
compiler/table_gen.m:
compiler/term_util.m:
compiler/type_ctor_info.m:
compiler/unused_args.m:
compiler/use_local_vars.m:
Minor updates to conform to the changes above.
library/term_size_prof_builtin.m:
New module containing helper predicates for term size profiling.
size_prof.m generates call to these predicates.
library/library.m:
Include the new module in the library.
doc/Mmakefile:
Do not include the term_size_prof_builtin module in the library
documentation.
library/array.m:
library/benchmarking.m:
library/construct.m:
library/deconstruct.m:
library/io.m:
library/sparse_bitset.m:
library/store.m:
library/string.m:
Replace all uses of MR_incr_hp with MR_offset_incr_hp, to ensure
that we haven't overlooked any places where offsets may need to be
specified.
Fix formatting of foreign_procs.
Use new macros defined by the runtime system when constructing
terms (which all happen to be lists) in C code. These new macros
specify the types of the cell arguments, allowing the implementation
to figure out the size of the new cell based on the sizes of its
fields.
library/private_builtin.m:
Define some constant type_info structures for use by these macros.
They cannot be defined in the runtime, since they refer to types
defined in the library (list.list and std_util.univ).
util/mkinit.c:
Make the addresses of these type_info structures available to the
runtime.
runtime/mercury_init.h:
Declare these type_info structures, for use in mkinit-generated
*_init.c files.
runtime/mercury_wrapper.[ch]:
Declare and define the variables that hold these addresses, for use
in the new macros for constructing typed lists.
Since term size profiling can refer to a memory cell by a pointer
that is offset by one word, register the extra offsets with the Boehm
collector if is being used.
Document the incompatibility of MR_HIGHTAGS and the Boehm collector.
runtime/mercury_tags.h:
Define new macros for constructing typed lists.
Provide macros for preserving the old interface presented by this file
to the extent possible. Uses of the old MR_list_cons macro will
continue to work in grades without term size profiling. In term
size profiling grades, their use will get a C compiler error.
Fix a bug caused by a missing backslash.
runtime/mercury_heap.h:
Change the basic macros for allocating new heap cells to take
an optional offset argument. If this is nonzero, the macros
increment the returned address by the given number of words.
Term size profiling specifies offset=1, reserving the extra
word at the start (which is ignored by all components of the
system except term size profiling) for holding the size of the term.
Provide macros for preserving the old interface presented by this file
to the extent possible. Since the old MR_create[123] and MR_list_cons
macros did not specify type information, they had to be changed
to take additional arguments. This affects only hand-written C code.
Call new diagnostic macros that can help debug heap allocations.
Document why the macros in this files must expand to expressions
instead of statements, evn though the latter would be preferable
(e.g. by allowing them to declare and use local variables without
depending on gcc extensions).
runtime/mercury_debug.[ch]:
Add diagnostic macros to debug heap allocations, and the functions
behind them if MR_DEBUG_HEAP_ALLOC is defined.
Update the debugging routines for hand-allocated cells to print the
values of the term size slot as well as the other slots in the relevant
grades.
runtime/mercury_string.h:
Provide some needed variants of the macro for copying strings.
runtime/mercury_deconstruct_macros.h:
runtime/mercury_type_info.c:
Supply type information when constructing terms.
runtime/mercury_deep_copy_body.h:
Preserve the term size slot when copying terms.
runtime/mercury_deep_copy_body.h:
runtime/mercury_ho_call.c:
runtime/mercury_ml_expand_body.h:
Use MR_offset_incr_hp instead of MR_incr_hp to ensure that all places
that allocate cells also allocate space for the term size slot if
necessary.
Reduce code duplication by using a now standard macro for copying
strings.
runtime/mercury_grade.h:
Handle the two new grade components.
runtime/mercury_conf_param.h:
Document the C macros used to control the two new grade components,
as well as MR_DEBUG_HEAP_ALLOC.
Detect incompatibilities between high level code and profiling.
runtime/mercury_term_size.[ch]:
A new module to house a function to find and return term sizes
stored in heap cells.
runtime/mercury_proc_id.h:
runtime/mercury_univ.h:
New header files. mercury_proc_id.h contains the (unchanged)
definition of MR_Proc_Id, while mercury_univ.h contains the
definitions of the macros for manipulating univs that used to be
in mercury_type_info.h, updated to use the new macros for allocating
memory.
In the absence of these header files, the following circularity
would ensue:
mercury_deep_profiling.h includes mercury_stack_layout.h
- needs definition of MR_Proc_Id
mercury_stack_layout.h needs mercury_type_info.h
- needs definition of MR_PseudoTypeInfo
mercury_type_info.h needs mercury_heap.h
- needs heap allocation macros for MR_new_univ_on_hp
mercury_heap.h includes mercury_deep_profiling.h
- needs MR_current_call_site_dynamic for recording allocations
Breaking the circular dependency in two places, not just one, is to
minimize similar problems in the future.
runtime/mercury_stack_layout.h:
Delete the definition of MR_Proc_Id, which is now in mercury_proc_id.h.
runtime/mercury_type_info.h:
Delete the macros for manipulating univs, which are now in
mercury_univ.h.
runtime/Mmakefile:
Mention the new files.
runtime/mercury_imp.h:
runtime/mercury.h:
runtime/mercury_construct.c:
runtime/mercury_deep_profiling.h:
Include the new files at appropriate points.
runtime/mercury.c:
Change the names of the functions that create heap cells for
hand-written code, since the interface to hand-written code has
changed to include type information.
runtime/mercury_tabling.h:
Delete some unused macros.
runtime/mercury_trace_base.c:
runtime/mercury_type_info.c:
Use the new macros supplying type information when constructing lists.
scripts/canonical_grade_options.sh-subr:
Fix an undefined sh variable bug that could cause error messages
to come out without identifying the program they were from.
scripts/init_grade_options.sh-subr:
scripts/parse_grade_options.sh-subr:
scripts/canonical_grade_options.sh-subr:
scripts/mgnuc.in:
Handle the new grade components and the options controlling them.
trace/mercury_trace_internal.c:
Implement the mdb command "term_size <varspec>", which is like
"print <varspec>", but prints the size of a term instead of its value.
In non-term-size-profiling grades, it prints an error message.
Replace the "proc_body" command with optional arguments to the "print"
and "browse" commands.
doc/user_guide.tex:
Add documentation of the term_size mdb command. Since the command is
for implementors only, and works only in grades that are not yet ready
for public consumption, the documentation is commented out.
Add documentation of the new arguments of the print and browse mdb
commands. Since they are for implementors only, the documentation
is commented out.
trace/mercury_trace_vars.[ch]:
Add the functions needed to implement the term_size command, and
factor out the code common to the "size" and "print"/"browse" commands.
Decide whether to print the name of a variable before invoking the
supplied print or browse predicate on it based on a flag design for
this purpose, instead of overloading the meaning of the output FILE *
variable. This arrangement is much clearer.
trace/mercury_trace_browse.c:
trace/mercury_trace_external.c:
trace/mercury_trace_help.c:
Supply type information when constructing terms.
browser/program_representation.m:
Since the new library module term_size_prof_builtin never generates
any events, mark it as such, so that the declarative debugger doesn't
expect it to generate any.
Do the same for the deep profiling builtin module.
tests/debugger/term_size_words.{m,inp,exp}:
tests/debugger/term_size_cells.{m,inp,exp}:
Two new test cases, each testing one of the new grades.
tests/debugger/Mmakefile:
Enable the two new test cases in their grades.
Disable the tests sensitive to stack frame sizes in term size profiling
grades.
tests/debugger/completion.exp:
Add the new "term_size" mdb command to the list of command completions,
and delete "proc_body".
tests/debugger/declarative/dependency.{inp,exp}:
Use "print proc_body" instead of "proc_body".
tests/hard_coded/nondet_c.m:
tests/hard_coded/pragma_inline.m:
Use MR_offset_incr_hp instead of MR_incr_hp to ensure that all places
that allocate cells also allocate space for the term size slot if
necessary.
tests/valid/Mmakefile:
Disable the IL tests in term size profiling grades, since the term size
profiling primitives haven't been (and probably won't be) implemented
for the MLDS backends, and handle_options causes a compiler abort
for grades that combine term size profiling and any one of IL, Java
and high level C.
|
||
|
Simon Taylor
|
5fa9a4b111 |
Remove the unimplemented aditi_filter and aditi_modify
Estimated hours taken: 0.5 Branches: main compiler/*.m: Remove the unimplemented aditi_filter and aditi_modify goals -- they will never be implemented. Remove the `aditi_top_down' lambda_eval_method, which was only used for those update goals. Even if those update goals were to be implemented, a special type of lambda expression shouldn't actually be needed. Use clearer names for the updates in the constructors of the aditi_builtin type. |
||
|
Simon Taylor
|
ea33d1945c |
The Aditi API has been re-implemented. This change updates
Estimated hours taken: 40
Branches: main
The Aditi API has been re-implemented. This change updates
the Mercury->Aditi interface to work with the new API.
compiler/aditi_builtin_ops.m:
Pass aditi__states to the builtin predicates implementing
calls to Aditi procedures.
compiler/mode_util.m:
Add a function aditi_ui_mode.
compiler/type_util.m:
Add a function aditi_state_type.
runtime/mercury_wrapper.{c,h}:
util/mkinit.c:
Pass the connection and a transaction in which to
store the Aditi-RL modules.
extras/aditi/aditi.m:
extras/aditi/aditi_private_builtin.m:
util/mkinit.c:
Use the new API.
|
||
|
Simon Taylor
|
a8ce49c7a8 |
Fix a bug reported by Fergus, which caused an abort when a
Estimated hours taken: 5
Branches: main
Fix a bug reported by Fergus, which caused an abort when a
user-defined unification or comparison predicate was ill-typed.
compiler/intermod.m:
Don't attempt to module qualify the unification
and comparison routines for type declarations that
won't be used on the current back-end -- they won't
have been typechecked. They will be ignored when read
back in, but we put them in the `.opt' file because
it is sometimes useful to test compiling a module
against a workspace using a grade different to that
used to build the workspace.
compiler/type_util.m:
Choose the correct unification/comparison predicates for
the current back-end where there are both Mercury and
foreign definitions for a type.
compiler/make_hlds.m:
compiler/foreign.m:
Move have_foreign_type_for_backend to foreign.m, for
use by intermod.m.
doc/reference_manual.texi:
Clarify the documentation about user-defined unification and
comparison predicates for foreign types.
tests/invalid/Mmakefile:
tests/invalid/illtyped_compare.{m,err_exp}:
Add a test case.
tests/invalid/make_opt_error.{m,err_exp}:
This change caused the error in this test case to not
be reported any more (it occurred in code not used
on the back-end being compiled for). Fix the test
so an error is reported.
|
||
|
David Overton
|
2ad2f0a28e |
Allow types to be declared as "solver" types using the syntax
Estimated hours taken: 120
Branches: main
Allow types to be declared as "solver" types using the syntax
`:- solver type ...'.
For a non-solver type t (i.e. any type declared without using the
`solver' keyword), the inst `any' should be considered to be equivalent
to a bound inst i where i contains all the functors of the type t and
each argument has inst `any'. For solver types, `any' retains its
previous meaning.
This is required to allow us to represent HAL's `old' inst using `any'.
In HAL, `old' is like `any' if the type is an instance of a particular
type class (`solver/1'). However, for types that are not instances of
`solver/1', `old' needs to be treated as though it is `bound'.
library/ops.m:
Add `solver' as a unary prefix operator.
compiler/prog_data.m:
Add a field to the type `type_defn' to record whether or not the
type is a solver type.
compiler/hlds_data.m:
Add an equivalent field to the type `hlds_type_body'.
compiler/prog_io.m:
compiler/make_hlds.m:
compiler/modules.m:
compiler/mercury_to_mercury.m:
compiler/hlds_out.m:
Handle the new ":- solver type ..." syntax.
compiler/det_report.m:
compiler/equiv_type.m:
compiler/foreign.m:
compiler/hlds_code_util.m:
compiler/hlds_out.m:
compiler/intermod.m:
compiler/magic_util.m:
compiler/ml_code_gen.m:
compiler/ml_type_gen.m:
compiler/ml_unify_gen.m:
compiler/mlds.m:
compiler/module_qual.m:
compiler/post_typecheck.m:
compiler/pragma_c_gen.m:
compiler/recompilation.check.m:
compiler/recompilation.usage.m:
compiler/recompilation.version.m:
compiler/special_pred.m:
compiler/stack_opt.m:
compiler/switch_util.m:
compiler/table_gen.m:
compiler/term_util.m:
compiler/type_ctor_info.m:
compiler/unify_gen.m:
compiler/unify_proc.m:
Handle the changes to `type_defn' and `hlds_type_body'.
compiler/type_util.m:
Add predicates `type_util__is_solver_type' and
`type_body_is_solver_type'.
compiler/inst_match.m:
compiler/inst_util.m:
In inst_matches_{initial,final,binding} and
abstractly_unify_inst_functor, when we are comparing `any' insts, check
whether or not the type is a solver type and treat it appropriately.
compiler/instmap.m:
compiler/modecheck_unify.m:
Pass type information to abstractly_unify_inst_functor.
compiler/mode_util.m:
Add a predicate `constructors_to_bound_any_insts' which is the same as
`constructors_to_bound_insts' except that it makes the arguments of the
bound inst `any' instead of `ground'.
tests/invalid/any_mode.m:
tests/invalid/any_mode.err_exp:
tests/hard_coded/any_free_unify.m:
Modify these test cases to use a "solver" type instead of `int'.
tests/valid/any_matches_bound.m:
tests/valid/Mmakefile:
tests/invalid/Mmakefile:
tests/invalid/any_should_not_match_bound.m:
tests/invalid/any_should_not_match_bound.err_exp:
Add new test cases.
extras/trailed_update/var.m:
clpr/cfloat.m:
Modify to use the new `:- solver type' syntax.
|
||
|
David Overton
|
127fe0f85f |
Fixes to allow testing of ground' matches bound'.
Estimated hours taken: 10 Branches: main Fixes to allow testing of `ground' matches `bound'. compiler/modules.m: When writing discriminated union types to the .int2 file, write out the full type definition rather than an abstract type declaration. This is necessary because a module which transitively imports the .int2 file may need to know the constructors to allow `ground' to be compared with `bound' insts. See the new test case `transitive_inst_type' for an example. If the type has user-defined equality and/or comparison predicates then we write "... where type_is_abstract_noncanonical" to the .int2 file instead of giving the predicate names. compiler/make_hlds.m: If a discriminated union type is imported from a .int2 file, mark it as `abstract_imported'. compiler/typecheck.m: When type checking var-functor unifications, do not allow functors whose types are `abstract_imported', unless we are type checking an `opt_imported' predicate. compiler/prog_data.m: Add a new alternative `abstract_noncanonical_type' to the type `unify_compare' to represent "where type_is_abstract_noncanonical" annotations read from .int2 files. compiler/prog_io.m: Parse "where type_is_abstract_noncanonical" annotations on discriminated union types. compiler/special_pred.m: compiler/unify_proc.m: Avoid creating unification and comparison predicates for types with `type_is_abstract_noncanonical' annotations. compiler/intermod.m: Handle the change to the `unify_compare' type. compiler/type_util.m: Do not remove module qualifiers from constructors before looking them up in the cons table. Some cons ids only have the qualified version in the table. tests/hard_coded/Mmakefile: tests/hard_coded/Mercury.options: tests/hard_coded/transitive_inst_type.exp: tests/hard_coded/transitive_inst_type.m: tests/hard_coded/transitive_inst_type2.m: tests/hard_coded/transitive_inst_type3.m: tests/hard_coded/trans_intermod_user_equality.exp: tests/hard_coded/trans_intermod_user_equality.m: tests/hard_coded/trans_intermod_user_equality2.m: tests/hard_coded/trans_intermod_user_equality3.m: Add some test cases. |
||
|
Zoltan Somogyi
|
a25b2c0507 |
Prepare to make type_info and typeclass_info foreign types by allowing
Estimated hours taken: 2 Branches: main Prepare to make type_info and typeclass_info foreign types by allowing the compiler to generate type_ctor_infos for them, and allow them to be passed to foreign code without warnings. compiler/type_util.m: Make the predicate type_ctor_has_hand_defined_rtti return true only if the relevant type is not declared as a foreign type. This is needed to allow the compiler to bootstrap across the change that makes type_info and typeclass_info foreign types. This required passing the type definition to the predicate. compiler/special_pred.m: compiler/unify_proc.m: Pass the extra argument to type_ctor_has_hand_defined_rtti. compiler/type_ctor_info.m: Pass the extra argument to type_ctor_has_hand_defined_rtti. Set the required flags on any compiler-generated type_ctor_info structures for the builtin types with fake arities. compiler/llds_out.m: Fix an old bug: ensure that the second argument of the MR_MAYBE_UNBOX_FOREIGN_TYPE macro is of type MR_Word, because the macro insists on this. If applied to e.g. type_ctor_info constants, the old code would have generated C compiler warnings, because their type is not MR_Word. Special case the most frequently passed foreign types to avoid the memcpy overhead in MR_MAYBE_UNBOX_FOREIGN_TYPE. compiler/export.m: Add a utility predicate to help llds_out.m. In the future, the MLDS C backend may want to use it too. |
||
|
Zoltan Somogyi
|
d6f05747a2 |
Prepare to make type_info and typeclass_info foreign types by eliminating the
Estimated hours taken: 4 Branches: main Prepare to make type_info and typeclass_info foreign types by eliminating the compiler's dependence on their function symbols. At the moment, the compiler generates type_intos and typeclass_infos by using the function symbols of these types as cons_ids. However, the function symbols have fake arities, which demanded special treatment in many places. This change makes the compiler use the cons_ids type_into_cell_constructor and typeclass_into_cell_constructor instead, except in insts, which need to know the arity of the constructor. compiler/hlds_data.m: Add the two new cons_ids. compiler/polymorphism.m: Use the two new cons_ids instead of the function symbols of the type_info and typeclass_info types, since those function symbols will soon be deleted. compiler/type_util.m: Add a type and some predicates to control the representation of type_info and typeclass_info cells in one place. Since we no longer depend on the representations of the function symbols of the type_info and typeclass_info types, do not special case their representation. compiler/hlds_code_util.m: Implement the representation of the two new function symbols. compiler/bytecode.m: Add two new cons_ids to parallel the ones in hlds_data.m. compiler/higher_order.m: Look for the two new cons_ids, instead of the old ones. Make the code more maintainable. compiler/*.m: Minor changes to conform to the changes above. library/private_builtin.m: Delete the statement that the compiler depends on the functors of the type_info and type_ctor_info types. bytecode/mb_bytecode.h: Document that some bytecodes generated by the compiler are not yet implemented by the bytecode interpreter. |
||
|
Zoltan Somogyi
|
aa478cb237 |
Take a piece of code in modecheck_unify and make it a predicate in
Estimated hours taken: 0.2 Branches: main compiler/type_util.m: compiler/modecheck_unify.m: Take a piece of code in modecheck_unify and make it a predicate in type_util, without any logic changes. In an upcoming diff, another module will need the same code. |
||
|
Zoltan Somogyi
|
4f42c8e2b1 |
Improve the documentation of predicates checking for user-defined
Estimated hours taken: 0.2 Branches: main compiler/type_util.m: compiler/det_analysis.m: Improve the documentation of predicates checking for user-defined equality. |
||
|
Zoltan Somogyi
|
6554ef7daa |
Replace "is" with "=".
Estimated hours taken: 2 Branches: main Replace "is" with "=". Add field names where relevant. Replace integers with counters where relevant. |
||
|
Zoltan Somogyi
|
9551640f55 |
Import only one compiler module per line. Sort the blocks of imports.
Estimated hours taken: 2 Branches: main compiler/*.m: Import only one compiler module per line. Sort the blocks of imports. This makes it easier to merge in changes. In a couple of places, remove unnecessary imports. |
||
|
Simon Taylor
|
482105e074 |
Allow user-defined comparison functions using the syntax
Estimated hours taken: 10
Branches: main
Allow user-defined comparison functions using the syntax
:- type t ---> t where equality is t_equal, comparison is t_compare.
.
Allow user-defined equality and comparison for foreign types using the syntax
:- pragma foreign_type(c, t, "c_t") where
equality is t_equal, comparison is t_compare.
compiler/prog_data.m:
compiler/mercury_to_mercury.m:
compiler/hlds_out.m:
compiler/*.m:
Allow comparison predicates in `type' and `pragma foreign_type'
declarations
compiler/hlds_data.m:
compiler/*.m:
Allow equality and comparison predicates to be attached
to foreign types.
compiler/prog_io.m:
compiler/prog_io_pragma.m:
Parse the new syntax.
compiler/make_hlds.m:
Don't add the types to the HLDS or do typechecking if
there are errors in the type declarations.
Test case: tests/invalid/foreign_type_visibility.m.
compiler/foreign.m:
compiler/special_pred.m:
compiler/type_util.m:
Check whether foreign types have user-defined equality.
compiler/unify_proc.m:
Generate clauses for user-defined comparison,
and clauses for unification for foreign types.
compiler/intermod.m:
Resolve overloading before writing the `.opt' files.
library/builtin.m:
Add `uo' modes for promise_only_solution, for use in
user-defined comparison predicates.
Add types and insts to allow declaration of user-defined
comparison predicates using `with_type` and `with_inst`.
We already have types and insts `builtin__comparison_pred',
but they have a different argument ordering to `compare/3'.
NEWS:
doc/reference_manual.texi:
Document the change.
tests/hard_coded/Mmakefile:
tests/hard_coded/user_compare.{m,exp}:
Test case.
tests/invalid/Mmakefile:
tests/invalid/typeclass_test_{9,10}.{m,err_exp}:
tests/invalid/purity/purity_nonsense{,2}.{m,err_exp}:
The change to error-checking in make_hlds.m meant that
the compilation stopped before some errors in
typeclass_test_9.m were detected. The code which
tests for those errors is now in typeclass_test_10.m.
|
||
|
Fergus Henderson
|
ef7ed9c2f5 |
Support impurity declarations for higher-order code.
Estimated hours taken: 24 Branches: main Support impurity declarations for higher-order code. In particular, allow `impure' and `semipure' annotations on higher-order types, higher-order calls, and lambda expresions. NEWS: doc/reference_manual.texi: Document the new language feature. compiler/hlds_goal.m: compiler/hlds_pred.m: Add `purity' field to - the `higher_order' alternative of the hlds_goal.generic_call type - the `higher_order' alternative of the hlds_pred.generic_call_id type - the `lambda_goal' alternative of the hlds_goal.unify_rhs type compiler/type_util.m: Add a new `purity' argument to the procedures dealing with higher-order types. Add code for parsing impure/semipure higher-order types. compiler/lambda.m: compiler/make_hlds.m: compiler/typecheck.m: compiler/post_typecheck.m: compiler/purity.m: compiler/polymorphism.m: Various minor changes to support impure/semipure higher-order lambda expressions. compiler/polymorphism.m: compiler/pseudo_type_info.m: XXX ought to change these to include purity in the RTTI for higher-order function types. compiler/simplify.m: Don't try to optimize semipure/impure higher-order calls. compiler/assertion.m: compiler/bytecode_gen.m: compiler/call_gen.m: compiler/continuation_info.m: compiler/cse_detection.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/det_analysis.m: compiler/det_util.m: compiler/equiv_type.m: compiler/goal_util.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/intermod.m: compiler/magic.m: compiler/magic_util.m: compiler/ml_call_gen.m: compiler/ml_closure_gen.m: compiler/mode_util.m: compiler/modecheck_call.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/pd_util.m: compiler/prog_rep.m: compiler/pseudo_type_info.m: compiler/quantification.m: compiler/recompilation.usage.m: compiler/rl_gen.m: compiler/stratify.m: compiler/switch_detection.m: compiler/term_traversal.m: compiler/term_util.m: compiler/unify_gen.m: compiler/unique_modes.m: Trivial changes to handle the new purity fields and/or arguments. tests/hard_coded/purity/Mmakefile: tests/hard_coded/purity/impure_func_t5_fixed2.m: tests/hard_coded/purity/impure_func_t5_fixed2.exp: tests/hard_coded/purity/impure_func_t5_fixed2.exp2: tests/hard_coded/purity/impure_pred_t1_fixed3.m: tests/hard_coded/purity/impure_pred_t1_fixed3.exp: tests/invalid/purity/Mmakefile: tests/invalid/purity/impure_func_t5_fixed.m: tests/invalid/purity/impure_func_t5_fixed.err_exp: tests/invalid/purity/impure_pred_t1_fixed.m: tests/invalid/purity/impure_pred_t1_fixed.err_exp: Add new test cases to test the new feature. tests/invalid/purity/impure_func_t5.err_exp: tests/invalid/purity/impure_pred_t1.err_exp: tests/invalid/purity/impure_pred_t2.err_exp: tests/invalid/purity/purity.err_exp: tests/invalid/purity/purity_nonsense.err_exp: Update the expected error messages for existing test cases. tests/invalid/purity/.cvsignore: New file, copied from tests/invalid/.cvsignore. |
||
|
Fergus Henderson
|
17f53149a4 |
Implement `:- pragma reserve_tag(<TypeName>/<Arity>).'.
Estimated hours taken: 6 Branches: main Implement `:- pragma reserve_tag(<TypeName>/<Arity>).'. This has the same effect as the `--reserve-tag' option, except that it only applies to specified type, rather than to all types. doc/reference_manual.texi: Document the new feature. (However, the documentation is currently commented out.) compiler/prog_data.m: Add `reserve_tag(sym_name, arity)' to the `pragma_type' type. compiler/hlds_data.m: Add a new boolean field to the representation of discriminated union type bodies to record whether or not the type has a reserved tag. compiler/prog_io_pragma.m: Add code to parse the new pragma. compiler/make_hlds.m: Add code to process the new pragma: - check all the appropriate semantic restrictions: - the pragma must have the same visibility as the type - the type must be defined - the type must be a discriminated union type - warn if there are multiple such pragmas for the same type - call make_tags.m to recompute the tags used for the constructor. - record the presence of the reserve_tag pragma in the HLDS type definition body compiler/make_tags.m: compiler/type_util.m: Add an extra argument to assign_constructor_tags (in make_tags.m) and type_constructors_should_be_no_tag (in type_util.m) to specify whether or not there was a `reserve_tag' pragma. Reserve a tag if either this argument or the global `reserve_tag' option is set. compiler/intermod.m: Output a `:- reserve_tag' pragma whenever outputting a type to which such a pragma applies. compiler/ml_type_gen.m: compiler/ml_unify_gen.m: Ignore the reserved_tag field. XXX This means that the `reserve_tag' pragma (or the compiler option) won't have much effect if --high-level-data is set. compiler/code_util.m: compiler/det_report.m: compiler/hlds_out.m: compiler/magic_util.m: compiler/mercury_to_mercury.m: compiler/mode_util.m: compiler/module_qual.m: compiler/modules.m: compiler/post_typecheck.m: compiler/recompilation.usage.m: compiler/recompilation.version.m: compiler/special_pred.m: compiler/stack_opt.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_util.m: compiler/type_ctor_info.m: compiler/unify_gen.m: compiler/unify_proc.m: Trivial changes to handle the new reserved_tag field of hlds_type_defn_body. tests/valid/Mmakefile: tests/valid/reserve_tag.m: tests/invalid/Mmakefile: tests/invalid/reserve_tag.m: tests/invalid/reserve_tag.err_exp: Some tests of the new feature. |
||
|
Ralph Becket
|
3607da6191 |
Added infix `.' as a module separator. This is paving the way to phasing
Estimated hours taken: 3 Branches: main Added infix `.' as a module separator. This is paving the way to phasing out `:' as a module separator in order to use it as a synonym for `with_type` instead. NEWS: Report the change. compiler/prog_io.m: compiler/type_util.m: Changed so that `.'/2 is recognised as a module separator. library/ops.m: Change associativity of `.'/2 from xfy to yfx. |
||
|
Ralph Becket
|
1cdfefc8ae | Backed out last change due to wrong log message | ||
|
Ralph Becket
|
bfd2905743 |
NEWS for Mercury release 0.12:
------------------------------ HIGHLIGHTS ========== Changes to the Mercury language: * Infix `.' is now accepted as a module name separator. Changes to the Mercury compiler: * Nothing yet. Portability improvements: * Nothing yet. Changes to the Mercury debugger: * Nothing yet. Changes to the compiler back-ends: * Nothing yet. Numerous minor improvements to the Mercury standard library. DETAILED LISTING ================ Changes to the Mercury language: * Infix `.' is now accepted as a module name separator. Hence it is now possible to write io.write_string and list.member to mean the same thing as io__write_string and list__member, for instance. This has required changing the associativity of `.' from xfy to yfx and from precedence 600 to 10. Changes to the Mercury standard library: * We've added the three predicates, `is_nan/1', `is_inf/1' and `is_nan_or_inf/1' to float.m. These predicates are for use only on systems which support IEEE floating point arithmetic. * The determinisms of the following predicates in the `std_util' module have been changed from cc_nondet to cc_multi: arg_cc/3 and limited_deconstruct_cc/3 (formerly limited_deconstruct_cc/5). The success or failure of these predicates is now encoded in a maybe type. * The incorrect cc_nondet modes of the following predicates in the `deconstruct' module have been removed: arg/4, limited_deconstruct/6. cc_multi version of the predicates have been introduced where the success or failure of the predicate has been encoded into a maybe type. Changes to the extras distribution: * Nothing yet. Changes to the Mercury compiler: * Nothing yet. Portability improvements: * Nothing yet. Changes to the Mercury debugger: * Nothing yet. Changes to the compiler back-ends: * Nothing yet. NEWS for Mercury 0.11 --------------------- HIGHLIGHTS ========== Changes to the Mercury language: * Support for constrained polymorphic modes. * Addition of state variable syntax. * Improved support for higher-order functions. * Predicate and function equivalence type and mode declarations. * Support for defining predicates or functions using different clauses for different modes. * Support for Haskell-like "@" expressions. * Generalized foreign language interface. Changes to the Mercury compiler: * A new `--make' option, for simpler building of programs. * A new `--smart-recompilation' option, for fine-grained dependency tracking. * A new optional warning: `--warn-non-tail-recursion'. * A new optimization: `--constraint-propagation'. * A new optimization: `--loop-invariants'. * Support for arbitrary mappings from module name to source file name. Portability improvements: * Mac OS X is now supported "out-of-the-box". * On Windows we now support generating non-Cygwin executables. * Better conformance to ANSI/ISO C. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". * The .NET CLR back-end is much improved. Major improvements to the Mercury debugger, including: * Support for source-linked debugging using vim (rather than emacs). * Command-line completion. * Ability to display values of higher-order terms. * Declarative debugging. * Support for transparent retries across I/O. A new profiler, which we call the Mercury deep profiler or mdprof: * Supports both time and memory profiling. * Gathers information about individual call sites as well as procedures. * Eliminates the assumption that all calls to a procedure have equal cost. * Allows users to explore the gathered data interactively with a web browser. Numerous minor improvements to the Mercury standard library. A new testing tool in the extras distribution. A new regex module for string matching and search-and-replace in the extras distribution. DETAILED LISTING ================ Changes to the Mercury language: * We have added support for constrained polymorphic modes. See the section on Constrained Polymorphic Modes in the Modes chapter of the Mercury Language Reference Manual. * A more general alternative to DCG syntax has been added to the language to simplify the manipulation of threaded state. See the section on State Variables in the Syntax chapter in the Mercury Language Reference Manual. * If a higher-order function term has inst 'ground' it is now assumed to have the standard higher-order function inst 'func(in, .., in) = out is det'. This makes higher-order functional programming much easier, particularly when passing functions to polymorphic predicates. This change is not completely backwards compatible since, for safety, we must now disallow calls that would cause a variable that has a nonstandard function inst to become 'ground'. * Predicate and function type and mode declarations can now be expressed in terms of higher-order predicate and function types and insts, rather than explicitly listing the argument types and modes. This is useful where several predicates or functions must have the the same type and mode signature. For example: :- type foldl_pred(T, U) == pred(T, U, U). :- inst foldl_pred == (pred(in, in, out) is det). :- pred p `with_type` foldl_pred(T, U) `with_inst` foldl_pred. For more information see the "Predicate and function type declarations" section of the "Types" chapter and the "Predicate and function mode declarations" section of the "Modes chapter" of the Mercury Language Reference Manual. * The constructor for lists is now called '[|]' rather than '.'. `./2' will eventually become the module qualification operator. This change only affects programs which use `./2' explicitly. Programs which only use the `[H | T]' syntax will be unaffected. * We've added a new kind of expression to the language. A unification expression, written `X @ Y', unifies X and Y and returns the result. Unification expressions are most useful when writing switches: p(X, X) :- X = f(_, _). can now be written as p(X @ f(_, _), X). See the "Data-terms" section of the "Syntax" chapter of the Mercury Language Reference Manual for more details. * We've extended the language to allow you to specify different clauses for different modes of a predicate or function. This is done by putting mode annotations in the head of each clause. For example, you can write :- mode p(in). :- mode p(out). p(X::in) :- ... /* clause for the `in' mode */ p(X::out) :- ... /* clause for the `out' mode */ For predicates or functions which have different clauses for different modes, you need to either (1) add a `pragma promise_pure' declaration for the predicate or function, and ensure that the declarative semantics remains the same in each mode, or (2) declare the predicate as impure. * We now allow `:- pragma promise_semipure' declarations. For more information, see the "Impurity" chapter of the Mercury Language Reference Manual. * We've added `:- pragma c_import_module' declarations, which are used to make the C declarations for predicates and functions with `:- pragma export' declarations in the imported module visible to any C code in the importing module. `mmake' uses `:- pragma c_import_module' declarations to make sure that the header file for the imported module is built before it is needed, which it can't do if the header file is explicitly #included. * The foreign language interface has been generalized to support interfacing with languages other than C. In particular, the Mercury compiler's .NET back-end now supports interfacing with C#, IL, and "Managed C++" (C++ with Microsoft's extensions for the .NET CLR). Mercury procedures can be defined using inline code fragments written in any of these languages. For details, see the new "Foreign language interface" chapter of the Mercury Language Reference Manual. * We've removed the undocumented operators `export_adt', `export_cons', `export_module', `export_op', `export_pred', `export_sym', `export_type', `import_adt', `import_cons', `import_op', `import_pred', `import_sym', `import_type' `use_adt', `use_cons', `use_op', `use_pred', `use_sym' and `use_type'. These operators were reserved for module system extensions which are unlikely to be implemented. Changes to the Mercury standard library: * The Prolog-style term comparison operators @<, @=<, @>, @>= are now builtin. * A new builtin function ordering/2 has been added. * We've added a function to io.m to construct io__error codes from error messages: `io__make_io_error'. * The assumptions that we make about user supplied comparison predicates and functions have been relaxed to allow more general orderings. The new assumptions are documented in builtin.m. * The builtin predicates !/0 and !/2 from Mercury's Prolog heritage have been removed (`!' is now a prefix operator used in the state variable syntax). * We have added the type class `pprint__doc/1' and a new concatenation operator, `++/2', which should make it easier to construct doc values. * Performance bugs in `pprint__to_doc' have now been fixed. Even very large terms can now be converted to docs and pretty printed without causing a machine to thrash or run out of memory. * `io__read_file' and `io__read_file_as_string' now have better error handling. The result types have changed, so code using these predicates will need minor modifications. * We've added predicates `io__input_stream_foldl', `io__input_stream_foldl_io' and `io__input_stream_foldl2_io', which apply a predicate to each character of an input stream in turn. * We've added predicates `io__binary_input_stream_foldl', `io__binary_input_stream_foldl_io' and `io__binary_input_stream_foldl2_io', which apply a predicate to each byte of a binary input stream in turn. * We've added versions of `io__print', `io__write' and `io__write_univ' that allow the caller to specify how they should treat values of noncanonical types, e.g. types in which a single semantic value may have more than one syntactic expression. * We've added four new predicates to allow programs to retrieve current streams: `io__current_input_stream', `io__current_output_stream', `io__current_binary_input_stream', and `io__current_binary_output_stream'. * We've added a predicate to io.m to return the last modification time of a file: `io__file_modification_time'. * We've added cc_multi modes to io__write_list/5 and io__write_list/6. * You can now close stdin, stdout and stderr. * We've added four functions to list.m for mapping functions over corresponding members of lists: list__map_corresponding/3, list__map_corresponding3/4, list__filter_map_corresponding/3 and list__filter_map_corresponding3/4. * We've added some other new functions to list.m, namely list__last_det/2, list__split_last/3 and list__split_last_det/3. * We've added cc_multi modes to list__foldl/4 and list__foldr/4. * We've added a predicate list__map_foldl2. * As mentioned above, the constructor for lists has changed from './2' to `[|]/2'. This change affects the behaviour of the term manipulation predicates in the standard library when dealing with values of type `term__term/1' representing lists. The affected predicates are parser__read_term, parser__read_term_from_string, term__type_to_term, term__term_to_type, term_io__read_term and term_io__write_term. Also beware that std_util__functor and std_util__deconstruct now return `[|]' rather than `.' for lists, and calls to std_util__construct which construct lists may need to be updated. * We've added the predicate list__is_empty/1 and list__is_not_empty/1. * We've added the predicate list__remove_adjacent_dups/3. * We've added a function version of error/1, called func_error/1, to require.m. * ops.m now defines a typeclass which can be used to define operator precedence tables for use by parser.m and term_io.m. See samples/calculator2.m for an example program. The `ops__table' type has been renamed `ops__mercury_op_table'. `ops__init_op_table' has been renamed `ops__init_mercury_op_table'. `ops__max_priority' is now a function taking an operator table argument. * The predicates and functions in int.m, float.m, math.m and array.m now generate exceptions rather than program aborts on domain errors and out-of-bounds array accesses. There are new functions `float__unchecked_quotient/2', `int__unchecked_quotient/2' and `int__unchecked_rem/2' for which no checking is performed and the behaviour if the right operand is zero is undefined. * We've removed the reverse modes of the arithmetic functions in float.m and extras/complex_numbers. (Because of rounding errors, the functions aren't actually reversible.) * float__pow now works for negative exponents, and runs much faster for large exponents. * We've removed the destructive update modes of string__set_char, string__set_char_det and string__unsafe_set_char. The compiler currently always stores constant strings in static data, even if they are passed to procedures with mode `di', so any attempt to update a constant string will cause a crash. Fixing this properly will be a lot of work, so for now we have just removed the modes. * We've added string__suffix, string__words/1, string__foldr, string__foldl_substring and string__foldr_substring. * The exception module has a new predicate `try_store', which is like `try_io', but which works with stores rather than io__states. * We've fixed a bug in time.m. Type `tm' didn't store the day of the month, which meant that the functions which required that field (e.g. time__asctime, time__mktime) did not work. The order of the fields of type `time__tm' has been changed so that comparison of values of type `tm' whose `tm_dst' fields are identical is equivalent to comparison of the times those values represent. * std_util.m now contains predicates and functions `map_maybe', `fold_maybe', `map_fold_maybe' and `map_fold2_maybe', which are analogues of `list__map', `list__foldl', `list__map_foldl' and `list__map_foldl2' operating on values of type `maybe' instead of `list'. * We've added a predicate to io.m to return the last modification time of a file (io__file_modification_time). * There is a variant of io__call_system, io__call_system_return_signal which on interrupt returns the number of the signal which interrupted the command rather than just an error message. * We've added added several new predicates for deconstructing terms to std_util.m. `named_argument' and `det_named_argument' are analogous to `argument' and `det_argument' respectively, but specify the desired argument by its name, not its position. We have also added committed choice version of all the predicates that deconstruct terms. These differ from the existing versions in that they do not abort when called upon to deconstruct non-canonical terms, such as values of types with user-defined equality. * We've added a new predicate `intersect_list' in each of the modules implementing sets in the Mercury standard library. * We've added a predicate version of `set__fold'. * We've added function versions of `builtin__unsafe_promise_unique', `ops__init_op_table' and `ops__max_priority'. * We've added a version of `getopt__process_options' which returns the option arguments. * `getopt__process_options' has been modified to allow negation of accumulating options. Negating an accumulating option empties the accumulated list of strings. * We've added some functions to the term_io module to return printable representations of term components as strings. * We've made the outputs of the string concatenation primitives unique. * New convenience/readability predicates `int__even/1' and `int__odd/1'. * New predicate benchmark_det_io for benchmarking code that performs I/O. * We've removed the long obsolete `int__builtin_*' and `float__builtin_float_*' predicates, which were synonyms for the arithmetic functions dating from when Mercury didn't have functions. * We've added int:'/'/2 as a synonym for int:'//'/2 and false/0 as a built-in synonym for fail/0 (both left-overs from Mercury's Prolog heritage.) * dir:'/'/2 is now a synonym for `dir__make_path_name'. * We've removed the long obsolete predicates `io__read_anything', `io__write_anything', and `io__print_anything', which were long ago renamed as `io__read', `io__write', and `io__print' respectively. * We've added random__random/5, which produces a random integer in a given range, and random__randcount/3, which returns the number of distinct random numbers that can be generated. Changes to the extras distribution: * The lex subdirectory now contains a new module, regex, which provides for more traditional string-based ways of defining regular expressions and provides string matching and search-and-replace functionality. * There's a new testing tool called "quickcheck", which is similar to Haskell's "QuickCheck". See quickcheck/tutes/index.html. * The interface to Moose has been changed in a non-backwards compatible way to support user-defined modes for the parser state and integrate better with lex. Changes to the Mercury compiler: * There is a new `--make' option which performs most of the functions of Mmake. The advantages of `mmc --make' are that no `mmake depend' step is necessary and the dependencies are more accurate. Parallel builds are not yet supported. See the "Using Mmake" chapter of the "Mercury User's Guide" for details. * The Mercury compiler can now perform smart recompilation, enabled by the `--smart-recompilation' option. With smart recompilation, when the interface of a module changes, only modules which use the changed declarations are recompiled. Smart recompilation does not yet work with `--intermodule-optimization'. * The Mercury compiler can now handle arbitrary mappings from source files to module names. If the program contains modules for which the source file name does not match the module name, before generating the dependencies the command `mmc -f SOURCES' must be run, where `SOURCES' is a list of the names of all of the source files. If the names of the source files all match the contained module names, `mmc -f' need not be run. * There is a new `--use-grade-subdirs' option which is similar to `--use-subdirs', but allows multiple grades to be built in a directory at the same time. `--use-grade-subdirs' does not work with Mmake (it does work with `mmc --make'). * The compiler and scripts accept a `--mercury-stdlib-dir' option, which overrides the configured location of the Mercury standard library. There is also an environment variable MERCURY_STDLIB_DIR which has the same effect. The environment variables which were previously used to override the location of the standard library (MERCURY_ALL_C_INCL_DIRS, MERCURY_ALL_MC_C_INCL_DIRS, MERCURY_INT_DIR, MERCURY_C_LIB_DIR, MERCURY_MOD_LIB_MODS, MERCURY_TRACE_LIB_MODS) are now deprecated, and will be removed in a future release. MERCURY_C_INCL_DIR has already been removed. * We've added a new compiler option `--warn-non-tail-recursion', which causes the compiler to issue a warning about any directly recursive call that is not a tail call. * The automatically generated header files for modules containing `pragma export' declarations are now named `<module>.mh', not `<module>.h'. This avoids conflicts with system header files. * We've fixed a long-standing bug in the handling of module imports. Previously, if `module1' imported `module2' which imported `module3' in its interface section, then any types, insts, modes and typeclasses defined in the interface of `module3' could be used in `module1' even if `module1' did not import `module3' directly. This change will break some existing programs, but that is easily fixed by adding any necessary `:- import_module' or `:- use_module' declarations. * Options for the Mercury runtime can now be set at compile time using the new `--runtime-flags' option of ml and c2init. * We've added a new optimization pass -- constraint propagation. Constraint propagation attempts to transform the code so that goals which can fail are executed as early as possible. It is enabled with the `--constraint-propagation' option (or `--local-constraint-propagation' for a more restricted version of the transformation). * The Mercury compiler can now perform inter-module optimization using information from transitively imported modules. This is especially useful for back-ends which do not support abstract equivalence types properly (for example the .NET backend). To disable this behaviour and only optimize using information from directly imported modules, use the option `--no-read-opt-files-transitively'. * For each `--Xflags' option there is now a `--Xflag' option which allows a single quoted argument to be passed to the invoked program. This is useful where the argument is a directory name containing spaces. * The `--convert-to-goedel' option has been removed. It never really worked anyway. Portability improvements: * Mac OS X is now supported "out-of-the-box". See README.MacOSX for details. * On Windows we now support generating non-Cygwin executables. The Mercury compiler source distribution can be configured using `configure --with-cc="gcc -mno-cygwin"'. This option ensures that the Mercury libraries are only linked with the standard Windows libraries, not the Cygwin Unix emulation library, so Mercury programs don't need Cygwin, and use DOS/Windows-style path names rather than Cygwin's Unix-style path names. Note that you still need Cygwin to install and use Mercury. The change is that the programs which you build using Mercury don't need Cygwin anymore. * Better conformance to ANSI/ISO C. We now pass all the tests in the Mercury test suite when the compiler is built with the "lcc" C compiler, which is more strict about ANSI/ISO C conformance than GNU C. This should also make it easier to port to other C compilers. Changes to the Mercury debugger: * The debugger can now print goals just as Prolog debuggers do. At an exit port of e.g. append, the command "print goal" will print the current goal in a form such as "append([1], [2], [1, 2])". * You can now navigate terms in the debugger by argument name as well as by argument number. * The debugger can now print higher order values. * The debugger can now print type_info structures. However, since such structures are normally of interest to implementors only, the debugger will print such values only if the user gives the command "print_optionals on". * The debugger can now perform command line completion when compiled with GNU Readline support enabled. * We've added a 'view' command to `mdb', which opens a `vim' window and in it displays the current source location, updated at each event. This requires X11 and a version of `vim' with the `clientserver' feature enabled. * The `--window' mdb option now creates a window for mdb, not the program. The main advantage of the new behaviour is that redirection of the program's input and output works. The old behaviour is still available with `mdb --program-in-window'. * The debugger now includes support for declarative debugging. The `dd' command starts diagnosis at any exit, fail or exception port in mdb. See the Mercury User's Guide for more details. * When a program is compiled in a debugging grade, the debugger can be asked, via the command `table_io start', to make I/O primitives (such as io__open_file, io__write_string etc) idempotent. This means that a given call to e.g. io__open_file will open the specified file only once, even if retry commands cause the call to be executed more than once. A new profiler, which we call the Mercury deep profiler or mdprof: * The old Mercury profiler is based on the technology of the standard Unix profiler gprof. This technology makes the assumption that all calls to a given C function (in Mercury, a given function or predicate in a given mode) have the same cost, whether the cost being measured is CPU time, memory cells allocated, memory words allocated etc. In C programs, this assumption is usually close enough to correct for the output of gprof to be useful. In Mercury, due to the presence of parametric polymorphism and the significantly higher frequency of higher order code, different call sites are far more likely to have distinct performance characteristics than in C, so the output of a gprof-style profiler is usually not accurate enough to be useful. The new profiler records, for each of its measurements, not just the current predicate/function and its caller, but the entire chain of ancestors. This "deep context" is what gives the profiler its name. Actually, to keep overheads down, we don't walk the stack at every measurement; we just associate the current context with each measurement, and update the current context when it changes. Given this fact, it costs very little extra to record measurements on every aspect of performance (counts of calls, exits, fails and redos, counts of memory cells and memory words allocated, and time spent). We thus have only one deep profiling grade component, .profdeep, as opposed to the old profiler which has several grade components for different subsets of these measurements. * The deep context recorded by the deep profiler records the identities of the call sites as well as the identities of predicates and functions in the list of ancestors. If a predicate p contains two calls to predicate q, this allows the deep profiler to report that one call to q costs next to nothing while the other one is a major performance problem. * The deep profiler gathers so much data that giving it to the user all at once would swamp the user with too much information. We therefore implemented the deep profiler as a CGI program. Users can use thus use a web browser to explore the information contained in profiling data files. * The deep profiler currently does not handle programs that catch exceptions. * Further information about the deep profiler is available in the paper "Deep profiling: engineering a profiler for a declarative programming language" by Thomas C. Conway and Zoltan Somogyi, available from our web site at <http://www.cs.mu.oz.au/mercury/information/papers.html#mu_01_24>. Changes to the compiler back-ends: * The native code Linux/x86 back-end is now "release quality". The native code back-end, which was first released in Mercury 0.10, compiles directly to assembler, rather than than going via C. This back-end is enabled using the `--target asm' option. It is implemented by linking the Mercury compiler with the (relatively) language independent GNU Compiler Collection back-end. In other words, it is a Mercury front-end for GCC. This release is the first to be based on an officially released version of GCC (it is based on GCC 3.2). In this release, the native code back-end now passes all of the applicable tests in the Mercury test suite, including bootstraping the Mercury compiler. Currently it is only supported on i*86-pc-linux-gnu (Intel x86-based PCs running Linux). For details see <http://www.cs.mu.oz.au/mercury/download/gcc-backend.html>. * .NET CLR back-end much improved. The .NET CLR back-end, which generates MSIL code for Microsoft's new .NET Common Language Runtime, has been substantially improved. Mercury data structures are mapped to .NET CLR data types in a more natural and more efficient manner. A lot more of the standard library is now supported. Text files on Windows are now output with proper Windows CR-LF line endings. Many bugs have been fixed. This back-end supports the whole of the Mercury language, but the Mercury standard library implementation for the .NET CLR is still not yet complete. The .NET CLR back-end now passes about half of the tests in the Mercury test suite. This back-end is selected when you use the `--grade il' option. See <http://www.cs.mu.oz.au/mercury/dotnet.html> and/or <http://www.cs.mu.oz.au/mercury/information/dotnet/mercury_and_dotnet.html>. For news about earlier versions, see the HISTORY file. |
||
|
Ralph Becket
|
54255f93e7 |
Make the Prolog term comparison operators (@<, @=<, @>, @>=)
Estimated hours taken: 32 Branches: main Make the Prolog term comparison operators (@<, @=<, @>, @>=) builtin since they're often useful and calling compare/3 can look a little awkward. Simplification now applies the following transformations on the new builtin operators: X @< Y ---> some [R] (compare(R, X, Y), R = (<)) X @=< Y ---> some [R] (compare(R, X, Y), R \= (>)) X @> Y ---> some [R] (compare(R, X, Y), R = (>)) X @>= Y ---> some [R] (compare(R, X, Y), R \= (<)) compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/table_gen.m: Added `only_mode' argument to calls to goal_util__generate_simple_call which now has an extra parameter. compiler/goal_util.m: Added a new parameter, ModeNo, to goal_util__generate_simple_call. ModeNo is either - `only_mode' in which case the predicate in question is expected to have exactly one mode or - `mode_no(N)' in which case mode number N (counting from 0) is used. The inequality transformation uses this to handle calls to compare/3 with unique arguments (even though the builtin inequality modes don't yet handle ui arguments...) compiler/simplify.m: simplify__goal_2 for calls now makes a decision as to whether to call simplify__call_goal or simplify__inequality_goal. The bulk of simplify__goal_2 is now in simplify__call_goal. The inequality transformation is handled in simplify__inequality_goal. compiler/type_util.m: Added comparison_result_type constant. compiler/NEWS: Mention these changes. library/builtin.m: Added the inequalities as built-ins. Added the function ordering/2. library/prolog.m: Removed the definitions for @< etc. |
||
|
Simon Taylor
|
0387a6e9c2 |
Improvements for `:- pragma foreign_type'.
Estimated hours taken: 10
Branches: main
Improvements for `:- pragma foreign_type'.
- Allow default Mercury definitions. The Mercury definition must define
a discriminated union type. The constructors of the Mercury type are
only visible in predicates which have implementations for all the
foreign languages the type has implementations for. In all other
predicates the type is treated as an abstract type (the check for
this isn't quite right).
- Allow polymorphic foreign types.
- Don't require the `:- pragma foreign_type' for exported foreign types
to be in the interface. We now only require that all definitions
have the same visibility.
compiler/prog_data.m:
compiler/prog_io_pragma.m:
Allow polymorphic foreign types.
compiler/prog_io.m:
Export code to parse the type name in a type definition for
use by prog_io_pragma.m.
compiler/make_hlds.m:
Handle Mercury definitions for foreign types.
Separate out the code to add constructors and special predicates
to the HLDS into a separate pass. For foreign types, we don't know
what to add until all type definitions have been seen.
Use the C definition for foreign types with `--target asm'.
compiler/modules.m:
Distinguish properly between `exported' and `exported_to_submodules'.
Previously, if a module had sub-modules, all declarations,
including those in the interface, had import_status
`exported_to_submodules'. Now, the declarations in the
interface have status `exported' or `abstract_exported'.
This is needed to check that the visibility of all the
definitions of a type is the same.
compiler/hlds_pred.m:
Add a predicate status_is_exported_to_non_submodules, which
fails if an item is local to the module and its sub-modules.
compiler/hlds_data.m:
compiler/*.m:
Record whether a du type has foreign definitions as well.
Also record whether uses of the type or its constructors
need to be qualified (this is needed now that adding
the constructors to the HLDS is a separate pass).
compiler/typecheck.m:
Check that a predicate or function has foreign clauses before
allowing the use of a constructor of a type which also has
foreign definitions.
compiler/hlds_pred.m:
compiler/make_hlds.m:
Simplify the code to work out the goal_type for a predicate.
compiler/hlds_out.m:
Don't abort on foreign types.
Print the goal type for each predicate.
compiler/error_util.m:
Handle the case where the message being written is a
continuation of an existing message, so the first line
should be indented.
compiler/module_qual.m:
Remove unnecessary processing of foreign types.
doc/reference_manual.tex:
Document the change.
Update the documentation for mixing Mercury and foreign clauses.
The Mercury clauses no longer need to be mode-specific.
tests/hard_coded/Mmakefile:
tests/hard_coded/foreign_type2.{m,exp}:
tests/hard_coded/foreign_type.m:
tests/hard_coded/intermod_foreign_type.{m,exp}:
tests/hard_coded/intermod_foreign_type2.m:
tests/invalid/Mmakefile:
tests/invalid/foreign_type_2.{m,err_exp}:
tests/invalid/foreign_type_visibility.{m,err_exp}:
Test cases.
tests/invalid/record_syntax.err_exp:
Update expected output.
|
||
|
Fergus Henderson
|
7597790760 |
Use sub-modules to structure the modules in the Mercury compiler directory.
The main aim of this change is to make the overall, high-level structure of the compiler clearer, and to encourage better encapsulation of the major components. compiler/libs.m: compiler/backend_libs.m: compiler/parse_tree.m: compiler/hlds.m: compiler/check_hlds.m: compiler/transform_hlds.m: compiler/bytecode_backend.m: compiler/aditi_backend.m: compiler/ml_backend.m: compiler/ll_backend.m: compiler/top_level.m: New files. One module for each of the major components of the Mercury compiler. These modules contain (as separate sub-modules) all the other modules in the Mercury compiler, except gcc.m and mlds_to_gcc.m. Mmakefile: compiler/Mmakefile: Handle the fact that the top-level module is now `top_level', not `mercury_compile' (since `mercury_compile' is a sub-module of `top_level'). compiler/Mmakefile: Update settings of *FLAGS-<modulename> to use the appropriate nested module names. compiler/recompilation_check.m: compiler/recompilation_version.m: compiler/recompilation_usage.m: compiler/recompilation.check.m: compiler/recompilation.version.m: compiler/recompilation.version.m: Convert the `recompilation_*' modules into sub-modules of the `recompilation' module. compiler/*.m: compiler/*.pp: Module-qualify the module names in `:- module', `:- import_module', and `:- use_module' declarations. compiler/base_type_info.m: compiler/base_type_layout.m: Deleted these unused empty modules. compiler/prog_data.m: compiler/globals.m: Move the `foreign_language' type from prog_data to globals. compiler/mlds.m: compiler/ml_util.m: compiler/mlds_to_il.m: Import `globals', for `foreign_language'. Mmake.common.in: trace/Mmakefile: runtime/Mmakefile: Rename the %.check.c targets as %.check_hdr.c, to avoid conflicts with compiler/recompilation.check.c. |
||
|
Zoltan Somogyi
|
41a27af862 |
Change type_id to the more descriptive type_ctor everywhere.
Estimated hours taken: 6 Branches: main compiler/*.m: Change type_id to the more descriptive type_ctor everywhere. |
||
|
Fergus Henderson
|
ceae383ec2 |
Fix some bugs with the hlc.agc grade where the compiler was generating
Estimated hours taken: 2 Branches: main Fix some bugs with the hlc.agc grade where the compiler was generating references to type_info variables that were not in scope. compiler/hlds_pred.m: Document the invariant that type_info arguments must precede non-type_info arguments, since MLDS->C accurate GC relies on this. compiler/type_util.m: Add new function put_typeinfo_vars_first, for use by lamdbda.m and ml_code_gen.m. compiler/lambda.m: Call put_typeinfo_vars_first on the arguments of the introduced procedures, to ensure that invariant documented in hlds_pred.m holds. compiler/ml_code_gen.m: Call put_typeinfo_vars_first on the list of local variables that we generate for each subgoal, to avoid referring to type_info variables that are not in scope in the GC tracing code. |
||
|
Fergus Henderson
|
7622e889e0 |
Define the `heap_pointer' type in private_builtin.m as a new builtin
Estimated hours taken: 2 Branches: main Define the `heap_pointer' type in private_builtin.m as a new builtin type with representation MR_TYPECTOR_REP_HP, rather than as equivalent to `c_pointer'. This is needed so that the accurate garbage collector can tell saved heap pointer values apart from other c_pointer values, which it needs to do in order to handle saved heap pointer values. library/private_builtin.m: runtime/mercury.h: runtime/mercury.c: Define the type_ctor_info etc. for the heap_pointer type. compiler/type_util.m: Add a new function `heap_pointer_type'. compiler/add_heap_ops.m: Use `heap_pointer_type' from type_util.m. |
||
|
Fergus Henderson
|
3e8cc77012 |
Various bug fixes for accurate GC with the MLDS->C back-end.
Estimated hours taken: 16 Branches: main Various bug fixes for accurate GC with the MLDS->C back-end. runtime/mercury.c: Fix a typo in the definition of the `stack_chain' global. compiler/ml_code_util.m: compiler/ml_call_gen.m: Fix several bugs: - generate appropriate GC tracing code for tracing type_infos and typeclass_infos. These need to be handled specially because of the parameters of private_builtin:type_info/1 etc. don't affect the representation of the type, and need to be ignored (to avoid infinite recursion). - don't generate GC tracing code for no_type_info_builtin procedures, because the generated GC tracing code would refer to type_info arguments that don't get passed. - in ml_call_gen.m, we were generating incorrect GC tracing code for the `conv_*' variables introduced to hold output arguments of polymorphically typed procedures. compiler/type_util.m: library/private_builtin.m: Add types `sample_type_info' and `sample_typeclass_info', so that ml_code_util.m can use them when tracing type_infos and typeclass_infos (respectively). library/private_builtin.m: Fix some software rot in gc_trace/1: add `MR_eng_' prefixes. library/io.m: runtime/mercury_library_types.h: runtime/mercury_file.c: Implement stream ids for NATIVE_GC. |
||
|
Fergus Henderson
|
a4f23438f0 |
Fix a typo in a comment that Simon Taylor pointed out in his
Estimated hours taken: 0.1 Branches: main compiler/type_util.m: Fix a typo in a comment that Simon Taylor pointed out in his code review. |
||
|
Fergus Henderson
|
116cea5c24 |
Fix a bug in the --high-level-data version of the .NET back-end,
Branches: main Estimated hours taken: 16 Fix a bug in the --high-level-data version of the .NET back-end, where when constructing data types with polymorphically typed fields, we were calling the constructor with incorrect (unboxed) argument types. It was documented in mlds.m that handling this boxing/unboxing was the responsibility of the MLDS->target code generator, but the MLDS didn't contain enough information (in particular it was missing the unsubstituted constructor argument types for new_object statements). So I ended up fixing it by doing this boxing in the HLDS->MLDS code generator. This makes it more consistent with how we handle other cases where boxing/unboxing is needed. compiler/mlds.m: Update the documentation about who is responsible for handling boxing/unboxing for `new_object' statements (and improve the documentation about the same issue for `field' rvals). compiler/ml_unify_gen.m: When generating new_object statements, look up the original (unsubstituted) types for the constructor arguments, and where necessary box the actual arguments to match. compiler/mlds_to_il.m: Don't box arguments of new_object statements, since this is now done in ml_unify_gen.m. compiler/type_util.m: Export type_util__get_cons_defn, for use by ml_unify_gen.m. Add some comments. compiler/ml_code_util.m: compiler/mlds_to_c.m: Improve the comments. compiler/mlds_to_c.m: Avoid generating some unnecessary casts. |
||
|
David Overton
|
40bda1e4a0 |
Fix a bug in inst_merge when merging a ground inst with a bound inst
Estimated hours taken: 8
Branches: main
Fix a bug in inst_merge when merging a ground inst with a bound inst
containing 'any' insts. Previously,
inst_merge(ground, bound(f(..., any, ...)))
would return a result of 'any' which is not as accurate as we would
like (e.g. this problem occurs often in Mercury code generated by the
HAL compiler). To improve this, we pass the type of the variable
being merged to inst_merge and when this situation arises we expand
'ground' to 'bound(<functors of type>)' and use this inst in the
merge.
An alternative to passing the types through inst_merge would be to
reinstate the use of 'typed_inst' and 'typed_ground' which are created
by (currently commented out) code in 'propagate_types_into_insts'.
However, this has previously been found to cause performance problems
since it greatly expands the size of all insts and instmaps in the
program. The approach used here is the same as that adopted for
inst_matches_{initial,final} some time ago, where it does not appear
to have a noticeable performance impact on typical programs.
compiler/inst_util.m:
Pass types through inst_merge and implement the changes to
inst_merge(ground, bound(...)) described above.
compiler/inst_match.m:
compiler/instmap.m:
compiler/mode_util.m:
compiler/simplify.m:
Pass types to calls to inst_merge.
compiler/inst_match.m:
compiler/type_util.m:
Move 'maybe_get_cons_id_arg_types' and
'maybe_get_higher_order_arg_types' from inst_match.m to
type_util.m and export them.
compiler/mode_util.m:
Export 'constructors_to_bound_insts'.
tests/valid/Mmakefile:
tests/valid/merge_ground_any.m :
Add a regression test.
tests/invalid/Mmakefile:
tests/invalid/merge_ground_any.err_exp:
tests/invalid/merge_ground_any.m:
Add a test to make sure the ground inst is expanded out to the
full set of functors for the type.
|
||
|
Simon Taylor
|
ad0aa5b60e |
Allow user-defined types with a single constructor `{}/1'
Estimated hours taken: 1
Branches: main
compiler/type_util.m:
Allow user-defined types with a single constructor `{}/1'
to be treated as no-tag types. Unary tuples aren't treated
as no-tag types because it would significantly complicate
the implementation.
Use more descriptive variable names.
Simplify some code using std_util__map_maybe.
|
||
|
David Overton
|
f21676c3a6 |
When testing for type_info types, check that the type is in
Estimated hours taken: 0.5 Branches: main compiler/type_util.m: When testing for type_info types, check that the type is in the 'private_builtin' module. This allows user-defined types to use the names 'type_info', 'type_ctor_info', etc. This change is required to allow the new module rtti_implementation.m to compile in reserved_tag grades. The compiler was assuming that the types in this module were the builtin type_info types and was not using the reserved_tag representation for them. |
||
|
Simon Taylor
|
9dd11b2fc6 |
Smart recompilation. Record version numbers for each item
Estimated hours taken: 400
Smart recompilation. Record version numbers for each item
in interface files. Record which items are used in each compilation.
Only recompile a module if the output file does not exist or
nothing has changed.
There is still some work to do on this:
- it doesn't work with inter-module optimization.
- it doesn't work when the module name doesn't match the file name.
(this problem will go away when mmake functionality is moved into
the compiler.
I'll hold off documenting this change in the NEWS file and
on the web page for a month or so, until I've had a bit more
experience using it.
compiler/options.m:
compiler/handle_options.m:
doc/user_guide.texi:
Add an option `--smart-recompilation', currently off by default.
Add an internal option `--generate-version-numbers' to control
whether version numbers are written to the interface files. If
`--smart-recompilation' is disabled because the module
is being compiled with `--intermodule-optimization' (e.g. in the
standard library), we still want to write the version numbers
to the interface files.
Add an option `--verbose-recompilation' (default off)
to write messages describing why recompilation is needed.
Add an option `--warn-smart-recompilation' (default on)
to control warnings relating to the smart recompilation
system. Warn if smart recompilation will not work with
the output and inter-module optimization options given.
compiler/recompilation.m:
Type declarations for smart recompilation.
Predicates to record program items used by compilation.
compiler/recompilation_version.m:
Compute version numbers for program items in interface files.
compiler/recompilation_usage.m:
Find all items used by a compilation.
compiler/recompilation_check.m:
Check whether recompilation is necessary.
compiler/timestamp.m:
Timestamp ADT for smart recompilation.
compiler/mercury_compile.m:
Invoke the smart recompilation passes.
compiler/modules.m:
compiler/prog_io.m:
Return timestamps for modules read.
When reading a module make sure the current input stream
is reset to its old value, not stdin.
Handle version number items in interface files.
compiler/module_qual.m:
compiler/unify_proc.m:
compiler/make_hlds.m:
Record all items used by local items.
compiler/make_hlds.m:
Process `:- pragma type_spec' declarations in
add_item_list_clauses. The qual_info is needed
when processing `:- pragma type_spec' declarations
so that any equivalence types used by the declaration
can be recorded as used by the predicate or function to
which the `:- pragma type_spec' applies.
compiler/equiv_type.m:
For each imported item, record which equivalence types
are used by that item.
compiler/hlds_module.m:
Add a field to the module_info to store information about
items used during compilation of a module.
compiler/check_typeclass.m:
Make sure any items used in clauses for typeclass method
implementations are recorded in the `.used' file.
compiler/prog_data.m:
compiler/*.m:
Factor out some duplicated code by combining the
pred and func, and pred_mode and func_mode items.
Make it easier to extract the name of a type, inst or mode
from its declaration.
Add an item type to hold the version numbers for an interface file.
Allow warnings to be reported for `nothing' items (used for
reporting when version numbers are written using an
obsolete format).
compiler/prog_io.m:
compiler/prog_io_util.m:
compiler/typecheck.m:
compiler/type_util.m:
compiler/*.m:
Strip contexts from all types, not just those in class constraints.
This makes it possible to use ordinary unification to check
whether items have changed (with the exception of clauses).
Remove code to create types with contexts in typechecking.
Remove code scattered through the compiler to remove contexts
from types in class constraints.
compiler/hlds_pred.m:
compiler/prog_util.m:
Move hlds_pred__adjust_func_arity to prog_util, so that it
can be used by the pre-hlds passes.
compiler/typecheck.m:
compiler/hlds_module.m:
Move typecheck__visible_modules to hlds_module.m, so it can
be used by recompilation_usage.m.
compiler/typecheck.m:
Add a comment telling where updates may be required if the
code to typecheck a var-functor unification changes.
compiler/error_util.m:
Allow writing messages without contexts (used for the verbose
recompilation messages).
Add functions to format sym_name and sym_name_and_arity,
and to add punctuation to the end of an error message
without unwanted line breaks before the punctuation.
scripts/Mmake.rules:
compiler/modules.m:
Don't remove the output file before running the compiler. We need
to leave the old output file intact if smart recompilation detects
that recompilation is not needed.
compiler/notes/compiler_design.html:
Document the new modules.
library/io.m:
NEWS:
Add predicates to find the modification time of files
and input_streams.
library/set.m:
NEWS:
Add a predicate version of set__fold
Don't sort the output of set__filter, it's already sorted.
library/std_util.m:
NEWS:
Add a predicate `std_util__map_maybe/3' and a function
`std_util__map_maybe/2' to apply a predicate or a function to
a value stored in a term of type `std_util__maybe'.
configure.in:
runtime/mercury_conf.h.in:
runtime/RESERVED_MACRO_NAMES:
When checking whether the compiler is recent enough, check for
the --warn-smart-recompilation option.
Check for stat().
library/Mmakefile:
Disable warnings about smart recompilation not working with
`--intermodule-optimization'.
browser/Mmakefile:
Disable warnings about smart recompilation not working when
the module name doesn't match the file name.
runtime/mercury_string.h:
Add a macro MR_make_string_const() which automates computation
of the length of string argument to MR_string_const().
tests/recompilation/Mmakefile:
tests/recompilation/runtests:
tests/recompilation/test_functions:
tests/recompilation/TESTS:
tests/recompilation/README:
A framework for testing smart recompilation.
The option currently only works for the recompilation directory.
tests/recompilation/TEST.m.{1,2}:
tests/recompilation/TEST_2.m.{1,2}:
tests/recompilation/TEST.exp.{1,2}:
tests/recompilation/TEST.err_exp.2:
Test cases, where TEST is one of add_constructor_r, add_instance_r,
add_instance_2_r, add_type_nr, change_class_r, change_instance_r,
change_mode_r, field_r, func_overloading_nr, func_overloading_r,
lambda_mode_r, nested_module_r, no_version_numbers_r,
pragma_type_spec_r, pred_ctor_ambiguity_r, pred_overloading_r,
add_type_re, remove_type_re, type_qual_re.
tests/handle_options:
Add an option `-e' to generate any missing expected output files.
|
||
|
Zoltan Somogyi
|
04e614485d |
Implement deep profiling; merge the changes on the deep2 branch back
Estimated hours taken: 500 Branches: main Implement deep profiling; merge the changes on the deep2 branch back onto the trunk. The main documentation on the general architecture of the deep profiler is the deep profiling paper. doc/user_guide.texi: Document how to use the deep profiler. deep_profiler: deep_profiler/Mmakefile: A new directory holding the deep profiler and its mmakefile. Mmakefile: Add targets for the new directory. Add support for removing inappropriate files from directories. deep_profiler/interface.m: The deep profiler consists of two programs: mdprof_cgi.m, which acts as a CGI "script", and mdprof_server.m, which implements the server process that the CGI script talks to. Interface.m defines the interface between them. script/mdprof.in: A shell script template. ../configure uses it to generate mdprof, which is a wrapper around mdprof_cgi that tells it how to find mdprof_server. deep_profiler/mdprof_cgi.m: The CGI "script" program. deep_profiler/mdprof_server.m: The top level predicates of the server. deep_profiler/profile.m: The main data structures of the server and their operations. deep_profiler/read_profile.m: Code for reading in profiling data files. deep_profiler/startup.m: Code for post-processing the information in profiling data files, propagating costs from procedures to their ancestors and performing various kinds of summaries. deep_profiler/server.m: Code for responding to requests from the CGI script. deep_profiler/cliques.m: Code to find cliques in graphs. deep_profiler/array_util.m: deep_profiler/util.m: Utility predicates. deep_profiler/dense_bitset.m: An implementation of (part of) the set ADT with dense bit vectors. deep_profiler/measurements.m: Operations on profiling measurements. deep_profiler/timeout.m: An implementation of a timeout facility. deep_profiler/conf.m: Functions that depend on autoconfigured settings. configure.in: Find out what command to use to find the name of the local host. Install deep profiling versions of the standard library along with the other profiling versions. runtime/mercury_conf.h.in: Add some macros for deep_profiler/conf.m to use. library/profiling_builtin.m: runtime/mercury_deep_call_port_body.h: runtime/mercury_deep_leave_port_body.h: runtime/mercury_deep_redo_port_body.h: A new library module that implements deep profiling primitives. Some of these primitives have many versions, whose common code is factor is factored out in three new include files in the runtime. compiler/deep_profiling.m: New module to perform the program transformations described in the paper. compiler/notes/compiler_design.html: Document the new compiler module. compiler/mercury_compiler.m: Invoke the new module in deep profiling grades. Allow global static data to be generated by deep_profiling.m. compiler/options.m: Add options to turn on deep profiling and (for benchmarking purposes) control its implementation. Add an optiooption disable tailcall optimization in the LLDS backend, to help benchmarking deep profiling. compiler/jumpopt.m: compiler/optimize.m: Obey the option to disable tailcalls. compiler/handle_options.m: Handle the implications of deep profiling. compiler/modules.m: In deep profiling grades, automatically import profiling_builtin.m. compiler/prog_util.m: doc/Makefile: library/library.m: Handle the new builtin module. compiler/export.m: In deep profiling grades, wrap deep profiling code around exported procedures to handle the "unscheduled call" aspects of callbacks to Mercury from the foreign language. compiler/higher_order.m: profiler/demangle.m: util/demangle.c: When creating a name for a higher-order-specialized predicate, include the mode number in the name. compiler/add_trail_ops.m: compiler/type_util.m: Move c_pointer_type from add_trail_ops to type_util, so it can also be used by deep_profiling.m. compiler/hlds_goal.m: Add a new goal feature that marks a tail call, for use by deep_profiling.m. compiler/hlds_pred.m: Add a new field to proc_info structures for use by deep_profiling.m. Add a mechanism for getting proc_ids for procedure clones. Remove next_proc_id, an obsolete and unused predicate. compiler/hlds_data.m: Add a new cons_id to refer to the proc_static structure of a procedure. compiler/bytecode_gen.m: compiler/code_util.m: compiler/dependency_graph.m: compiler/hlds_out.m: compiler/mercury_to_mercury.m: compiler/ml_unify_gen.m: compiler/opt_debug.m: compiler/prog_rep.m: compiler/rl_exprn.m: compiler/switch_util.m: compiler/unify_gen.m: Trivial changes to handle the new cons_id, goal feature and/or proc_info argument. compiler/rtti.m: Add a utility predicate for extracting pred_id and proc_id from an rtti_proc_label, for use by hlds_out.m compiler/layout.m: compiler/layout_out.m: compiler/llds.m: compiler/llds_common.m: Add support for proc_static and call_site_static structures. compiler/layout_out.m: compiler/llds_out.m: Add code for the output of proc_static structures. compiler/code_util.m: Make code_util__make_proc_label_from_rtti a function, and export it. util/mkinit.c: compiler/llds_out.m: compiler/layout.m: compiler/modules.m: Add support for a fourth per-module C function, for writing out proc_static structures (and the call_site_static structures they contains). Since proc_static structures can be referred to from LLDS code (and not just from other static structures and compiler-generated C code), reorganize the declarations of static structures slightly. Change the schema for the name of the first per-module C function slightly, to make it the addition of the fourth function easier. The scheme now is: mercury__<modulename>__init mercury__<modulename>__init_type_tables mercury__<modulename>__init_debugger mercury__<modulename>__write_out_proc_statics Improve formatting of the generated C code. library/*.m: runtime/mercury.c: runtime/mercury_context.c: runtime/mercury_engine.c: runtime/mercury_ho_call.c: runtime/mercury_tabling.c: runtime/mercury_trace_base.c: runtime/mercury_wrapper.c: trace/mercrury_trace.[ch]: trace/mercrury_trace_declarative.c: trace/mercrury_trace_external.c: trace/mercrury_trace_internal.c: Conform to the new scheme for initialization functions for hand-written modules. compiler/mercury_compile.m: library/benchmarking.m: runtime/mercury_conf_param.h: runtime/mercury.h: runtime/mercury_engine.c: runtime/mercury_goto.c: runtime/mercury_grade.h: runtime/mercury_ho_call.c: runtime/mercury_label.[ch]: runtime/mercury_prof.[ch]: Add an MR_MPROF_ prefix in front of the C macros used to control the old profiler. compiler/handle_options.m: runtime/mercury_grade.h: scripts/canonical_grade.sh-subr: scripts/init_grade_options.sh-subr: scripts/parse_grade_options.sh-subr: Make deep profiling completely separate from the old profiling system, by making the deep profiling grade independent of MR_MPROF_PROFILE_TIME and the compiler option --profile-time. library/array.m: library/builtin.m: library/std_util.m: runtime/mercury_hand_unify_body.h: runtime/mercury_hand_compare_body.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of hand-written unification and comparison procedures. Make the reporting of array bounds violations switchable between making them fatal errors, as we currently, and reporting them by throwing an exception. Throwing an exception makes debugging code using arrays easier, but since exceptions aren't (yet) propagated across engine boundaries, we keep the old behaviour as the default; the new behaviour is for implementors. runtime/mercury_deep_profiling_hand.h: New file that defines macros for use in Mercury predicates whose definition is in hand-written C code. library/exception.m: runtime/mercury_exception_catch_body.h: runtime/mercury_stacks.h: In deep profiling grades, wrap the deep profiling call, exit, fail and redo codes around the bodies of the various modes of builtin_catch. Provide a function that C code can use to throw exceptions. library/benchmarking.m: library/exception.m: library/gc.m: library/std_util.m: runtime/mercury_context.[ch]: runtime/mercury_engine.[ch]: runtime/mercury_debug.c: runtime/mercury_deep_copy.c: runtime/mercury_overflow.h: runtime/mercury_regs.h: runtime/mercury_stacks.h: runtime/mercury_thread.c: runtime/mercury_wrapper.c: Add prefixes to the names of the fields in the engine and context structures, to make code using them easier to understand and modify. runtime/mercury_deep_profiling.[ch]: New module containing support functions for deep profiling and functions for writing out a deep profiling data file at the end of execution. runtime/mercury_debug.[ch]: Add support for debugging deep profiling. Add support for watching the value at a given address. Make the buffered/unbuffered nature of debugging output controllable via the -du option. Print register contents only if -dr is specified. runtime/mercury_goto.h: runtime/mercury_std.h: Use the macros in mercury_std.h instead of defining local variants. runtime/mercury_goto.h: runtime/mercury_stack_layout.h: runtime/mercury_stack_trace.c: runtime/mercury_tabling.c: trace/mercury_trace.c: trace/mercury_trace_declarative.c: trace/mercury_trace_external.c: trace/mercury_trace_vars.c: Standardize some of the macro names with those used in the debugger paper. runtime/mercury_heap.h: Add support for memory profiling with the deep profiler. runtime/mercury_prof.[ch]: runtime/mercury_prof_time.[ch]: Move the functionality that both the old profiler and the deep profiler need into the new module mercury_prof_time. Leave mercury_prof containing stuff that is only relevant to the old profiler. runtime/mercury_prof.[ch]: runtime/mercury_strerror.[ch]: Move the definition of strerror from mercury_prof to its own file. runtime/mercury_wrapper.[ch]: Add support for deep profiling. Add suppory for controlling whether debugging output is buffered or not. Add support for watching the value at a given address. runtime/Mmakefile: Mention all the added files. scripts/mgnuc.in: Add an option for turning on deep profiling. Add options for controlling the details of deep profiling. These are not documented because they are intended only for benchmarking the deep profiler itself, for the paper; they are not for general use. tools/bootcheck: Compile the deep_profiler directory as well as the other directories containing Mercury code. Turn off the creation of deep profiling data files during bootcheck, since all but one of these in each directory will be overwritten anyway. Add support for turning on --keep-objs by default in a workspace. tools/speedtest: Preserve any deep profiling data files created by the tests. trace/mercury_trace.c: Trap attempts to perform retries in deep profiling grades, since they would lead to core dumps otherwise. util/Mmakefile: Avoid compile-time warnings when compiling getopt. tests/*/Mmakefile: tests/*/*/Mmakefile: In deep profiling grades, switch off the tests that test features that don't work with deep profiling, either by design or because the combination hasn't been implemented yet. |
||
|
Tyson Dowd
|
19f6ca24e0 |
Add arity when outputting types. This lets us distinguish types that
Estimated hours taken: 0.5 Branches: main, dotnet-foreign Add arity when outputting types. This lets us distinguish types that have the same name but different arity, which is a bit of a problem in high-level data grades. Also add a minor fix for mapping Mercury arrays into System.Array. compiler/mlds_to_il.m: Append _arity to the type name. Translate arrays into System.Array. Re-use a little duplicated code. compiler/type_util.m: Add type_id_is_array for detecting arrays. |
||
|
David Jeffery
|
19ceeaf30f |
Merge the changes from the HAL branch onto the main branch.
Estimated hours taken: 40
(to do this merge... 100s of hours on the HAL branch
itself by myself and Warwick Harvey though).
Merge the changes from the HAL branch onto the main branch. With the recent
changes made to the HAL implementation, this means adding just one grade,
`.rt' or --reserve-tag, which reserves one tag (zero) in each type for
use by HAL's Herbrand constraint solver. This disables no-tag types and
enumerations.
This grade will now bootstrap, and passes all tests, except for a few failing
cases in the debugger and tabling directories.
compiler/options.m:
compiler/handle_options.m:
Add the `.rt' or --reserve-tag grade option.
runtime/mercury_conf_param.h:
Document the macro MR_RESERVE_TAG
doc/user_guide.texi:
Document the `.rt' grade.
compiler/make_hlds.m:
Don't record any types as no-tag types if we are in a .rt grade.
compiler/make_tags.m:
compiler/type_ctor_info.m:
Allocate tags starting from `1' in .rt grades.
compiler/rtti_out.m:
In .rt grades, output a dummy ptag definition for tag `0'.
compiler/type_util.m:
Add predicates `type_util__constructors_are_dummy_argument_type' and
`type_constructors_are_type_info' for use when allocating tags to
ensure that type infos and dummy types (io__state/0 and store__store/1)
are still treated as no-tag types in .rt grades.
library/sparse_bitset.m:
When allocating a sparse bitset element, use tag `1' if we are in a
.rt grade.
runtime/mercury_tags.h:
Define a macro `MR_UNIV_TAG' which is `1' is we in a .rt grade and
`0' otherwise. (Now that univ is a user defined type, it is a also
assigned a `var' tag).
Also make the definitions of MR_RAW_TAG_NIL and MR_RAW_TAG_CONS take the
.rt grade into account.
runtime/mercury_type_info.h:
Define `MR_unravel_univ' and
`MR_initialise_univ' for taking apart and putting together univs.
Add a new secondary tag alternative: MR_SECTAG_VARIABLE, used to
represent Herbrand variables.
library/std_util.m:
Use MR_UNIV_TAG, MR_unravel_univ and MR_initialise_univ when
manipulating univs.
Handle the new MR_SECTAG_VARIABLE secondary tag by aborting.
runtime/mercury_deep_copy_body.h:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
Handle the new MR_SECTAG_VARIABLE secondary tag by aborting.
library/std_util.m:
Add a constant for MR_SECTAG_VARIABLE in the MC++ back end.
scripts/canonical_grade.sh-subr:
scripts/init_grade_options.sh-subr:
scripts/mgnuc.in:
scripts/parse_grade_options.sh-subr:
Process the new grade.
scripts/mmake.in:
Add an option `--include-makefile', which includes a Makefile given
as a command line argument into the Makefile generated by mmake.
This is used to implement `halmake', a make program for HAL which
just passes a bunch of extra rules and variable definitions onto
mmake.
tests/debugger/existential_type_classes.m:
tests/hard_coded/existential_types_test.m:
trace/mercury_trace_declarative.c:
trace/mercury_trace_external.c:
trace/mercury_trace_internal.c:
Use MR_UNIV_TAG.
TODO:
- The declarative debugger falls over in .rt grades. This is possibly
because compiler/static_term.m assumes that the generated code uses
the same data representation as the compiler itself. This should be
fixed, although it is not critical; the declarative debugger won't
work with trailing as is, and the .rt grade is only ever used in
conjunction with trailing (.tr) at this stage.
|
||
|
Zoltan Somogyi
|
50f1674dd5 |
In mdb's print and browse commands, allow the field to be printed to be
Estimated hours taken: 8
In mdb's print and browse commands, allow the field to be printed to be
specified by name as well as by number. This required extending the RTTI
for notag types to record field names.
trace/mercury_trace_vars.m:
Allow the field to be printed to be specified by name as well as by
number.
library/std_util.m:
Add code to find out whether a term has a field with a given name,
and if yes, which field that is. At the moment, this functionality
is accessible only from C. (There is no point to adding to the
user-visible interface before a redesign of that interface.)
Fix an old bug: ML_arg() was not compensating for the extra type_info
and/or typeclass_info arguments inserted at the start of a cell for
functors with existentially typed arguments. Document the ML_expand
data structure better to make that bug less likely in the future.
runtime/mercury_type_info.h:
Add an extra field to the type for notag type functors, recording
the field name of the argument, if it has one.
compiler/rtti.m:
Add a maybe-argument-name field to the record for notag types.
compiler/type_ctor_info.m:
Record the name of the single argument of the single functor of a
notag type, if it has one.
compiler/type_util.m:
Make that argument name available.
compiler/rtti_out.m:
Print out that argument name.
compiler/make_tags.m:
compiler/make_hlds.m:
compiler/rtti_to_mlds.m:
Ignore that argument name.
tests/debugger/field_names.{m,inp,exp}:
A new test case to test the printing of subterms specified by field
numbers and/or names.
tests/debugger/Mmakefile:
Enable the new test case.
|
||
|
Simon Taylor
|
b251a990aa |
Improve the efficiency of type_util__type_is_no_tag_type.
Estimated hours taken: 1 Improve the efficiency of type_util__type_is_no_tag_type. This change reduces the time taken by `mmc -C make_hlds' by about 2%. compiler/hlds_data.m: compiler/hlds_module.m: compiler/make_hlds.m: Add a field to the module_info to hold information about no-tag types to avoid searching the entire type table. compiler/type_util.m: Look up the no-tag type table rather than the type table in type_is_no_tag_type. Minor efficiency improvements for type_to_type_id. Avoid unnecessary calls to type_to_type_id. |
||
|
David Overton
|
82378c381b |
Allow polymorphic ground insts. This change assumes that all inst
Estimated hours taken: 80 Allow polymorphic ground insts. This change assumes that all inst parameters in the mode declaration for a predicate or function are constrained to be ground-shared. This is a temporary measure until we work out a nice syntax to allow the programmer to tell the compiler that certain inst parameters may be treated as ground insts. Since we don't currently support unconstrained inst parameters anyway, this shouldn't cause a problem. TODO: - Add syntax, something like `:- mode p(in(I)) <= ground(I).', to specify that an inst parameter represents a ground inst. - Allow abstract ground insts that are treated in a similar way to what we've done here with ground inst parameters. - Make mode checking more efficient (i.e. rewrite the mode system). compiler/inst.m: Add a new alternative for ground insts: `constrained_inst_var(inst_var)'. Define the type `inst_var_sub'. compiler/inst_match.m: Change inst_matches_initial so that it: - handles constrained_inst_vars correctly; - returns the inst_var substitutions necessary for the call; - handles inst_matches_initial(ground(...), bound(...), ...) properly (this requires knowing the type of the variable). The last change has also been made for inst_matches_final and inst_matches_binding. However, the check is disabled for now because, without alias tracking, the mode checker becomes too conservative. compiler/hlds_pred.m: compiler/mode_info.m: compiler/simplify.m: compiler/det_util.m: Include the inst_varset in the proc_info, mode_info and simplify_info. Add a vartypes field to the det_info. Remove the vartypes field from the simplify_info since it is now in the det_info. Use record syntax for these data structures and their access predicates to make future changes easier. compiler/prog_io.m: When processing pred and func mode declarations, convert all inst_var(V) insts to ground(shared, constrained_inst_var(V)). compiler/prog_data.m: compiler/hlds_data.m: compiler/make_hlds.m: compiler/mode_util.m: Use inst_vars instead of inst_params. compiler/modes.m: compiler/modecheck_call.m: compiler/unique_modes.m: compiler/mode_util.m: When checking or recomputing initial insts of a call, build up an inst_var substitution (using the modified inst_matches_initial) and apply this to the final insts of the called procedure before checking/recomputing them. compiler/mode_util.m: Make sure that recompute_instmap_delta recomputes the instmap_deltas for lambda_goals even when RecomputeAtomic = no. compiler/type_util.m: Add a new predicate, type_util__cons_id_arg_types which nondeterministically returns the cons_ids and argument types for a given type. Add a new predicate type_util__get_consid_non_existential_arg_types which is the same as type_util__get_existential_arg_types except that it fails rather than aborting for existenially typed arguments. compiler/accumulator.m: compiler/check_typeclass.m: compiler/clause_to_proc.m: compiler/common.m: compiler/continuation_info.m: compiler/deforest.m: compiler/det_analysis.m: compiler/det_report.m: compiler/det_util.m: compiler/dnf.m: compiler/follow_code.m: compiler/goal_store.m: compiler/goal_util.m: compiler/higher_order.m: compiler/inst_util.m: compiler/instmap.m: compiler/lambda.m: compiler/magic.m: compiler/magic_util.m: compiler/mercury_to_mercury.m: compiler/modecheck_unify.m: compiler/module_qual.m: compiler/pd_info.m: compiler/pd_util.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/prog_io_util.m: compiler/prog_rep.m: compiler/saved_vars.m: compiler/stack_layout.m: compiler/table_gen.m: compiler/unify_proc.m: compiler/unneeded_code.m: compiler/unused_args.m: Pass inst_varsets and types where needed. Changes to reflect change in definition of the inst data type. compiler/inlining.m: Recompute the instmap deltas for a procedure after inlining. This bug showed up compiling tests/hard_coded/lp.m with inlining and deforestation turned on: deforestation was getting incorrect instmap deltas from inlining, causing the transformation to break mode-correctness. It has only just shown up because of the added call to `inst_matches_initial' from within `recompute_instmap_delta'. tests/invalid/Mmakefile: tests/invalid/unbound_inst_var.m: tests/invalid/unbound_inst_var.err_exp: tests/valid/Mmakefile: tests/valid/unbound_inst_var.m: Move the `unbound_inst_var' test case from `invalid' to `valid' and extend its coverage a bit. |
||
|
Simon Taylor
|
3cf329a739 |
Fix bugs in explicit type qualification.
Estimated hours taken: 4
Fix bugs in explicit type qualification.
compiler/make_hlds.m:
Make the code to handle type qualification expressions match
the documentation. Variables occurring in type qualifications
but not in the predicate's argument types are local to the
clause in which they occur.
Don't export clauses_info_init -- it's not used anywhere else.
Add field labels to the qual_info type.
compiler/hlds_pred.m:
compiler/*.m:
Add a field to the clauses_info to contain the mapping from
type variable names to type variables for the head types.
This needs to be maintained because type variables added
while processing type qualifications in a clause should
not be added to the map used for other clauses.
compiler/typecheck.m:
Apply substitutions to the explicit vartypes at the end
of each pass of typechecking to keep them in sync with
the type variables in the argument types.
compiler/type_util.m:
Add a predicate type_util__apply_variable_renaming_to_type_map
for use by typecheck.m.
doc/reference_manual.texi:
Add some more comments about the handling of explicit type
qualifications to the documentation about valid type assignments.
Change references to existential type _qualifiers_ to consistently
refer to existential type _quantifiers_.
tests/hard_coded/type_qual.{m,exp}:
Add some more tests.
tests/hard_coded/Mmakefile:
Pass `--infer-all' to mmc when compiling type_qual.m.
|
||
|
Simon Taylor
|
46a8da81cb |
Implement builtin tuple types, similar to those in Haskell.
Estimated hours taken: 30
Implement builtin tuple types, similar to those in Haskell.
Tuples are constructed and deconstructed using
the syntax X = {Arg1, Arg2, ...}.
Tuples have type `{Arg1, Arg2, ...}'.
Unary tuples (X = {Arg}) do work, unlike in Haskell. The rationale
for this is that it is useful to be able to construct unary tuples
to be passed to a polymorphic predicate which uses std_util__deconstruct
to deal with a tuple of any arity. Since this is probably the only
use for unary tuples, it's not really worth the effort of treating
them as no_tag types, so we don't.
The type-infos for tuples have the same structure as for higher-order
types. There is a single type_ctor_info for tuples, and the arity
is placed before the argument type_infos.
library/parser.m:
Change the way '{}/N' terms are parsed, so that the parsed
representation is consistent with the way other functors
are represented (previously the arguments were left as
unparsed ','/2 terms). This avoids special case code
in prog_io__parse_qualified_term, term__term_to_type
and term__type_to_term.
compiler/prog_io_dcg.m:
compiler/prog_io_util.m:
Handle the new structure of '{}/N' terms when parsing DCG escapes
by converting the argument list back into a single ','/2 term.
compiler/module_qual.m:
Treat tuples as a builtin type.
compiler/typecheck.m:
Typecheck tuple constructors.
compiler/mode_util.m:
Propagate types into tuple bound insts.
compiler/type_util.m:
Add type_is_tuple/2 and type_id_is_tuple/1 to identify tuple types.
Add tuples to the list of types which are not atomic types.
Handle tuple types in `type_constructors' and
`get_cons_id_arg_types' and `switch_type_num_functors'.
compiler/tabling.m:
Handle tabling of tuples.
compiler/term_util.m:
Handle tuples in the code to compute functor norms.
compiler/magic_util.m:
compiler/rl.m:
compiler/rl_key.m:
Handle tuple types in the Aditi back end.
compiler/mercury_to_mercury.m:
library/io.m:
library/term_io.m:
Handle output of '{}/N' terms.
compiler/higher_order.m:
compiler/simplify.m:
Don't specialize complicated unifications of tuple
types into calls to a specific unification procedure --
even if the procedure were implemented, it probably
wouldn't be that much more efficient.
compiler/unify_proc.m:
Generate unification procedures for complicated unifications
of tuples (other than in-in unifications). These are generated
lazily as required.
compiler/make_hlds.m:
Export add_special_pred for use by unify_proc.m.
compiler/polymorphism.m:
Export polymorphism__process_pred for use by unify_proc.m.
compiler/bytecode_gen.m:
compiler/code_util.m:
compiler/ml_code_util.m:
Handle unify procedure names and tags for tuple types.
compiler/mlds_to_c.m:
Output tuple types as MR_Tuple.
compiler/ml_unify_gen.m:
Compute the field types for tuples.
compiler/polymorphism.m:
compiler/pseudo_type_info.m:
Treat tuple type_infos in a similar way to higher-order type_infos.
compiler/hlds_data.m:
Document how cons_ids for tuple types are represented.
compiler/switch_gen.m:
compiler/table_gen.m:
Add tuple types to switches on type_util__builtin_type.
compiler/llds_out.m:
util/mdemangle.c:
profiler/demangle.m:
Transform items named "{}" to "f_tuple" when mangling symbols.
library/builtin.m:
Define the type_ctor_info used for tuples.
library/private_builtin.m:
Add `builtin_unify_tuple/2' and `builtin_compare_tuple/3',
both of which abort. All comparisons and in-in unifications
of tuples are performed by the generic unification functions
in runtime/mercury_ho_call.c and runtime/mercury.c.
library/std_util.m:
Implement the various RTTI functions for tuples.
Encode tuple `TypeCtorDesc's in a similar way to that
used for higher-order types. This has the consequence that the limit
on the arity of higher-order types is now MAX_VIRTUAL_REG,
rather than 2*MAX_VIRTUAL_REG.
Avoid calling MR_GC_free for the type-info vector returned
from ML_expand() for tuples because unlike the vectors
for du types, it is not copied.
runtime/mercury_type_info.h:
Add macros for extracting fields from tuple type-infos.
These just call the macros for extracting fields from higher-order
type-infos.
Add a macro MR_type_ctor_rep_is_variable_arity(), which
returns TRUE for tuples and higher-order types.
The distinction between higher-order and first-order types
is now misnamed -- the distinction is really between fixed arity
types and builtin variable arity types. I'm not sure whether
it's worth renaming everything.
runtime/mercury.h:
runtime/mercury.c:
Define unification and comparison of tuples in
high-level code grades.
runtime/mercury_deep_copy_body.h:
runtime/mercury_make_type_info_body.h:
runtime/mercury_tabling.c:
runtime/mercury_unify_compare_body.h:
Handle tuple types in code which traverses data using RTTI.
tests/hard_coded/construct.{m,exp}:
tests/hard_coded/expand.{m,exp}:
Test RTTI functions from std_util.m applied to tuples.
tests/hard_coded/tuple_test.{m,exp}:
Test unification, comparison, term_to_type etc. applied to tuples.
tests/hard_coded/deep_copy.{m,exp}:
Test deep copy of tuples.
tests/hard_coded/typeclasses/tuple_instance.{m,exp}:
Test instance declarations for tuples.
tests/tabling/expand_tuple.{m,exp}:
Test tabling of tuples.
tests/hard_coded/write.m:
Add some module qualifications for code which uses
`{}/1' constructors which are not tuples.
tests/invalid/errors2.{m,err_exp,err_exp2}:
Test handling of tuples in type errors messages.
NEWS:
doc/reference_manual.texi:
w3/news/newsdb.inc:
Document tuples.
doc/transition_guide.texi:
Document the change to the parsing of '{}/N' terms.
|
||
|
Simon Taylor
|
2490aac4dd |
Generate declarations and clauses for the compiler-generated
Estimated hours taken: 10 Generate declarations and clauses for the compiler-generated unification and comparison procedures only when they are needed. The vast majority of these procedures are never used. This change speeds up `mmc -C make_hlds' by about 5%. compiler/make_hlds.m: Export add_special_pred_for_real and add_special_pred_decl_for_real for use by unify_proc.m. Don't generate declarations or clauses for unification or comparison predicates for imported types immediately unless the predicate needs to be typechecked. Don't generate clauses for comparison predicates for imported types -- they will never be used because the predicate has import_status `imported'. compiler/special_pred.m: compiler/typecheck.m: Add predicate special_pred_for_type_needs_typecheck, which succeeds for types with user-defined equality and types with existentially typed constructors. compiler/unify_proc.m: Make sure the declarations and clauses for the unification predicate for a type have been generated before processing a unify_request for that type. Add predicates for use by higher_order.m to force generation of a special predicate when required for specialization of a call to unify/2 or compare/3. Simplify the code for unification predicates for enumeration types. The code that was being generated cast the arguments to int, then called unify/2 on the ints. The simpler version just creates a unify goal. Enumerations are atomic types, so modecheck_unify.m will treat the unification as a simple_test. compiler/polymorphism.m: Add a predicate polymorphism__process_generated_pred to be used by unify_proc.m to process the bodies of the generated unification predicates. compiler/post_typecheck.m: Add versions of post_typecheck__finish_pred and post_typecheck__finish_imported_pred which don't require an io__state, for use by unify_proc.m. Errors should never be reported in post_typecheck.m for unification or comparison predicates. compiler/simplify.m: Don't generate calls to the type-specific predicate for an in-in complicated unification if the predicate is generated lazily. higher_order.m will handle the specialization in that case. compiler/higher_order.m: Call unify_proc.m to generate the declarations for a special pred when there is a call to that special pred which could be specialized. Add field labels to the higher_order_info type. compiler/type_util.m: Add predicates type_id_is_atomic and classify_type_id, which are similar to type_is_atomic and classify_type, for use by special_pred.m. |
||
|
Simon Taylor
|
19bcf11e7a |
Fix a bug in the handling of instances with unconstrained type
Estimated hours taken: 1 Fix a bug in the handling of instances with unconstrained type variables where a type variable occurs multiple times in the instance declaration. The compiler was adding multiple copies of the type_info for such variables to the typeclass_info. compiler/type_util.m: Remove duplicates in the list of variables returned by `get_unconstrained_tvars/3'. tests/hard_coded/Mmakefile: tests/hard_coded/instance_unconstrained_tvar_dup.m: tests/hard_coded/instance_unconstrained_tvar_dup.exp: Test case. |
||
|
Tyson Dowd
|
791ec10d1e |
Add options for
Estimated hours taken: 1 Add options for unboxed_enums - turns on unboxed enums (default is yes) unboxed_no_tag_types - turns on unboxed no-tag-types (default is yes) Currently every grade uses these representations. We will set these to `no' on the IL backend (and probably the Java backend) if using a simple implementation of the the Array of Object representation for Mercury data structures. compiler/make_tags.m: Check for these options when creating representations. compiler/options.m: Add the new options. compiler/type_util.m: Make sure type_is_no_tag_type checks the appropriate option. Add a new predicate type_constructors_are_no_tag_type which just does a check of the structure of the constructors (you have to do the option checking yourself). compiler/higher_order.m: compiler/mode_util.m: Use the new type_is_no_tag_type (this actually simplifies the code). compiler/type_ctor_info.m: Use type_constructors_are_no_tag_type and check the globals. |
||
|
Zoltan Somogyi
|
9dcab9bee2 |
Add a new optimization, enabled by the option --unneeded-code.
Estimated hours taken: 40 Add a new optimization, enabled by the option --unneeded-code. This optimization removes goals whose outputs are not used at all, and moves goals whose outputs are only used on some computation branches to the starts of those branches, so they do not need to be executed on other branches. Such deletions/movements are done only when the semantic switches and the properties of the relevant goal together permit it. compiler/unneeded_code.m: A new module to perform the goal rearrangement. compiler/hlds_goal.m: The new optimization needs to know how many functors the switched-on variable can be bound to, so it can check whether a given number of switch arms covers all alternatives or not. To make access to this information convenient, we add a field to the goal_path_step alternative for switch arm entry that records this number. compiler/goal_path.m: Fill in this number. To make this possible, we thread the necessary information through the predicates in this module. compiler/type_util.m: Add a utility predicate type_util__switch_type_num_functors, for use by the new code in goal_path.m. compiler/switch_detection.m: Avoid duplicated code by using type_util__switch_type_num_functors where relevant. compiler/code_aux.m: Add three new auxiliary predicate, code_aux__goal_cannot_loop_or_throw, code_aux__goal_can_loop_or_throw and code_aux__goal_can_loop, to the existing code_aux__goal_cannot_loop. code_aux__goal_cannot_loop now checks only what its name says. compiler/trace.m: Ignore the new field when generating goal paths strings. compiler/mercury_compile.m: Invoke unneeded_code.m if required. compiler/hlds_pred.m: Add some utility predicates for use by unneeded_code.m. compiler/unused_args.m: Use the new utility predicates instead of reimplementing them. compiler/options.m: Define the --unneeded-code option, and its auxiliary, --unneeded-code-copy-limit. doc/user_guide.texi: Document the new options. |