mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-13 21:04:00 +00:00
f08f93af2f0d74a236b06f5ed780ededdaa4f5a1
250 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
James Goddard
|
77d3bd1012 |
Bug fix for polymorphism.m
Estimated hours taken: 24 Branches: main Bug fix for polymorphism.m compiler/polymorphism.m: error appears in debug output in: store.hlds_dump.* Where the type_info/typeclass_info types were in the wrong order, which meant that the java code generated was trying to cast type_infos to typeclass_infos and vice versa. The problem was that in polymorphism__process_foreign_proc_args the ArgInfo list was being generated in a certain order: typeinfos ++ typeclass_infos ++ oldinfos as is in fact documented in the predicate, but the corresponding type list OrigArgTypes had: typeclass_info types ++ typeinfo types ++ OrigArgTypes So this has been altered so that the typeinfo types go first. compiler/hlds_out.m: hlds_out__write_goal_2 modified so as to print out the type list after the argument names list. |
||
|
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.
|
||
|
Zoltan Somogyi
|
6b432d0448 |
Split a predicate with a 200-line definition into three.
Estimated hours taken: 1 Branches: main compiler/polymorphism.m: Split a predicate with a 200-line definition into three. Fix some formatting issues. There is no change in algorithms. |
||
|
Zoltan Somogyi
|
b39a3d855f |
This diff makes hlds_module.m and many callers of its predicates easier to read
Estimated hours taken: 6 Branches: main This diff makes hlds_module.m and many callers of its predicates easier to read and to maintain, but contains no changes in algorithms whatsoever. compiler/hlds_module.m: Bring (most of) this module into line with our current coding standards. Use predmode declarations, functions, and state variable syntax when appropriate. (The 'most of' is because I left the part of the module dealing with predicate tables alone, not wishing to cause a conflict for Pete.) Reorder arguments of predicates where necessary for the use of state variable syntax, and where this improves readability. Replace old-style lambdas with new-style lambdas or with partially applied named procedures. compiler/*.m: Conform to the changes in hlds_module.m. This mostly means using the new argument orders of predicates exported by hlds_module.m, and switching to state variable notation. Replace old-style lambdas with new-style lambdas or with partially applied named procedures in updated code. Replace unnecessary occurrences of four-space indentation with standard indentation in updated code. library/list.m: library/map.m: library/tree234.m: Add list__foldl4 and map__foldl3, since in some compiler modules, state variable notation is more convenient (and the code more efficient) if we don't have to bundle up several data structures into a tuple just to iterate over them. Change the fold predicates to use state variable notation. NEWS: Mention the new library functions. |
||
|
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. |
||
|
Fergus Henderson
|
effa9144f3 |
Fix an XXX: when calling instmap_delta_from_mode_list in
Estimated hours taken: 0.25 Branches: main compiler/polymorphism.m: Fix an XXX: when calling instmap_delta_from_mode_list in expand_one_body, use the current version of ModuleInfo rather than an older version. |
||
|
Zoltan Somogyi
|
87c39c25ab |
This diff makes polymorphism.m easier to read and to maintain (as well as
Estimated hours taken: 3 Branches: main This diff makes polymorphism.m easier to read and to maintain (as well as 5% shorter), but contains no changes in algorithms whatsoever. compiler/polymorphism.m: Bring this module into line with our current coding standards. Use predmode declarations, field accesses 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. Replace references to c_code with references to foreign_procs. Standardize indentation. compiler/modecheck_unify.m: compiler/simplify.m: Conform to the new argument orders of predicates exported by polymorphism.m. |
||
|
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.
|
||
|
Zoltan Somogyi
|
681b6b5460 |
Fix some out-of-date documentation.
Estimated hours taken: 0.1 Branches: main compiler/polymorphism.m: Fix some out-of-date documentation. |
||
|
Zoltan Somogyi
|
0c0e9be6b2 |
Fix spelling error in comment.
Estimated hours taken: 0.1 Branches: main compiler/polymorphism.m: Fix spelling error in comment. |
||
|
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
|
1790c3b505 |
When generating calls, specify whether the call is to a predicate or
Estimated hours taken: 1 Branches: main compiler/goal_util.m: compiler/hlds_module.m: When generating calls, specify whether the call is to a predicate or function. compiler/goal_util.m: compiler/unify_proc.m: Move a predicate that generates unsafe casts from unify_proc to goal_util, since polymorphism may also want to use it someday. compiler/add_heap_ops.m: compiler/add_trail_ops.m: compiler/aditi_builtin_ops.m: compiler/deep_profiling.m: compiler/det_analysis.m: compiler/higher_order.m: compiler/polymorphism.m: compiler/simplify.m: compiler/table_gen.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: Trivial diffs to conform to the changes above. |
||
|
Zoltan Somogyi
|
599ef915d9 |
Instead of being relied on all over the place, centralize the compiler's
Estimated hours taken: 16 Branches: main Instead of being relied on all over the place, centralize the compiler's knowledge of the names of unify, compare and index predicates in one place, special_pred.m. This should make it easy to change the naming scheme once we switch over to compiler-generated type_ctor_infos for builtin types, which will eliminate the runtime system's knowledge of the naming scheme. compiler/hlds_pred.m: Add a field to pred_infos that says whether the predicate is a unify, compare or index predicate, and if so, for which type constructor. Code that used to test the predicate's name for __Unify__ etc now tests this field instead. Similarly the code that used to employ devious tricks to find out the type the unify/compare/index predicate is for. compiler/rtti.m: Include this field in rtti_proc_labels as well as pred_infos. compiler/make_hlds.m: Fill in this field as appropriate. compiler/proc_label.m: Replace the predicate name with special_pred_id in the proc_labels of unify, index and compare preds. compiler/special_pred.m: Narrow the interface to prevent reliance on the naming scheme for compiler-generated unify, compare and index predicates, except when absolutely necessary, i.e. when creating names for them. Narrow the mechanism required to reverse-engineer the type constructor a unify/compare/index predicate is for from the types to the functionality required by higher_order.m. compiler/code_gen.m: compiler/det_report.m: compiler/higher_order.m: compiler/intermod.m: compiler/layout_out.m: compiler/magic_util.m: compiler/ml_code_util.m: compiler/name_mangle.m: compiler/opt_debug.m: compiler/opt_util.m: compiler/optimize.m: compiler/polymorphism.m: compiler/post_typecheck.m: compiler/proc_label.m: compiler/rl_exprn.m: compiler/rl_key.m: compiler/simplify.m: compiler/termination.m: compiler/typecheck.m: compiler/unify_proc.m: compiler/unused_args.m: Update code and comments to conform to the changes above. compiler/hlds_out.m: Don't refer to the 'type' that a unify, compare or index predicate is for; refer to the type *constructor*. compiler/mlds_to_java.m: Delete an unused predicate. tests/invalid/purity/purity.err_exp: Update this expected output for the change in hlds_out.m. |
||
|
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. |
||
|
Simon Taylor
|
82a950c0d9 |
Make Aditi work with `--highlevel-code'.
Estimated hours taken: 80 Branches: main Make Aditi work with `--highlevel-code'. (Note that this doesn't work with the current CVS version of Aditi. The Aditi developers have rewritten the Aditi client API, and haven't maintained the old version of the API, so Mercury queries don't work at the moment. extras/aditi will be updated to use the new interface as a separate change.) extras/aditi/aditi_private_builtin.m: extras/aditi/aditi.m: Move code to implement Aditi calls and updates into a aditi_private_builtin.m. These operations are now implemented using ordinary Mercury foreign procedures, rather than hand-coded C modules. compiler/magic.m: Use calls to ordinary calls to predicates defined in extras/aditi/aditi_private_builtin.m to implement the procedures which interface between top-down Mercury code and Aditi procedures. compiler/aditi_backend.pp: compiler/aditi_builtin_ops.m: compiler/mercury_compile.m: compiler/notes/compiler_design.html: Add a pass to convert Aditi builtins (calls and updates) into ordinary calls to predicates defined in extras/aditi/aditi_private_builtin.m. compiler/hlds_goal.m: compiler/hlds_pred.m: Add a new generic_call type -- `unsafe_cast'. aditi_builtin_ops.m needs to be able to cast closures from one type and inst to another. Delete the `aditi_call' alternative for `aditi_builtin', which is not needed after the change to magic.m described above. Add predicates `construct_tuple' and `deconstruct_tuple'. compiler/*hlds.*.m: compiler/call_gen.m: compiler/ml_call_gen.m: Handle unsafe cast goals. compiler/common.m: compiler/higher_order.m: compiler/unify_proc.m: Generate unsafe_cast goals instead of calls to private_builtin.unsafe_type_cast. compiler/purity.m: compiler/notes/compiler_design.html: Convert calls to private_builtin.unsafe_type_cast into unsafe_cast goals. compiler/ml_code_gen.m: Don't attempt to generate code for Aditi procedures. Remove special case handling of calls to private_builtin.unsafe_type_cast -- such calls are now transformed away. compiler/mlds_to_c.m: compiler/mlds_to_gcc.m: compiler/maybe_mlds_to_gcc.m: Add the RL code to the generated C file. compiler/llds_out.m: compiler/c_util.m: compiler/compile_target_code.m: Move code to generate a `.rlo' file and work out the name of the RL constant embeeded in the C file for a module into c_util.m, for use by the MLDS backend. compiler/modules.m: Automatically import aditi_private_builtin when compiling with `--aditi'. We generate a C constant for the RL code for each module, so modules compiled with `--aditi' need to be treated by the build system as if they contain foreign code. compiler/polymorphism.m: Tuple insertion and deletion no longer need special treatment. compiler/llds.m: compiler/ll_backend.*.m: Delete the Aditi alternatives of the `code_addr' type. compiler/mode_util.m: Add function versions of in_mode, out_mode, etc. compiler/prog_util.m: Add aditi_public_builtin_module (returns `aditi') and aditi_private_builtin_module (returns `aditi_private_builtin'). tests/valid/aditi_private_builtin.m: tests/invalid/aditi_private_builtin.m: tests/valid/Mercury.options: tests/invalid/Mercury.options: Add a cut down version of extras/aditi/aditi_private_builtin.m for use in running the tests. |
||
|
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
|
129f605d25 |
Fix bugs in the handling of purity in the optimization passes
Estimated hours taken: 8
Branches: main, release
Fix bugs in the handling of purity in the optimization passes
(in particular constraint propagation), which caused purity
annotations on goals to be lost. This caused
tests/tabling/unused_args to fail on earth.
compiler/hlds_goal.m:
Make the version of goal_info_init called from
the optimization passes take the purity as an
argument. Previously, callers were constructing
a goal_info then adding the purity, which was
error prone.
compiler/hlds_goal.m:
compiler/purity.m:
Move the predicates to deal with purity representation
in hlds_goal_infos into hlds_goal.m. Rationale -
goal_info_get_determinism is not in det_analysis.m,
goal_info_get_nonlocals is not in quantification.m, etc.
This makes it easier to make the purity setting code
efficient.
Don't allocate memory in add_goal_info_purity_feature
if the call doesn't change the purity.
compiler/*.m:
Pass the extra argument to goal_info_init.
compiler/polymorphism.m:
Remove a duplicate definition of
hlds_goal__make_int_const_construction.
compiler/magic.m:
Remove some unused code.
tests/hard_coded/purity/Mmakefile:
tests/hard_coded/purity/Mercury.options:
tests/hard_coded/purity/purity_opt.{m,exp}:
Test case.
|
||
|
Simon Taylor
|
660a24a7ad |
Fix a bug reported by Michael Day which caused spurious
Estimated hours taken: 8 Branches: main, release Fix a bug reported by Michael Day which caused spurious "predicate multiply defined" errors if there were predicates `module1.p' and `module2.module1.p'. compiler/hlds_module.m: For each of the predicate table search predicates which takes a module, add an extra argument which states whether the module name passed in is fully qualified. If it is, then a search for `module1.p' will not return `module2.module1.p'. The module name is guaranteed to be fully qualified for the head of predicate, clause, etc. items, and for calls occurring in `.opt' files. Add a predicate `lookup_builtin_pred_proc_id', for looking up the builtin predicates in the predicate table. compiler/goal_util.m: Move code to look up builtin predicates into hlds_module.m. Set the builtin_state field of the call goal returned by generate_simple_call correctly. compiler/hlds_pred.m: Add a function `calls_are_fully_qualified' which takes an import_status, and returns whether calls from goals with that status are always fully qualified, which is true iff the call is in a `.opt' file. compiler/prog_io.m: Module qualify the sym_names in `:- external' items. compiler/*.m: Fill in the extra argument of predicate table searches. Use `lookup_builtin_pred_proc_id' rather than `predicate_table_search_*'. compiler/prog_util.m: Add function versions of mercury_*_builtin_module. compiler/polymorphism.m: compiler/simplify.m: compiler/unify_proc.m: Use goal_util__generate_simple_call to call builtins, rather than duplicating the code. tests/valid/Mmakefile: tests/valid/nested_module_bug.m: tests/valid/intermod_bug_nested.m: Test cases. |
||
|
Fergus Henderson
|
4ac56ddf67 |
Fix a bug where the stub code generated with `--allow-stubs'
Estimated hours taken: 0.5 Branches: main Fix a bug where the stub code generated with `--allow-stubs' was violating an invariant that polymorphism pass was relying on. compiler/polymorphism.m: Allow unifications whose kind (construction, deconstruction, simple_test, etc.) has already been determined. |
||
|
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. |
||
|
Mark Brown
|
06f2029688 |
Allow typeclass constraints on ground types.
Estimated hours taken: 3 Branches: main Allow typeclass constraints on ground types. compiler/prog_io_typeclass.m: Remove the check that typeclass constraints are non-ground. compiler/polymorphism.m: compiler/typecheck.m: Change tests for monomorphic calls to also test for no constraints. The optimizations that are applied if these tests succeed assume that there are no constraints. Remove "sanity" checks which are no longer applicable. tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/ground_constraint.exp: tests/hard_coded/typeclasses/ground_constraint.m: Test the new feature. tests/invalid/Mmakefile: tests/invalid/typeclass_constraint_no_var.err_exp: tests/invalid/typeclass_constraint_no_var.m: tests/valid/Mmakefile: tests/valid/typeclass_constraint_no_var.m: Move this test from invalid to valid, since it should compile successfully now. |
||
|
David Overton
|
9739517435 |
Allow constraints on pred/func, instance and typeclass declarations to
Estimated hours taken: 25 Branches: main Allow constraints on pred/func, instance and typeclass declarations to constraint arbitrary types rather than just type variables. The only restriction is that each constraint must contain at least one type variable and that all type variables in the constraint must also occur somewhere else in the declaration. compiler/prog_io_typeclass.m: When parsing class constraints (on pred/func, instance and typeclass declarations) remove the restriction that the arguments must all be variables. Instead, ensure that at least one argument contains at least one variable. compiler/hlds_data.m: compiler/hlds_out.m: compiler/make_hlds.m: Allow superclass constraints to have arguments of arbitrary type (rather than just variables) in the superclass table. compiler/polymorphism.m: compiler/typecheck.m: Put in some checks to ensure that we don't get into an infinite loop when processing mutually constrained intances, e.g. :- instance c(f(T)) <= d(g(T)). :- instance d(g(T)) <= c(f(T)). doc/reference_manual.texi: Document the change. tests/hard_coded/typeclasses/Mmakefile: tests/hard_coded/typeclasses/arbitrary_constraint_class.exp: tests/hard_coded/typeclasses/arbitrary_constraint_class.m: tests/hard_coded/typeclasses/arbitrary_constraint_pred_1.exp: tests/hard_coded/typeclasses/arbitrary_constraint_pred_1.m: tests/hard_coded/typeclasses/arbitrary_constraint_pred_2.exp: tests/hard_coded/typeclasses/arbitrary_constraint_pred_2.m: tests/hard_coded/typeclasses/recursive_instance_1.exp: tests/hard_coded/typeclasses/recursive_instance_1.m: tests/hard_coded/typeclasses/recursive_instance_2.exp: tests/hard_coded/typeclasses/recursive_instance_2.m: tests/invalid/Mmakefile: tests/invalid/typeclass_constraint_extra_var.err_exp: tests/invalid/typeclass_constraint_extra_var.m: tests/invalid/typeclass_constraint_no_var.err_exp: tests/invalid/typeclass_constraint_no_var.m: Add some test cases. |
||
|
Simon Taylor
|
9dbcf4714a |
Fix a bug which caused type-incorrect HLDS to be generated by mode
Estimated hours taken: 5
Branches: main
Fix a bug which caused type-incorrect HLDS to be generated by mode
analysis, which then caused a compiler abort in simplification.
In the code below, mode analysis must treat the headvar unification
as a construction followed by a var-var unification. If it is treated
as a deconstruction, the argument unifications will be ill-typed.
:- type t ---> some [T] f(T) => enum(T).
:- pred p(t::in) is semidet.
p('new f'(1)).
compiler/modecheck_unify.m:
Make sure unifications with a RHS of the form 'new f(X)'
are always classified as constructions.
compiler/hlds_goal.m:
compiler/*.m:
Add a field to var-functor unifications which identifies
those which must be treated as constructions.
compiler/polymorphism.m:
Fill in the field.
tests/hard_coded/Mmakefile:
tests/hard_coded/unify_existq_cons.{m,exp}:
Test case.
|
||
|
Simon Taylor
|
e66536cbe8 |
Update a comment about a bug which has been fixed.
Estimated hours taken: 0.25 Branches: main compiler/polymorphism.m: Update a comment about a bug which has been fixed. |
||
|
Simon Taylor
|
f65c3fd341 |
Previously, we assumed that when a type variable had not
Estimated hours taken: 1.5
Branches: main, release
compiler/polymorphism.m:
Previously, we assumed that when a type variable had not
been seen before, a type_info would be produced for
it by a later goal. This didn't work when the type_info
was contained in a typeclass_info produced by the later
goal. Now whenever an existential typeclass_info is produced
by a call or deconstruction unification, the type_info_varmap
entries for such type variables are updated to point to the
type_class_info, and code is generated to extract the type_info
from the typeclass_info.
tests/hard_coded/Mmakefile:
tests/hard_coded/existential_reordering_class.{m,exp}:
Before this change, the compiler reported a spurious mode
error for this test case.
|
||
|
Simon Taylor
|
ba848ac99d |
Make sure the type-infos needed for complicated argument
Estimated hours taken: 3
compiler/polymorphism.m:
Make sure the type-infos needed for complicated argument
unifications of var-functor unifications are included in
the non-locals set of the unification.
This bug caused an MLDS code generator abort when compiling
library/set_bbbtree.m with `--target asm'.
tests/hard_coded/Mmakefile:
tests/hard_coded/unify_typeinfo_bug.{m,exp}:
Test case.
|
||
|
Zoltan Somogyi
|
6e8a16b6d8 |
Give the Mercury variables containing type_ctor_infos a meaningful,
Estimated hours taken: 0.5 Branches: main compiler/polymorphism.m: Give the Mercury variables containing type_ctor_infos a meaningful, non-misleading name, i.e. name them TypeCtorInfo, not TypeInfo. tests/debugger/nondet_stack.exp*: Update expected output containing variable names affected by the change to polymorphism.m. |
||
|
Zoltan Somogyi
|
bf2ae5868d |
Fix some documentation rot.
Estimated hours taken: 0.1 Branches: main compiler/polymorphism.m: Fix some documentation rot. |
||
|
Zoltan Somogyi
|
189b9215ae |
This diff implements stack slot optimization for the LLDS back end based on
Estimated hours taken: 400
Branches: main
This diff implements stack slot optimization for the LLDS back end based on
the idea that after a unification such as A = f(B, C, D), saving the
variable A on the stack indirectly also saves the values of B, C and D.
Figuring out what subset of {B,C,D} to access via A and what subset to access
via their own stack slots is a tricky optimization problem. The algorithm we
use to solve it is described in the paper "Using the heap to eliminate stack
accesses" by Zoltan Somogyi and Peter Stuckey, available in ~zs/rep/stackslot.
That paper also describes (and has examples of) the source-to-source
transformation that implements the optimization.
The optimization needs to know what variables are flushed at call sites
and at program points that establish resume points (e.g. entries to
disjunctions and if-then-elses). We already had code to compute this
information in live_vars.m, but this code was being invoked too late.
This diff modifies live_vars.m to allow it to be invoked both by the stack
slot optimization transformation and by the code generator, and allows its
function to be tailored to the requirements of each invocation.
The information computed by live_vars.m is specific to the LLDS back end,
since the MLDS back ends do not (yet) have the same control over stack
frame layout. We therefore store this information in a new back end specific
field in goal_infos. For uniformity, we make all the other existing back end
specific fields in goal_infos, as well as the similarly back end specific
store map field of goal_exprs, subfields of this new field. This happens
to significantly reduce the sizes of goal_infos.
To allow a more meaningful comparison of the gains produced by the new
optimization, do not save any variables across erroneous calls even if
the new optimization is not enabled.
compiler/stack_opt.m:
New module containing the code that performs the transformation
to optimize stack slot usage.
compiler/matching.m:
New module containing an algorithm for maximal matching in bipartite
graphs, specialized for the graphs needed by stack_opt.m.
compiler/mercury_compile.m:
Invoke the new optimization if the options ask for it.
compiler/stack_alloc.m:
New module containing code that is shared between the old,
non-optimizing stack slot allocation system and the new, optimizing
stack slot allocation system, and the code for actually allocating
stack slots in the absence of optimization.
Live_vars.m used to have two tasks: find out what variables need to be
saved on the stack, and allocating those variables to stack slots.
Live_vars.m now does only the first task; stack_alloc.m now does
the second, using code that used to be in live_vars.m.
compiler/trace_params:
Add a new function to test the trace level, which returns yes if we
want to preserve the values of the input headvars.
compiler/notes/compiler_design.html:
Document the new modules (as well as trace_params.m, which wasn't
documented earlier).
compiler/live_vars.m:
Delete the code that is now in stack_alloc.m and graph_colour.m.
Separate out the kinds of stack uses due to nondeterminism: the stack
slots used by nondet calls, and the stack slots used by resumption
points, in order to allow the reuse of stack slots used by resumption
points after execution has left their scope. This should allow the
same stack slots to be used by different variables in the resumption
point at the start of an else branch and nondet calls in the then
branch, since the resumption point of the else branch is not in effect
when the then branch is executed.
If the new option --opt-no-return-calls is set, then say that we do not
need to save any values across erroneous calls.
Use type classes to allow the information generated by this module
to be recorded in the way required by its invoker.
Package up the data structures being passed around readonly into a
single tuple.
compiler/store_alloc.m:
Allow this module to be invoked by stack_opt.m without invoking the
follow_vars transformation, since applying follow_vars before the form
of the HLDS code is otherwise final can be a pessimization.
Make the module_info a part of the record containing the readonly data
passed around during the traversal.
compiler/common.m:
Do not delete or move around unifications created by stack_opt.m.
compiler/call_gen.m:
compiler/code_info.m:
compiler/continuation_info.m:
compiler/var_locn.m:
Allow the code generator to delete its last record of the location
of a value when generating code to make an erroneous call, if the new
--opt-no-return-calls option is set.
compiler/code_gen.m:
Use a more useful algorithm to create the messages/comments that
we put into incr_sp instructions, e.g. by distinguishing between
predicates and functions. This is to allow the new scripts in the
tool directory to gather statistics about the effect of the
optimization on stack frame sizes.
library/exception.m:
Make a hand-written incr_sp follow the new pattern.
compiler/arg_info.m:
Add predicates to figure out the set of input, output and unused
arguments of a procedure in several different circumstances.
Previously, variants of these predicates were repeated in several
places.
compiler/goal_util.m:
Export some previously private utility predicates.
compiler/handle_options.m:
Turn off stack slot optimizations when debugging, unless
--trace-optimized is set.
Add a new dump format useful for debugging --optimize-saved-vars.
compiler/hlds_llds.m:
New module for handling all the stuff specific to the LLDS back end
in HLDS goal_infos.
compiler/hlds_goal.m:
Move all the relevant stuff into the new back end specific field
in goal_infos.
compiler/notes/allocation.html:
Update the documentation of store maps to reflect their movement
into a subfield of goal_infos.
compiler/*.m:
Minor changes to accomodate the placement of all back end specific
information about goals from goal_exprs and individual fields of
goal_infos into a new field in goal_infos that gathers together
all back end specific information.
compiler/use_local_vars.m:
Look for sequences in which several instructions use a fake register
or stack slot as a base register pointing to a cell, and make those
instructions use a local variable instead.
Without this, a key assumption of the stack slot optimization,
that accessing a field in a cell costs only one load or store
instruction, would be much less likely to be true. (With this
optimization, the assumption will be false only if the C compiler's
code generator runs out of registers in a basic block, which for
the code we generate should be unlikely even on x86s.)
compiler/options.m:
Make the old option --optimize-saved-vars ask for both the old stack
slot optimization (implemented by saved_vars.m) that only eliminates
the storing of constants in stack slots, and the new optimization.
Add two new options --optimize-saved-vars-{const,cell} to turn on
the two optimizations separately.
Add a bunch of options to specify the parameters of the new
optimizations, both in stack_opt.m and use_local_vars.m. These are
for implementors only; they are deliberately not documented.
Add a new option, --opt-no-return-cells, that governs whether we avoid
saving variables on the stack at calls that cannot return, either by
succeeding or by failing. This is for implementors only, and thus
deliberately documented only in comments. It is enabled by default.
compiler/optimize.m:
Transmit the value of a new option to use_local_vars.m.
doc/user_guide.texi:
Update the documentation of --optimize-saved-vars.
library/tree234.m:
Undo a previous change of mine that effectively applied this
optimization by hand. That change complicated the code, and now
the compiler can do the optimization automatically.
tools/extract_incr_sp:
A new script for extracting stack frame sizes and messages from
stack increment operations in the C code for LLDS grades.
tools/frame_sizes:
A new script that uses extract_incr_sp to extract information about
stack frame sizes from the C files saved from a stage 2 directory
by makebatch and summarizes the resulting information.
tools/avg_frame_size:
A new script that computes average stack frame sizes from the files
created by frame_sizes.
tools/compare_frame_sizes:
A new script that compares the stack frame size information
extracted from two different stage 2 directories by frame_sizes,
reporting on both average stack frame sizes and on specific procedures
that have different stack frame sizes in the two versions.
|
||
|
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
|
9aca3d48f4 |
Another substantial step towards supporting accurate garbage
Branches: main Estimated hours taken: 50 Another substantial step towards supporting accurate garbage collection for the MLDS->C back-end: generate code for the GC tracing functions. compiler/mlds.m: Add new fields to store, with each local variable or argument declaration, the code for the GC to trace that local variable or argument. compiler/ml_code_util.m: Add a new procedure ml_gen_maybe_gc_trace_code to generate the code for GC tracing a variable. The generated MLDS code calls private_builtin:gc_trace/1, passing the variable's address and the type_info for that variable. This code is generated by invoking polymorphism__make_type_info_var to generate HLDS code to build the type_infos needed, and then calling ml_code_gen.m to convert that to MLDS. library/private_builtin.m: Add a new procedure gc_trace, which calls MR_agc_deep_copy(). This gets invoked by the code generated by ml_code_util.m. compiler/polymorphism.m: Export polymorphism__make_type_info_var, for use by ml_code_util.m. compiler/mercury_compile.m: Invoke the chain_gc_stack_frames pass before invoking the hoist_nested_functions pass, since otherwise it doesn't work. compiler/handle_options.m Add a couple of checks for options that are not supported in combination with `--gc accurate'. compiler/ml_call_gen.m: compiler/ml_code_gen.m: compiler/ml_elim_nested.m: compiler/ml_optimize.m: compiler/ml_string_switch.m: compiler/ml_tailcall.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/mlds_to_csharp.m: compiler/mlds_to_gcc.m: compiler/mlds_to_il.m: compiler/mlds_to_java.m: compiler/mlds_to_mcpp.m: compiler/rtti_to_mlds.m: Various changes to handle the GC trace code field for variable and argument declarations. |
||
|
Fergus Henderson
|
36050375bf |
Fix a bug in the handling of pragma c_code / foreign_proc: in
Estimated hours taken: 2 Branches: main compiler/polymorphism.m: Fix a bug in the handling of pragma c_code / foreign_proc: in the case where the procedure had both type class constraints and unconstrained type variables, it was getting the arguments in the wrong order. |
||
|
Tyson Dowd
|
b0d7da6a01 |
Add a field to clauses_info to record whether we have any
Estimated hours taken: 20 Branches: main compiler/hlds_pred.m: Add a field to clauses_info to record whether we have any foreign_proc clauses. Add a new goal type clauses_and_pragmas to describe predicates that have procedures implemented using both pragmas and clauses. Add pred_info_pragma_goal_type and pred_info_clause_goal_type to simplify cases where we are just interested whether the goal types might contain pragmas or goals. compiler/make_hlds.m: Record errors if we try to add a foreign_proc that will replace a Mercury clause that is not mode-specific, or if we try to add a non-mode specific Mercury clause that will replace a foreign proc. Otherwise, we allow a foreign_proc to replace mode-specific Mercury clauses. Set the goal type for potentially mixed mercury/foreign_proc clauses as "clauses". Add Mercury clauses only for modes not yet covered by foreign_proc clauses. Checking this could be a performance problem so we check the have_foreign_clauses boolean so that we don't need to search all the clauses every time we add a Mercury clause (only when there are foreign_clauses to search for). Traverse clauses and decide upon our course of action (add new foreign_proc clause, ignore new foreign_proc clause, replace existing clause, split existing clause and add new clause) all in one go. compiler/clause_to_proc.m: compiler/higher_order.m: compiler/hlds_out.m: compiler/make_hlds.m: compiler/purity.m: compiler/polymorphism.m: compiler/unify_proc.m: Handle have_foreign_clauses field in clauses_info. Handle clauses_and_pragmas goal type. compiler/intermod.m: Handle clauses_and_pragmas goal type. Handle all clauses in a single pass, since we now know on a clause by clause basis whether they are foreign_proc clauses or Mercury clauses we can simplify the traversal of all clauses down to a single pass. doc/reference_manual.texi: doc/user_guide.texi: Document the ability to mix mode-specific Mercury and foreign_proc clauses. Document the behaviour of the implementation when it comes to specific backends (that is, the preferred foreign languages list). Also a few fixes from fjh's review that didn't quite make it into the review. |
||
|
Tyson Dowd
|
cdbbaa5ac2 |
Support multiple language foreign_procs in the one file.
Estimated hours taken: 16 Branches: main Support multiple language foreign_procs in the one file. If there is more then one applicable foreign_proc for a given clause, select the most "preferred" programming language to use as the implementation. Currently only the IL backend has multiple languages supported by the backend, and C# is preferred over MC++. compiler/options.m: compiler/handle_options.m: Rename backend_foreign_language as backend_foreign_languages, and use it to record the list of foreign languages the selected backend can handle. Remove --use-foreign-language as it doesn't do anything right now. compiler/foreign.m: Update code to use the list of backend foreign languages. Add prefer_foreign_language function, to compute the preferred foreign language ordering for each backend. Move simple_foreign_language_string here from globals.m, and add foreign_language_file_extension and foreign_language_module_name functions. (much of the rest of the code in this module is intended to deal with the case where the backend *doesn't* handle the foreign language, but we don't have any working support for that at the moment). compiler/globals.m: Add globals__io_get_backend_foreign_languages and globals__get_backend_foreign_languages. compiler/make_hlds.m: Handle selection of foreign_proc code depending upon the preferred language. Rename a few *_foreign_code predicates as *_foreign_proc predicates. Handle the extra field in clause. compiler/ml_code_gen.m: compiler/mlds.m: Generate different mlds__foreign_code for each language (only one language is selected for each predicate, but there can be multiple languages in the onle module). and put them in a map which is indexed on foreign language. compiler/modules.m: Generate appropriate dependencies for foreign language modules. We now record which languages a list of items uses (taking into account the preferred foreign language for foreign_proc). We also allow for the fact that some foreign_proc declarations won't generate any external modules. compiler/hlds_pred.m: Add an extra field to clause which records which language this clause has been implemented in. compiler/assertion.m: compiler/clause_to_proc.m: compiler/dead_proc_elim.m: compiler/goal_util.m: compiler/hlds_out.m: compiler/inlining.m: compiler/intermod.m: compiler/modes.m: compiler/polymorphism.m: compiler/purity.m: compiler/typecheck.m: compiler/unify_proc.m: Handle the extra field in clause. compiler/mlds_to_c.m: compiler/mlds_to_csharp.m: compiler/mlds_to_gcc.m: compiler/mlds_to_mcpp.m: Select the appropriate mlds__foreign code from the map and generate code for it. |
||
|
Simon Taylor
|
14cdb854dd |
Disable the test which causes us to not pass type-infos to C
Estimated hours taken: 0.1
Branches: main
(This change was sent to mecury-reviews by dgj. I'm committing it
now so that the installation on earth will succeed tonight).
compiler/polymorphism.m:
Disable the test which causes us to not pass type-infos to C
code which do not use the variable corresponding to that type-info.
For some reason, this is causing the compiler to abort when
compiling stage2/browser/declarative_execution.m.
|
||
|
Simon Taylor
|
d701d8ba06 |
Use pred_const cons_ids in the unify_rhs field for constructions
Estimated hours taken: 4
Use pred_const cons_ids in the unify_rhs field for constructions
of higher-order terms. Previously there would be a `cons(sym_name, arity)'
cons_id in the `unify_rhs', and a pred_const in the `unification'.
This avoids multiple calls to get_pred_id_and_proc_id, and is more
consistent with how other cons_ids are handled.
compiler/post_typecheck.m:
Find the pred_const cons_id for constructions of higher-order terms.
Make sure the sym_name field of a call goal is fully module qualified.
compiler/higher_order.m:
compiler/lambda.m:
Use `pred_const' rather than `cons(sym_name, arity)' in the
`unify_rhs' of constructions of higher-order terms.
compiler/polymorphism.m:
compiler/modecheck_unify.m:
Change the interface of polymorphism__convert_pred_to_lambda_goal
to reflect the fact that the pred_proc_id of the higher-order term
has already been computed by post_typecheck.m.
compiler/purity.m:
Don't attempt to resolve overloading if there were type errors.
If the type inference iteration limit was exceeded the code
to resolve overloading of higher-order terms in post_typecheck.m
can abort. This occurred with tests/invalid/type_inf_loop.m.
compiler/hlds_goal.m:
Remove documentation about the restrictions on cons_ids
in a unify_rhs, since they no longer apply.
compiler/intermod.m:
Remove code duplicated from post_typecheck.m.
compiler/hlds_data.m:
Add a comment that code_addr_const cons_ids are no longer
used (they are left over from an old method of constructing
type_ctor_infos).
compiler/hlds_out.m:
Don't abort on code_addr_consts in hlds_out__write_functor_cons_id.
This will avoid problems if anyone decides to start using
code_addr_consts again.
tests/invalid/Mmakefile:
tests/invalid/aditi_update_errors.m:
tests/invalid/aditi_update_derived_relation.{m,err_exp}:
Separate out parts of aditi_update_errors.m which
were no longer being tested because post_typecheck
is no longer run when there are type errors.
tests/invalid/aditi_update_errors.err_exp:
tests/invalid/aditi_update_mode_errors.err_exp:
Update the expected output.
|
||
|
David Jeffery
|
204e151516 |
Do not pass a type-info or typeclass-info to C code that does not use
Estimated hours taken: 9
mercury/compiler/polymorphism.m:
Do not pass a type-info or typeclass-info to C code that does not use
the variable.
To check if the C code uses the variable, we simply check for the
occurence of the variable name in the string that represents the C
code. This is potentially unsafe if the user decides to do something
horrible with the preprocessor, but I don't think this needs to be
specially documented --- AFAIK there is no user-visible documentation
about passing type-infos to and from C anyway.
|
||
|
David Jeffery
|
3ea6e2e88d |
Fix a bug reported by Nick Nethercote. The symptom of this bug was that
Estimated hours taken: 4 Fix a bug reported by Nick Nethercote. The symptom of this bug was that the compiler aborted during the polymorphism transformation for predicates whose type contained a repeated type class constraint. library/map.m: Add a new predicate map__set_from_corresponding_lists which is like map__det_insert_from_corresponding_lists but uses map__set rather than map__det_insert. ie. it does not abort if a duplicate key is provided. Also add a pred map__set_from_assoc_list and function versions of these two new preds to be consistent with map__det_insert_from_corresponding_lists. compiler/polymorphism.m: When building the initial type class info variable map, use map__set_from_corresponding_lists rather than map__det_insert_from_corresponding_lists to take the case of repeated type class constraints into account. tests/valid/Mmakefile: tests/valid/repeated_class_constraint.m: A test case for this. |
||
|
Fergus Henderson
|
59250e8f20 |
Fix bugs with the handling of existentially typed data types
Estimated hours taken: 8 Branches: main, release Fix bugs with the handling of existentially typed data types in various parts of the RTTI code. Most of these bugs were due to passing in the pointer to the secondary tag, rather than the pointer to the first real argument (one word past the secondary tag). library/std_util.m: Fix bugs in ML_expand() and du_get_functor_info. runtime/mercury_tabling.c: Fix bug in MR_table_type(). runtime/mercury_deep_copy_body.h: Fix bug in MR_agc_deep_copy(), the accurate GC version of deep_copy(). Also fix another bug in the same function: when copying existentially typed data types, it was trying to use the type_infos in the original data after they had already been replaced by forwarding pointers. compiler/polymorphism.m: For existentially typed data types, make sure that the type_infos come BEFORE the typeclass_infos, not vice versa. This is needed to match the code in the runtime system. It's also consistent with the way we order them for procedure calls. runtime/mercury_type_info.h: Improve the comments a little. tests/hard_coded/Mmakefile: tests/hard_coded/deep_copy_exist.m: tests/hard_coded/deep_copy_exist.exp: Regression tests. |
||
|
Fergus Henderson
|
36bb97d223 |
Fix a bug where the compiler was silently accepting invalid code.
Estimated hours taken: 6 Branches: main, release Fix a bug where the compiler was silently accepting invalid code. doc/reference_manual.texi: Document that type class methods must have their modes and determinism explicitly declared. compiler/make_hlds.m: Report errors for predicate type class methods with no modes or with modes but no determinism. compiler/check_typeclass.m: compiler/polymorphism.m: Handle the case where a method has no declared determinism: since make_hlds.m will have already reported the error, we just need to avoid aborting or issuing spurious flow-on errors. tests/invalid/Mmakefile: tests/invalid/typeclass_missing_mode.m: tests/invalid/typeclass_missing_mode.err_exp: tests/invalid/typeclass_missing_mode_2.m: tests/invalid/typeclass_missing_mode_2.err_exp: tests/invalid/typeclass_missing_det.m: tests/invalid/typeclass_missing_det.err_exp: tests/invalid/typeclass_missing_det_2.m: tests/invalid/typeclass_missing_det_2.err_exp: tests/invalid/typeclass_missing_det_3.m: tests/invalid/typeclass_missing_det_3.err_exp: Add some regression tests. tests/invalid/tc_err1.err_exp: Update the expected output for this existing test. |
||
|
Adrian Pellas-Rice
|
1c65d003f7 |
Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations.
Estimated hours taken: 4.5
Branches: main
Add the shorthand_goal_expr wrapper type to ease hlds->hlds transformations.
compiler/hlds_goal.m
Create a new type, the `shorthand_goal_expr', for goals kinds that
are implemented by a (ordinary_hlds + shorthand) -> (ordinary_hlds)
transformation. At present, bi_implication is the only kind of
of goal that is implemented in this way.
Moved bi_implication functor from the type goal_expr to the new
shorthand_goal_expr type.
Added the functor shorthand to the goal_expr type.
compiler/*.m
Change switches on hlds_goal_expr that call error when they recognise
`bi_implication' from calling error when they recognise
`bi_implication' to calling error when they recognise `shorthand'.
For all predicates K that
a) switch on hlds_goal_expr and
b) perform non-trivial processing when they recognise
`bi_implication'
change K such that it now calls K_shorthand upon recognising the
functor `shorthand'. Define K_shorthand to switch on
shorthand_goal_expr, where the code for the `bi_implication' case
formerly contained in K is now contained in K_shorthand.
|
||
|
Tyson Dowd
|
711da78188 |
Rename foreign_code as foreign_proc where appropriate in the compiler.
Estimated hours taken: 4.0 Branches: main Rename foreign_code as foreign_proc where appropriate in the compiler. The rationale for this change is that it makes maintaining the code much simpler because it is clear whether `foreign' refers to a slab of code (foreign_code) or a procedure (foreign_proc). :- type pragma_foreign_code_attributes :- type pragma_foreign_proc_attributes The functors for pragma_type foreign(Lang, BodyCode) foreign(Attributes, Name, PredOrFunc, Vars, Varset, Impl) become foreign_code(Lang, BodyCode) foreign_proc(Attributes, Name, PredOrFunc, Vars, Varset, Impl) And the HLDS goal `pragma_foreign_code' becomes `foreign_proc'. compiler/*.m: Update the compiler to use the new names. |
||
|
David Jeffery
|
29baab7783 |
Fix a bug reported by petdr on October 30th last year.
Estimated hours taken: 12
Fix a bug reported by petdr on October 30th last year.
compiler/polymorphism.m:
When looking up the variable which contains a typeclass info for
a particular constraint to be passed to a call, handle the case where
there is *no* variable for such a constraint. This occurs in the case
where the producer of the variable occurs later on in the goal (but
will get re-ordered by the mode checker). The solution is to just
create a variable for the typeclass info, and whenever creating
a `head' variable to hold a constraint being produced by a call,
check first whether there is already a variable allocated for that
constraint.
doc/reference_manual.texi:
Delete mention of this bug from the "Known Bugs" in the existential
types section.
tests/hard_coded/typeclasses/Mmakefile:
tests/hard_coded/typeclasses/reordered_existential_constraint.exp:
tests/hard_coded/typeclasses/reordered_existential_constraint.m:
A test case for this. (Not the same as petdr's original test case,
but much simpler and exhibits the same bug).
|
||
|
Simon Taylor
|
7fc6ce8792 |
Fix a bug which caused some programs using typeclasses to
Estimated hours taken: 6
Fix a bug which caused some programs using typeclasses to
crash with a segmentation fault.
compiler/polymorphism.m:
For typeclass method implementations, make sure the
order of the type-info and typeclass-info arguments
matches the order used by do_call_class_method.
The type-infos for the unconstrained type variables in
the instance declaration and the typeclass-infos for the
constraints on the instance declaration must come
before any other type-infos and typeclass-infos.
compiler/hlds_pred.m:
Add a field to the pred_info type to record for each
typeclass method implementation which class constraints
come from the `:- instance' declaration and which come
from the predicate or function declaration in the
`:- typeclass' declaration.
compiler/check_typeclass.m:
Fill in the new field in the pred_info.
compiler/typecheck.m:
Apply the necessary renamings to the types and
class constraints in the new field in the pred_info.
tests/hard_coded/typeclasses/Mmakefile:
tests/hard_coded/typeclasses/typeclass_order_bug.{m,exp}
tests/hard_coded/typeclasses/typeclass_order_bug2.{m,exp}
tests/hard_coded/typeclasses/typeclass_order_bug3.{m,exp}
Test cases.
|
||
|
Tyson Dowd
|
477ecb18f6 |
Implement pragma foreign_code for Managed C++.
Estimated hours taken: 60 Implement pragma foreign_code for Managed C++. Currently you can only write MC++ code if your backend is capable of generating use MC++ as its "native" foreign language. The IL backend is the only backend that does this at the moment (the other backends have C as their "native" foreign language). Most of the machinery is in place to call from C to (normal) C++ but there is little work done on actually spitting out the C++ code into a separate file. The IL backend does this step already with managed C++. The intention is to turn foreign_code for C++ into a pragma import (which imports the C++ function from a separate file) and foreign_code for C (which calls the imported function). The C++ code will be inserted into a separate file that is compiled using C linkage. The important improvement this change gives is that you can write a module with a C and a MC++ implementations side-by-side. The target backend will select the most appropriate foreign language to use. You can override its choice using --use-foreign-language. Later on we will probably want more flexibility than just a single language selection option). This change also implements :- pragma foreign_decl, which allows header file style declarations to be written in languages other than C. compiler/code_gen.m: Reject code that is not C when generating LLDS. compiler/export.m: Start renaming C as foreign. Reject code that is not C when generating exports. compiler/foreign.m: A new module to handle foreign language interfacing. The bulk of the code for pragma import has been moved here from make_hlds. compiler/globals.m: Convert foreign language names to foreign_language. This code has been moved closer to the similar conversion we do for target language names. Add globals__io_lookup_foreign_language_option to make it easier to deterministically lookup the options relating to foreign languages. compiler/hlds_module.m: Move module_add_foreign_decl and module_add_foreign_body_code from make_hlds.m (where they were called module_add_c_header and module_add_c_code). compiler/hlds_out.m: Write the foreign language out in HLDS dumps. compiler/llds.m: Change foreign_header_info to foreign_decl_info. Change definitions of foreign_decl_code and foreign_body_code to include the language. compiler/llds_out.m: Reject code that is not C when writing out LLDS. compiler/make_hlds.m: Add foreign language information to the bodys and decls when creating them. Update error messages to refer to foreign code instead of C code. Use foreign.m to generate interfaces from the backend language to the foreign language. Hardcode C as the language for fact tables. compiler/mercury_compile.m: Collect the appropriate foreign language code together for output to the backend. compiler/intermod.m: compiler/mercury_to_mercury.m: Output the foreign language string. Change a few names to foreign_code instead of c_code. compiler/ml_code_gen.m: Filter the foreign language bodys and decls so that we only get the ones we are in (given by the use-foreign-language option). compiler/mlds_to_c.m: Abort if we are given non C foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/mlds_to_ilasm.m: Abort if we are given non MC++ foreign language code to output (we might handle it here in future, or we might handle it elsewhere). compiler/options.m: compiler/handle_options.m: Add --use-foreign-language as a user option to control the preferred foreign language to use as the implementation of this module. Add backend_foreign_language as an internal option which stores the foreign language that the compiler will use as a default (e.g. the natural foreign language for the backend to use). Set the preferred backend foreign language depending on the target. compiler/prog_data.m: Add managedcplusplus as a new alternative for the foreign_language type. Make c_header_code into foreign_decl. Give the foreign language for foreign_code as an attribute of the code. Write code to turn attributes into a list of strings (suitable for writing out by mercury_to_mercury). This fixes what appears to be a bug in tabled_for_io -- the tabled_for_io attribute was not being written out. Structure the code so this bug is difficult to repeat in future. compiler/prog_io_pragma.m: Parse foreign_decl. Turn c_header_code into a special case of foreign_decl. compiler/*.m: Remove the language field from pragma_foreign_code, it is now an attribute of the code. Various type and variable renamings. tests/invalid/pragma_c_code_and_clauses1.err_exp: tests/invalid/pragma_c_code_dup_var.err_exp: tests/warnings/singleton_test.exp: Update the tests to reflect the new error messages talking about :- pragma foreign_code rather than :- pragma c_code. |
||
|
David Jeffery
|
e29f9a3d2f |
Fix a bug whereby polymorphism was not using the complete set of class
Estimated hours taken: 5
Fix a bug whereby polymorphism was not using the complete set of class
constraint proofs when generating a type class info, resulting in a map
lookup failure under certain conditions.
compiler/polymorphism.m:
When generating a type class info, don't just pass the proofs for
the instance declaration that we calculated in check_typeclass.m.
These proofs just specify how to build the type class infos for any
superclass constraints *given the constraints on the instance
declaration*. Instead, we pass the union of those constraints and
those local to the predicate. This provides proofs for the constraints
on the instance declaration too.
compiler/typecheck.m:
Rather than using the headvars as the set of variables that must not
be bound when searching the superclass relation, use all the variables
in the varset. This remove a parameter from the exported constraint
reduction predicate.
compiler/check_typeclass.m:
Remove the redundant parameter.
tests/hard_coded/typeclasses/Mmakefile:
tests/hard_coded/typeclasses/superclass_bug2.exp:
tests/hard_coded/typeclasses/superclass_bug2.m:
A test case for this.
|
||
|
Fergus Henderson
|
e6769ef622 |
Record the module that each instance declaration came from.
Estimated hours taken: 8 Record the module that each instance declaration came from. This is needed for the IL back-end, which includes that module name in the symbol name that it generates for each instance declaration. compiler/prog_data.m: Add a module_name field to the `instance' item. compiler/prog_io_typeclass.m: When parsing `instance' declarations, store the module name that they came from in the module_name field of the `instance' item. compiler/hlds_data.m: Add a module_name field to the `hlds_instance_defn' structure. compiler/make_hlds.m: Copy the module_name field from the `instance' item to the `hlds_instance_defn' structure. compiler/polymorphism.m: Fix an old XXX: when constructing `base_typeclass_info_const's, use the module name from the `hlds_instance_defn', rather than hard-coding the invalid value "some bogus module name". compiler/rtti.m: Add a module_name field to the `base_typeclass_info' rtti_name and rtti_data. compiler/base_typeclass_info.m: Copy the module_name field in the `hlds_instance_defn' to the module_name field in the `base_typeclass_info' rtti_data and rtti_name. compiler/rtti_to_mlds.m: When constructing mlds `data_addr's, use the module_name from the `base_typeclass_info' rtti_name, rather than assuming that such references always refer to instance declarations in the current module. (That assumption would be a safe one currently, but doing it this way is probably a bit more robust against future changes.) compiler/*.m: Trivial changes to reflect the above data structure changes. |
||
|
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. |