mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-19 07:45:09 +00:00
d69ba1a1f0
Estimated hours taken: 32 Branches: main Include the type_ctor in cons_ids for user-defined types. The intention is two-fold: - It prepares for a future in which we allow more than one function symbol to with the same name to be defined in a module. - It makes the HLDS code more self-contained. In many places, processing construction and deconstruction unifications required knowing which type the cons_id belongs to, but until now, code couldn't know that unless it kept track of the type of the variable unified with the cons_id. With this diff, user-defined cons_ids are represented as cons(SymName, Arity, TypeCtor) The last field is filled in during post-typecheck. After that time, any module qualification in the SymName (which may initially be partial) is redundant, since it is also available in the TypeCtor. In the future, we could make all those SymNames be just unqualified(_) at that time. We could also replace the current maps in HLDS type definitions with full cons_id keys with just name/arity keys (since the module qualifier is a given for any given type definition), we could also support partially qualified cons_ids in source code using a map from name/arity pairs to a list of all the type_ctors that have function symbols with that name/arity, instead of our current practice of inserting all possible partially module qualified version of every cons_id into a single giant table, and we could do the same thing with the field names table. This diff also separates tuples out from user-defined types, since in many respects they are different (they don't have a single type_ctor, for starters). It also separates out character constants, since they were alreay treated specially in most places, though not in some places where they *ought* to have been treated specially. Take the opportunity to give some other cons_ids better names. compiler/prog_data.m: Make the change described above, and document it. Put the implementations of the predicates declared in each part of this module next to the declarations, instead of keeping all the code until the very end (where it was usually far from their declarations). Remove three predicates with identical definitions from inst_match.m, inst_util.m and mode_constraints.m, and put the common definition in prog_data.m. library/term_io.m: Add a new predicate that is basically a reversible version of the existing function espaced_char, since the definition of char_consts needs reversibilty. compiler/post_typecheck.m: For functors of user-defined types, record their type_ctor. For tuples and char constants, record them as such. compiler/builtin_lib_types.m: compiler/parse_tree.m: compiler/notes/compiler_design.html: New module to centralize knowledge about builtin types, specially handled library types, and their function symbols. Previously, the stuff now in this module used to be in several different places, including prog_type.m and stm_expand.m, and some of it was duplicated. mdbcomp/prim_data.m: Add some predicates now needed by builtin_lib_types.m. compiler/builtin_ops.m: Factor out some duplicated code. compiler/add_type.m: Include the relevant type_ctors in the cons_ids generated in type definitions. compiler/hlds_data.m: Document an existing type better. Rename a cons_tag in sync with its corresponding cons_id. Put some declarations into logical order. compiler/hlds_out.m: Rename a misleadingly-named predicate. compiler/prog_ctgc.m: compiler/term_constr_build.m: Add XXXs for questionable existing code. compiler/add_clause.m: compiler/add_heap_ops.m: compiler/add_pragma.m: compiler/add_pred.m: compiler/add_trail_ops.m: compiler/assertion.m: compiler/bytecode_gen.m: compiler/closure_analysis.m: compiler/code_info.m: compiler/complexity.m: compiler/ctgc_selector.m: compiler/dead_proc_elim.m: compiler/deep_profiling.m: compiler/delay_partial_inst.m: compiler/dependency_graph.m: compiler/det_analysis.m: compiler/det_report.m: compiler/distance_granularity.m: compiler/erl_rtti.m: compiler/erl_unify_gen.m: compiler/export.m: compiler/field_access.m: compiler/foreign.m: compiler/format_call.m: compiler/hhf.m: compiler/higher_order.m: compiler/hlds_code_util.m: compiler/hlds_desc.m: compiler/hlds_goal.m: compiler/implementation_defined_literals.m: compiler/inst_check.m: compiler/inst_graph.m: compiler/inst_match.m: compiler/inst_util.m: compiler/instmap.m: compiler/intermod.m: compiler/interval.m: compiler/lambda.m: compiler/lco.m: compiler/make_tags.m: compiler/mercury_compile.m: compiler/mercury_to_mercury.m: compiler/middle_rec.m: compiler/ml_closure_gen.m: compiler/ml_code_gen.m: compiler/ml_code_util.m: compiler/ml_switch_gen.m: compiler/ml_type_gen.m: compiler/ml_unify_gen.m: compiler/ml_util.m: compiler/mlds_to_c.m: compiler/mlds_to_java.m: compiler/mode_constraints.m: compiler/mode_errors.m: compiler/mode_ordering.m: compiler/mode_util.m: compiler/modecheck_unify.m: compiler/modes.m: compiler/module_qual.m: compiler/polymorphism.m: compiler/prog_ctgc.m: compiler/prog_event.m: compiler/prog_io_util.m: compiler/prog_mode.m: compiler/prog_mutable.m: compiler/prog_out.m: compiler/prog_type.m: compiler/prog_util.m: compiler/purity.m: compiler/qual_info.m: compiler/rbmm.add_rbmm_goal_infos.m: compiler/rbmm.execution_path.m: compiler/rbmm.points_to_analysis.m: compiler/rbmm.region_transformation.m: compiler/recompilation.usage.m: compiler/rtti.m: compiler/rtti_out.m: compiler/rtti_to_mlds.m: compiler/simplify.m: compiler/simplify.m: compiler/special_pred.m: compiler/ssdebug.m: compiler/stack_opt.m: compiler/stm_expand.m: compiler/stratify.m: compiler/structure_reuse.direct.detect_garbagem: compiler/superhomoegenous.m: compiler/switch_detection.m: compiler/switch_gen.m: compiler/switch_util.m: compiler/table_gen.m: compiler/term_constr_build.m: compiler/term_norm.m: compiler/try_expand.m: compiler/type_constraints.m: compiler/type_ctor_info.m: compiler/type_util.m: compiler/typecheck.m: compiler/typecheck_errors.m: compiler/unify_gen.m: compiler/unify_proc.m: compiler/unify_modes.m: compiler/untupling.m: compiler/unused_imports.m: compiler/xml_documentation.m: Minor changes, mostly to ignore the type_ctor in cons_ids in places where it is not needed, take the type_ctor from the cons_id in places where it is more convenient, conform to the new names of some cons_ids, conform to the changes in hlds_out.m, and/or add now-needed imports of builtin_lib_types.m. In some places, the handling previously applied to cons/2 (which included tuples and character constants as well as user-defined function symbols) is now applied only to user-defined function symbols or to user-defined function symbols and tuples, as appropriate, with character constants being handled more like the other kinds of constants. In inst_match.m, rename a whole bunch of predicates to avoid ambiguities. In prog_util.m, remove two predicates that did almost nothing yet were far too easy to misuse.
286 lines
11 KiB
Mathematica
286 lines
11 KiB
Mathematica
%-----------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%-----------------------------------------------------------------------------%
|
|
% Copyright (C) 1999-2001, 2003-2006, 2009 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU General
|
|
% Public License - see the file COPYING in the Mercury distribution.
|
|
%-----------------------------------------------------------------------------%
|
|
%
|
|
% File: builtin_ops.m -- defines the builtin operator types.
|
|
% Main author: fjh.
|
|
%
|
|
% This module defines various types which enumerate the different builtin
|
|
% operators. Several of the different back-ends -- the bytecode back-end,
|
|
% the LLDS, and the MLDS -- all use the same set of builtin operators.
|
|
% These operators are defined here.
|
|
%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- module backend_libs.builtin_ops.
|
|
:- interface.
|
|
|
|
:- import_module hlds.
|
|
:- import_module hlds.hlds_pred.
|
|
:- import_module mdbcomp.
|
|
:- import_module mdbcomp.prim_data.
|
|
|
|
:- import_module list.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- type unary_op
|
|
---> mktag
|
|
; tag
|
|
; unmktag
|
|
; strip_tag
|
|
; mkbody
|
|
; unmkbody
|
|
; hash_string
|
|
; bitwise_complement
|
|
; logical_not.
|
|
|
|
:- type binary_op
|
|
---> int_add
|
|
; int_sub
|
|
; int_mul
|
|
; int_div % assumed to truncate toward zero
|
|
; int_mod % remainder (w.r.t. truncating integer division)
|
|
% XXX `mod' should be renamed `rem'
|
|
; unchecked_left_shift
|
|
; unchecked_right_shift
|
|
; bitwise_and
|
|
; bitwise_or
|
|
; bitwise_xor
|
|
; logical_and
|
|
; logical_or
|
|
; eq % ==
|
|
; ne % !=
|
|
; body
|
|
; array_index(array_elem_type)
|
|
; str_eq % string comparisons
|
|
; str_ne
|
|
; str_lt
|
|
; str_gt
|
|
; str_le
|
|
; str_ge
|
|
; int_lt % signed integer comparions
|
|
; int_gt
|
|
; int_le
|
|
; int_ge
|
|
; unsigned_le % unsigned integer comparison
|
|
% Note that the arguments to `unsigned_le' are just ordinary
|
|
% (signed) Mercury ints, but it does the comparison as
|
|
% if they were first cast to an unsigned type, so e.g.
|
|
% binary(unsigned_le, int_const(1), int_const(-1)) returns true,
|
|
% since (MR_Unsigned) 1 <= (MR_Unsigned) -1.
|
|
|
|
; float_plus
|
|
; float_minus
|
|
; float_times
|
|
; float_divide
|
|
; float_eq
|
|
; float_ne
|
|
; float_lt
|
|
; float_gt
|
|
; float_le
|
|
; float_ge
|
|
|
|
; compound_eq
|
|
; compound_lt.
|
|
% Comparisons on values of non-atomic types. This is likely to be
|
|
% supported only on very high-level back-ends.
|
|
|
|
% For the MLDS back-end, we need to know the element type for each
|
|
% array_index operation.
|
|
%
|
|
% Currently array index operations are only generated in limited
|
|
% circumstances. Using a simple representation for them here,
|
|
% rather than just putting the MLDS type here, avoids the need
|
|
% for this module to depend on back-end specific stuff like MLDS types.
|
|
:- type array_elem_type
|
|
---> elem_type_string % ml_string_type
|
|
; elem_type_int % mlds_native_int_type
|
|
; elem_type_generic. % mlds_generic_type
|
|
|
|
% translate_builtin:
|
|
%
|
|
% Given a module name, a predicate name, a proc_id and a list of the
|
|
% arguments, find out if that procedure of that predicate is an inline
|
|
% builtin. If so, return code which can be used to evaluate that call:
|
|
% either an assignment (if the builtin is det) or a test (if the builtin
|
|
% is semidet).
|
|
%
|
|
% There are some further guarantees on the form of the expressions
|
|
% in the code returned -- see below for details.
|
|
% (bytecode_gen.m depends on these guarantees.)
|
|
%
|
|
:- pred translate_builtin(module_name::in, string::in, proc_id::in,
|
|
list(T)::in, simple_code(T)::out(simple_code)) is semidet.
|
|
|
|
:- type simple_code(T)
|
|
---> assign(T, simple_expr(T))
|
|
; ref_assign(T, T)
|
|
; test(simple_expr(T))
|
|
; noop(list(T)).
|
|
|
|
:- type simple_expr(T)
|
|
---> leaf(T)
|
|
; int_const(int)
|
|
; float_const(float)
|
|
; unary(unary_op, simple_expr(T))
|
|
; binary(binary_op, simple_expr(T), simple_expr(T)).
|
|
|
|
% Each test expression returned is guaranteed to be either a unary
|
|
% or binary operator, applied to arguments that are either variables
|
|
% (from the argument list) or constants.
|
|
%
|
|
% Each to be assigned expression is guaranteed to be either in a form
|
|
% acceptable for a test rval, or in the form of a variable.
|
|
|
|
:- inst simple_code
|
|
---> assign(ground, simple_assign_expr)
|
|
; ref_assign(ground, ground)
|
|
; test(simple_test_expr)
|
|
; noop(ground).
|
|
|
|
:- inst simple_arg_expr
|
|
---> leaf(ground)
|
|
; int_const(ground)
|
|
; float_const(ground).
|
|
|
|
:- inst simple_test_expr
|
|
---> unary(ground, simple_arg_expr)
|
|
; binary(ground, simple_arg_expr, simple_arg_expr).
|
|
|
|
:- inst simple_assign_expr
|
|
---> unary(ground, simple_arg_expr)
|
|
; binary(ground, simple_arg_expr, simple_arg_expr)
|
|
; leaf(ground).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
|
|
translate_builtin(FullyQualifiedModule, PredName, ProcId, Args, Code) :-
|
|
proc_id_to_int(ProcId, ProcInt),
|
|
is_std_lib_module_name(FullyQualifiedModule, ModuleName),
|
|
builtin_translation(ModuleName, PredName, ProcInt, Args, Code).
|
|
|
|
:- pred builtin_translation(string::in, string::in, int::in, list(T)::in,
|
|
simple_code(T)::out(simple_code)) is semidet.
|
|
|
|
builtin_translation("private_builtin", "trace_get_io_state", 0, [X],
|
|
noop([X])).
|
|
builtin_translation("private_builtin", "trace_set_io_state", 0, [_X],
|
|
noop([])).
|
|
|
|
builtin_translation("private_builtin", "store_at_ref", 0, [X, Y],
|
|
ref_assign(X, Y)).
|
|
builtin_translation("private_builtin", "store_at_ref_impure", 0, [X, Y],
|
|
ref_assign(X, Y)).
|
|
|
|
% Note that the code we generate for unsafe_type_cast is not type-correct.
|
|
% Back-ends that require type-correct intermediate code (e.g. the MLDS
|
|
% back-end) must handle unsafe_type_cast separately, rather than by calling
|
|
% builtin_translation.
|
|
builtin_translation("private_builtin", "unsafe_type_cast", 0, [X, Y],
|
|
assign(Y, leaf(X))).
|
|
builtin_translation("builtin", "unsafe_promise_unique", 0, [X, Y],
|
|
assign(Y, leaf(X))).
|
|
|
|
builtin_translation("private_builtin", "builtin_int_gt", 0, [X, Y],
|
|
test(binary(int_gt, leaf(X), leaf(Y)))).
|
|
builtin_translation("private_builtin", "builtin_int_lt", 0, [X, Y],
|
|
test(binary(int_lt, leaf(X), leaf(Y)))).
|
|
|
|
builtin_translation("private_builtin", "builtin_compound_eq", 0, [X, Y],
|
|
test(binary(compound_eq, leaf(X), leaf(Y)))).
|
|
builtin_translation("private_builtin", "builtin_compound_lt", 0, [X, Y],
|
|
test(binary(compound_lt, leaf(X), leaf(Y)))).
|
|
|
|
builtin_translation("term_size_prof_builtin", "term_size_plus", 0, [X, Y, Z],
|
|
assign(Z, binary(int_add, leaf(X), leaf(Y)))).
|
|
|
|
builtin_translation("int", "+", 0, [X, Y, Z],
|
|
assign(Z, binary(int_add, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "+", 1, [X, Y, Z],
|
|
assign(X, binary(int_sub, leaf(Z), leaf(Y)))).
|
|
builtin_translation("int", "+", 2, [X, Y, Z],
|
|
assign(Y, binary(int_sub, leaf(Z), leaf(X)))).
|
|
builtin_translation("int", "plus", 0, [X, Y, Z],
|
|
assign(Z, binary(int_add, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "-", 0, [X, Y, Z],
|
|
assign(Z, binary(int_sub, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "-", 1, [X, Y, Z],
|
|
assign(X, binary(int_add, leaf(Y), leaf(Z)))).
|
|
builtin_translation("int", "-", 2, [X, Y, Z],
|
|
assign(Y, binary(int_sub, leaf(X), leaf(Z)))).
|
|
builtin_translation("int", "minus", 0, [X, Y, Z],
|
|
assign(Z, binary(int_sub, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "*", 0, [X, Y, Z],
|
|
assign(Z, binary(int_mul, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "times", 0, [X, Y, Z],
|
|
assign(Z, binary(int_mul, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "unchecked_quotient", 0, [X, Y, Z],
|
|
assign(Z, binary(int_div, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "unchecked_rem", 0, [X, Y, Z],
|
|
assign(Z, binary(int_mod, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "unchecked_left_shift", 0, [X, Y, Z],
|
|
assign(Z, binary(unchecked_left_shift, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "unchecked_right_shift", 0, [X, Y, Z],
|
|
assign(Z, binary(unchecked_right_shift, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "/\\", 0, [X, Y, Z],
|
|
assign(Z, binary(bitwise_and, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "\\/", 0, [X, Y, Z],
|
|
assign(Z, binary(bitwise_or, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "xor", 0, [X, Y, Z],
|
|
assign(Z, binary(bitwise_xor, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "xor", 1, [X, Y, Z],
|
|
assign(Y, binary(bitwise_xor, leaf(X), leaf(Z)))).
|
|
builtin_translation("int", "xor", 2, [X, Y, Z],
|
|
assign(X, binary(bitwise_xor, leaf(Y), leaf(Z)))).
|
|
builtin_translation("int", "+", 0, [X, Y],
|
|
assign(Y, leaf(X))).
|
|
builtin_translation("int", "-", 0, [X, Y],
|
|
assign(Y, binary(int_sub, int_const(0), leaf(X)))).
|
|
builtin_translation("int", "\\", 0, [X, Y],
|
|
assign(Y, unary(bitwise_complement, leaf(X)))).
|
|
|
|
builtin_translation("int", ">", 0, [X, Y],
|
|
test(binary(int_gt, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "<", 0, [X, Y],
|
|
test(binary(int_lt, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", ">=", 0, [X, Y],
|
|
test(binary(int_ge, leaf(X), leaf(Y)))).
|
|
builtin_translation("int", "=<", 0, [X, Y],
|
|
test(binary(int_le, leaf(X), leaf(Y)))).
|
|
|
|
builtin_translation("float", "+", 0, [X, Y, Z],
|
|
assign(Z, binary(float_plus, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", "-", 0, [X, Y, Z],
|
|
assign(Z, binary(float_minus, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", "*", 0, [X, Y, Z],
|
|
assign(Z, binary(float_times, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", "unchecked_quotient", 0, [X, Y, Z],
|
|
assign(Z, binary(float_divide, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", "+", 0, [X, Y],
|
|
assign(Y, leaf(X))).
|
|
builtin_translation("float", "-", 0, [X, Y],
|
|
assign(Y, binary(float_minus, float_const(0.0), leaf(X)))).
|
|
|
|
builtin_translation("float", ">", 0, [X, Y],
|
|
test(binary(float_gt, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", "<", 0, [X, Y],
|
|
test(binary(float_lt, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", ">=", 0, [X, Y],
|
|
test(binary(float_ge, leaf(X), leaf(Y)))).
|
|
builtin_translation("float", "=<", 0, [X, Y],
|
|
test(binary(float_le, leaf(X), leaf(Y)))).
|
|
|
|
%-----------------------------------------------------------------------------%
|
|
:- end_module builtin_ops.
|
|
%-----------------------------------------------------------------------------%
|