Make-lang.in (fortran/f95-lang.o): Update dependencies.

* Make-lang.in (fortran/f95-lang.o): Update dependencies.
        (fortran/trans-decl.o, fortran/trans-types.o): Likewise.
        * gfortran.h (gfc_integer_info): Add c_char, c_short, c_int,
        c_long, c_long_long.
        (gfc_logical_info): Add c_bool.
        (gfc_real_info): Add mode_precision, c_float, c_double, c_long_double.
        * trans-array.c (gfc_array_allocate): Use TYPE_PRECISION
        rather than gfc_int[48]_type_node for allocate choice.
        * trans-decl.c (gfc_build_intrinsic_function_decls): Cache
        local copies of some kind type nodes.
        (gfc_build_builtin_function_decls): Likewise.
        * trans-expr.c (gfc_conv_power_op): Likewise.
        * trans-intrinsic.c (gfc_conv_intrinsic_index,
        gfc_conv_intrinsic_scan, gfc_conv_intrinsic_verify,
        gfc_conv_intrinsic_trim, gfc_conv_intrinsic_repeat): Likewise.
        * trans-stmt.c (gfc_trans_pause, gfc_trans_stop,
        gfc_trans_character_select, gfc_trans_allocate): Likewise.
        * trans-io.c (gfc_pint4_type_node): Move into ...
        (gfc_build_io_library_fndecls): ... here.  Cache local copies of
        some kind type nodes.
        * trans-types.c (gfc_type_nodes): Remove.
        (gfc_character1_type_node, gfc_strlen_type_node): New.
        (gfc_integer_types, gfc_logical_types): New.
        (gfc_real_types, gfc_complex_types): New.
        (gfc_init_kinds): Fill in real mode_precision.
        (gfc_build_int_type, gfc_build_real_type): New.
        (gfc_build_complex_type, gfc_build_logical_type): New.
        (c_size_t_size): New.
        (gfc_init_types): Loop over kinds.
        (gfc_get_int_type, gfc_get_real_type): Use gfc_validate_kind.
        (gfc_get_complex_type, gfc_get_logical_type): Likewise.
        (gfc_get_character_type_len): Likewise.
        (gfc_type_for_size): Loop over kinds; use a reduced set of
        unsigned type nodes.
        (gfc_type_for_mode): Loop over kinds.
        (gfc_signed_or_unsigned_type): Use gfc_type_for_size.
        (gfc_unsigned_type, gfc_signed_type): Use gfc_signed_or_unsigned_type.
        * trans-types.h (F95_INT1_TYPE, F95_INT2_TYPE, F95_INT4_TYPE,
        F95_INT8_TYPE, F95_INT16_TYPE, F95_REAL4_TYPE, F95_REAL8_TYPE,
        F95_REAl16_TYPE, F95_COMPLEX4_TYPE, F95_COMPLEX8_TYPE,
        F95_COMPLEX16_TYPE, F95_LOGICAL1_TYPE, F95_LOGICAL2_TYPE,
        F95_LOGICAL4_TYPE, F95_LOGICAL8_TYPE, F95_LOGICAL16_TYPE,
        F95_CHARACTER1_TYPE, NUM_F95_TYPES, gfc_type_nodes,
        gfc_int1_type_node, gfc_int2_type_node, gfc_int4_type_node,
        gfc_int8_type_node, gfc_int16_type_node, gfc_real4_type_node,
        gfc_real8_type_node, gfc_real16_type_node, gfc_complex4_type_node,
        gfc_complex8_type_node, gfc_complex16_type_node,
        gfc_logical1_type_node, gfc_logical2_type_node,
        gfc_logical4_type_node, gfc_logical8_type_node,
        gfc_logical16_type_node, gfc_strlen_kind): Remove.
        (gfc_character1_type_node): Turn in to a variable.
        (gfc_strlen_type_node): Likewise.

From-SVN: r86806
This commit is contained in:
Richard Henderson 2004-08-30 14:59:08 -07:00 committed by Richard Henderson
parent bc482be493
commit e2cad04b28
11 changed files with 369 additions and 414 deletions

View File

@ -1,3 +1,58 @@
2004-08-30 Richard Henderson <rth@redhat.com>
* Make-lang.in (fortran/f95-lang.o): Update dependencies.
(fortran/trans-decl.o, fortran/trans-types.o): Likewise.
* gfortran.h (gfc_integer_info): Add c_char, c_short, c_int,
c_long, c_long_long.
(gfc_logical_info): Add c_bool.
(gfc_real_info): Add mode_precision, c_float, c_double, c_long_double.
* trans-array.c (gfc_array_allocate): Use TYPE_PRECISION
rather than gfc_int[48]_type_node for allocate choice.
* trans-decl.c (gfc_build_intrinsic_function_decls): Cache
local copies of some kind type nodes.
(gfc_build_builtin_function_decls): Likewise.
* trans-expr.c (gfc_conv_power_op): Likewise.
* trans-intrinsic.c (gfc_conv_intrinsic_index,
gfc_conv_intrinsic_scan, gfc_conv_intrinsic_verify,
gfc_conv_intrinsic_trim, gfc_conv_intrinsic_repeat): Likewise.
* trans-stmt.c (gfc_trans_pause, gfc_trans_stop,
gfc_trans_character_select, gfc_trans_allocate): Likewise.
* trans-io.c (gfc_pint4_type_node): Move into ...
(gfc_build_io_library_fndecls): ... here. Cache local copies of
some kind type nodes.
* trans-types.c (gfc_type_nodes): Remove.
(gfc_character1_type_node, gfc_strlen_type_node): New.
(gfc_integer_types, gfc_logical_types): New.
(gfc_real_types, gfc_complex_types): New.
(gfc_init_kinds): Fill in real mode_precision.
(gfc_build_int_type, gfc_build_real_type): New.
(gfc_build_complex_type, gfc_build_logical_type): New.
(c_size_t_size): New.
(gfc_init_types): Loop over kinds.
(gfc_get_int_type, gfc_get_real_type): Use gfc_validate_kind.
(gfc_get_complex_type, gfc_get_logical_type): Likewise.
(gfc_get_character_type_len): Likewise.
(gfc_type_for_size): Loop over kinds; use a reduced set of
unsigned type nodes.
(gfc_type_for_mode): Loop over kinds.
(gfc_signed_or_unsigned_type): Use gfc_type_for_size.
(gfc_unsigned_type, gfc_signed_type): Use gfc_signed_or_unsigned_type.
* trans-types.h (F95_INT1_TYPE, F95_INT2_TYPE, F95_INT4_TYPE,
F95_INT8_TYPE, F95_INT16_TYPE, F95_REAL4_TYPE, F95_REAL8_TYPE,
F95_REAl16_TYPE, F95_COMPLEX4_TYPE, F95_COMPLEX8_TYPE,
F95_COMPLEX16_TYPE, F95_LOGICAL1_TYPE, F95_LOGICAL2_TYPE,
F95_LOGICAL4_TYPE, F95_LOGICAL8_TYPE, F95_LOGICAL16_TYPE,
F95_CHARACTER1_TYPE, NUM_F95_TYPES, gfc_type_nodes,
gfc_int1_type_node, gfc_int2_type_node, gfc_int4_type_node,
gfc_int8_type_node, gfc_int16_type_node, gfc_real4_type_node,
gfc_real8_type_node, gfc_real16_type_node, gfc_complex4_type_node,
gfc_complex8_type_node, gfc_complex16_type_node,
gfc_logical1_type_node, gfc_logical2_type_node,
gfc_logical4_type_node, gfc_logical8_type_node,
gfc_logical16_type_node, gfc_strlen_kind): Remove.
(gfc_character1_type_node): Turn in to a variable.
(gfc_strlen_type_node): Likewise.
2004-08-30 Tobias Schlueter <tobias.schlueter@physik.uni-muenchen.de>
* gfortran.h (gfc_namespace): Add new field is_block_data.

View File

@ -278,14 +278,17 @@ $(F95_PARSER_OBJS): fortran/gfortran.h fortran/intrinsic.h fortran/match.h \
GFORTRAN_TRANS_DEPS = fortran/gfortran.h fortran/intrinsic.h fortran/trans-array.h \
fortran/trans-const.h fortran/trans-const.h fortran/trans.h \
fortran/trans-stmt.h fortran/trans-types.h \
$(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(TM_H) coretypes.h
$(CONFIG_H) $(SYSTEM_H) $(TREE_H) $(TM_H) coretypes.h $(GGC_H)
fortran/f95-lang.o: $(GFORTRAN_TRANS_DEPS) fortran/mathbuiltins.def \
gt-fortran-f95-lang.h gtype-fortran.h cgraph.h
gt-fortran-f95-lang.h gtype-fortran.h cgraph.h $(TARGET_H)
fortran/convert.o: $(GFORTRAN_TRANS_DEPS)
fortran/trans.o: $(GFORTRAN_TRANS_DEPS)
fortran/trans-decl.o: $(GFORTRAN_TRANS_DEPS) gt-fortran-trans-decl.h cgraph.h
fortran/trans-types.o: $(GFORTRAN_TRANS_DEPS) gt-fortran-trans-types.h
fortran/trans-decl.o: $(GFORTRAN_TRANS_DEPS) gt-fortran-trans-decl.h \
cgraph.h $(TARGET_H) function.h errors.h $(FLAGS_H) tree-gimple.h \
tree-dump.h
fortran/trans-types.o: $(GFORTRAN_TRANS_DEPS) gt-fortran-trans-types.h \
real.h toplev.h $(TARGET_H)
fortran/trans-const.o: $(GFORTRAN_TRANS_DEPS)
fortran/trans-expr.o: $(GFORTRAN_TRANS_DEPS)
fortran/trans-stmt.o: $(GFORTRAN_TRANS_DEPS)

View File

@ -1090,12 +1090,18 @@ gfc_expr;
typedef struct
{
int kind, radix, digits, bit_size;
/* Values really representable by the target. */
mpz_t huge, min_int, max_int;
int range;
mpz_t huge;
int kind, radix, digits, bit_size, range;
mpz_t min_int, max_int; /* Values really representable by the target */
/* True if the C type of the given name maps to this precision.
Note that more than one bit can be set. */
unsigned int c_char : 1;
unsigned int c_short : 1;
unsigned int c_int : 1;
unsigned int c_long : 1;
unsigned int c_long_long : 1;
}
gfc_integer_info;
@ -1106,6 +1112,8 @@ typedef struct
{
int kind, bit_size;
/* True if the C++ type bool, C99 type _Bool, maps to this precision. */
unsigned int c_bool : 1;
}
gfc_logical_info;
@ -1114,10 +1122,18 @@ extern gfc_logical_info gfc_logical_kinds[];
typedef struct
{
int kind, radix, digits, min_exponent, max_exponent;
int range, precision;
mpfr_t epsilon, huge, tiny;
int kind, radix, digits, min_exponent, max_exponent;
int range, precision;
/* The precision of the type as reported by GET_MODE_PRECISION. */
int mode_precision;
/* True if the C type of the given name maps to this precision.
Note that more than one bit can be set. */
unsigned int c_float : 1;
unsigned int c_double : 1;
unsigned int c_long_double : 1;
}
gfc_real_info;

View File

@ -2784,9 +2784,9 @@ gfc_array_allocate (gfc_se * se, gfc_ref * ref, tree pstat)
pointer = gfc_build_addr_expr (NULL, tmp);
pointer = gfc_evaluate_now (pointer, &se->pre);
if (gfc_array_index_type == gfc_int4_type_node)
if (TYPE_PRECISION (gfc_array_index_type) == 32)
allocate = gfor_fndecl_allocate;
else if (gfc_array_index_type == gfc_int8_type_node)
else if (TYPE_PRECISION (gfc_array_index_type) == 64)
allocate = gfor_fndecl_allocate64;
else
abort ();

View File

@ -1559,6 +1559,14 @@ gfc_build_library_function_decl (tree name, tree rettype, int nargs, ...)
static void
gfc_build_intrinsic_function_decls (void)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
tree gfc_int8_type_node = gfc_get_int_type (8);
tree gfc_logical4_type_node = gfc_get_logical_type (4);
tree gfc_real4_type_node = gfc_get_real_type (4);
tree gfc_real8_type_node = gfc_get_real_type (8);
tree gfc_complex4_type_node = gfc_get_complex_type (4);
tree gfc_complex8_type_node = gfc_get_complex_type (8);
/* String functions. */
gfor_fndecl_copy_string =
gfc_build_library_function_decl (get_identifier (PREFIX("copy_string")),
@ -1738,6 +1746,10 @@ gfc_build_intrinsic_function_decls (void)
void
gfc_build_builtin_function_decls (void)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
tree gfc_int8_type_node = gfc_get_int_type (8);
tree gfc_logical4_type_node = gfc_get_logical_type (4);
gfor_fndecl_internal_malloc =
gfc_build_library_function_decl (get_identifier (PREFIX("internal_malloc")),
pvoid_type_node, 1, gfc_int4_type_node);

View File

@ -553,6 +553,7 @@ gfc_conv_cst_int_power (gfc_se * se, tree lhs, tree rhs)
static void
gfc_conv_power_op (gfc_se * se, gfc_expr * expr)
{
tree gfc_int4_type_node;
int kind;
int ikind;
gfc_se lse;
@ -573,6 +574,8 @@ gfc_conv_power_op (gfc_se * se, gfc_expr * expr)
if (gfc_conv_cst_int_power (se, lse.expr, rse.expr))
return;
gfc_int4_type_node = gfc_get_int_type (4);
kind = expr->op1->ts.kind;
switch (expr->op2->ts.type)
{

View File

@ -1945,6 +1945,7 @@ gfc_conv_intrinsic_len_trim (gfc_se * se, gfc_expr * expr)
static void
gfc_conv_intrinsic_index (gfc_se * se, gfc_expr * expr)
{
tree gfc_logical4_type_node = gfc_get_logical_type (4);
tree args;
tree back;
tree type;
@ -2245,6 +2246,7 @@ gfc_conv_associated (gfc_se *se, gfc_expr *expr)
static void
gfc_conv_intrinsic_scan (gfc_se * se, gfc_expr * expr)
{
tree gfc_logical4_type_node = gfc_get_logical_type (4);
tree args;
tree back;
tree type;
@ -2277,6 +2279,7 @@ gfc_conv_intrinsic_scan (gfc_se * se, gfc_expr * expr)
static void
gfc_conv_intrinsic_verify (gfc_se * se, gfc_expr * expr)
{
tree gfc_logical4_type_node = gfc_get_logical_type (4);
tree args;
tree back;
tree type;
@ -2529,6 +2532,7 @@ gfc_conv_intrinsic_sr_kind (gfc_se * se, gfc_expr * expr)
static void
gfc_conv_intrinsic_trim (gfc_se * se, gfc_expr * expr)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
tree var;
tree len;
tree addr;
@ -2570,6 +2574,7 @@ gfc_conv_intrinsic_trim (gfc_se * se, gfc_expr * expr)
static void
gfc_conv_intrinsic_repeat (gfc_se * se, gfc_expr * expr)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
tree tmp;
tree len;
tree args;

View File

@ -39,8 +39,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#include "trans-const.h"
static GTY(()) tree gfc_pint4_type_node;
/* Members of the ioparm structure. */
static GTY(()) tree ioparm_unit;
@ -160,13 +158,16 @@ static enum { READ, WRITE, IOLENGTH } last_dt;
void
gfc_build_io_library_fndecls (void)
{
tree gfc_int4_type_node;
tree gfc_pint4_type_node;
tree ioparm_type;
gfc_int4_type_node = gfc_get_int_type (4);
gfc_pint4_type_node = build_pointer_type (gfc_int4_type_node);
/* Build the st_parameter structure. Information associated with I/O
calls are transferred here. This must match the one defined in the
library exactly. */
/* Build the st_parameter structure. Information associated with I/O
calls are transferred here. This must match the one defined in the
library exactly. */
ioparm_type = make_node (RECORD_TYPE);
TYPE_NAME (ioparm_type) = get_identifier ("_gfc_ioparm");

View File

@ -275,6 +275,7 @@ gfc_trans_return (gfc_code * code ATTRIBUTE_UNUSED)
tree
gfc_trans_pause (gfc_code * code)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
gfc_se se;
tree args;
tree tmp;
@ -314,6 +315,7 @@ gfc_trans_pause (gfc_code * code)
tree
gfc_trans_stop (gfc_code * code)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
gfc_se se;
tree args;
tree tmp;
@ -991,6 +993,8 @@ gfc_trans_character_select (gfc_code *code)
if (select_struct == NULL)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
select_struct = make_node (RECORD_TYPE);
TYPE_NAME (select_struct) = get_identifier ("_jump_struct");
@ -3016,6 +3020,8 @@ gfc_trans_allocate (gfc_code * code)
if (code->expr)
{
tree gfc_int4_type_node = gfc_get_int_type (4);
stat = gfc_create_var (gfc_int4_type_node, "stat");
pstat = gfc_build_addr_expr (NULL, stat);

View File

@ -50,15 +50,14 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
static tree gfc_get_derived_type (gfc_symbol * derived);
tree gfc_type_nodes[NUM_F95_TYPES];
tree gfc_array_index_type;
tree pvoid_type_node;
tree ppvoid_type_node;
tree pchar_type_node;
tree gfc_character1_type_node;
tree gfc_strlen_type_node;
static GTY(()) tree gfc_desc_dim_type = NULL;
static GTY(()) tree gfc_desc_dim_type;
static GTY(()) tree gfc_max_array_element_size;
/* Arrays for all integral and real kinds. We'll fill this in at runtime
@ -67,9 +66,13 @@ static GTY(()) tree gfc_max_array_element_size;
#define MAX_INT_KINDS 5
gfc_integer_info gfc_integer_kinds[MAX_INT_KINDS + 1];
gfc_logical_info gfc_logical_kinds[MAX_INT_KINDS + 1];
static GTY(()) tree gfc_integer_types[MAX_INT_KINDS + 1];
static GTY(()) tree gfc_logical_types[MAX_INT_KINDS + 1];
#define MAX_REAL_KINDS 4
gfc_real_info gfc_real_kinds[MAX_REAL_KINDS + 1];
static GTY(()) tree gfc_real_types[MAX_REAL_KINDS + 1];
static GTY(()) tree gfc_complex_types[MAX_REAL_KINDS + 1];
/* The integer kind to use for array indices. This will be set to the
proper value based on target information from the backend. */
@ -178,6 +181,7 @@ gfc_init_kinds (void)
gfc_real_kinds[r_index].digits = fmt->p;
gfc_real_kinds[r_index].min_exponent = fmt->emin;
gfc_real_kinds[r_index].max_exponent = fmt->emax;
gfc_real_kinds[r_index].mode_precision = GET_MODE_PRECISION (mode);
r_index += 1;
}
@ -324,6 +328,127 @@ gfc_validate_kind (bt type, int kind, bool may_fail)
}
/* Four subroutines of gfc_init_types. Create type nodes for the given kind.
Reuse common type nodes where possible. Recognize if the kind matches up
with a C type. This will be used later in determining which routines may
be scarfed from libm. */
static tree
gfc_build_int_type (gfc_integer_info *info)
{
int mode_precision = info->bit_size;
if (mode_precision == CHAR_TYPE_SIZE)
info->c_char = 1;
if (mode_precision == SHORT_TYPE_SIZE)
info->c_short = 1;
if (mode_precision == INT_TYPE_SIZE)
info->c_int = 1;
if (mode_precision == LONG_TYPE_SIZE)
info->c_long = 1;
if (mode_precision == LONG_LONG_TYPE_SIZE)
info->c_long_long = 1;
if (TYPE_PRECISION (intQI_type_node) == mode_precision)
return intQI_type_node;
if (TYPE_PRECISION (intHI_type_node) == mode_precision)
return intHI_type_node;
if (TYPE_PRECISION (intSI_type_node) == mode_precision)
return intSI_type_node;
if (TYPE_PRECISION (intDI_type_node) == mode_precision)
return intDI_type_node;
if (TYPE_PRECISION (intTI_type_node) == mode_precision)
return intTI_type_node;
return make_signed_type (mode_precision);
}
static tree
gfc_build_real_type (gfc_real_info *info)
{
int mode_precision = info->mode_precision;
tree new_type;
if (mode_precision == FLOAT_TYPE_SIZE)
info->c_float = 1;
if (mode_precision == DOUBLE_TYPE_SIZE)
info->c_double = 1;
if (mode_precision == LONG_DOUBLE_TYPE_SIZE)
info->c_long_double = 1;
if (TYPE_PRECISION (float_type_node) == mode_precision)
return float_type_node;
if (TYPE_PRECISION (double_type_node) == mode_precision)
return double_type_node;
if (TYPE_PRECISION (long_double_type_node) == mode_precision)
return long_double_type_node;
new_type = make_node (REAL_TYPE);
TYPE_PRECISION (new_type) = mode_precision;
layout_type (new_type);
return new_type;
}
static tree
gfc_build_complex_type (tree scalar_type)
{
tree new_type;
if (scalar_type == NULL)
return NULL;
if (scalar_type == float_type_node)
return complex_float_type_node;
if (scalar_type == double_type_node)
return complex_double_type_node;
if (scalar_type == long_double_type_node)
return complex_long_double_type_node;
new_type = make_node (COMPLEX_TYPE);
TREE_TYPE (new_type) = scalar_type;
layout_type (new_type);
return new_type;
}
static tree
gfc_build_logical_type (gfc_logical_info *info)
{
int bit_size = info->bit_size;
tree new_type;
if (bit_size == BOOL_TYPE_SIZE)
{
info->c_bool = 1;
return boolean_type_node;
}
new_type = make_unsigned_type (bit_size);
TREE_SET_CODE (new_type, BOOLEAN_TYPE);
TYPE_MAX_VALUE (new_type) = build_int_cst (new_type, 1);
TYPE_PRECISION (new_type) = 1;
return new_type;
}
#if 0
/* Return the bit size of the C "size_t". */
static unsigned int
c_size_t_size (void)
{
#ifdef SIZE_TYPE
if (strcmp (SIZE_TYPE, "unsigned int") == 0)
return INT_TYPE_SIZE;
if (strcmp (SIZE_TYPE, "long unsigned int") == 0)
return LONG_TYPE_SIZE;
if (strcmp (SIZE_TYPE, "short unsigned int") == 0)
return SHORT_TYPE_SIZE;
abort ();
#else
return LONG_TYPE_SIZE;
#endif
}
#endif
/* Create the backend type nodes. We map them to their
equivalent C type, at least for now. We also give
names to the types here, and we push them in the
@ -332,69 +457,49 @@ gfc_validate_kind (bt type, int kind, bool may_fail)
void
gfc_init_types (void)
{
char name_buf[16];
int index;
tree type;
unsigned n;
unsigned HOST_WIDE_INT hi;
unsigned HOST_WIDE_INT lo;
/* Name the types. */
/* Create and name the types. */
#define PUSH_TYPE(name, node) \
pushdecl (build_decl (TYPE_DECL, get_identifier (name), node))
gfc_int1_type_node = signed_char_type_node;
PUSH_TYPE ("int1", gfc_int1_type_node);
gfc_int2_type_node = short_integer_type_node;
PUSH_TYPE ("int2", gfc_int2_type_node);
gfc_int4_type_node = gfc_type_for_size (32, 0 /*unsigned */ );
PUSH_TYPE ("int4", gfc_int4_type_node);
gfc_int8_type_node = gfc_type_for_size (64, 0 /*unsigned */ );
PUSH_TYPE ("int8", gfc_int8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
gfc_int16_type_node = gfc_type_for_size (128, 0 /*unsigned */ );
PUSH_TYPE ("int16", gfc_int16_type_node);
#endif
for (index = 0; gfc_integer_kinds[index].kind != 0; ++index)
{
type = gfc_build_int_type (&gfc_integer_kinds[index]);
gfc_integer_types[index] = type;
snprintf (name_buf, sizeof(name_buf), "int%d",
gfc_integer_kinds[index].kind);
PUSH_TYPE (name_buf, type);
}
gfc_real4_type_node = float_type_node;
PUSH_TYPE ("real4", gfc_real4_type_node);
gfc_real8_type_node = double_type_node;
PUSH_TYPE ("real8", gfc_real8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
/* Hmm, this will not work. Ref. g77 */
gfc_real16_type_node = long_double_type_node;
PUSH_TYPE ("real16", gfc_real16_type_node);
#endif
for (index = 0; gfc_logical_kinds[index].kind != 0; ++index)
{
type = gfc_build_logical_type (&gfc_logical_kinds[index]);
gfc_logical_types[index] = type;
snprintf (name_buf, sizeof(name_buf), "logical%d",
gfc_logical_kinds[index].kind);
PUSH_TYPE (name_buf, type);
}
gfc_complex4_type_node = complex_float_type_node;
PUSH_TYPE ("complex4", gfc_complex4_type_node);
gfc_complex8_type_node = complex_double_type_node;
PUSH_TYPE ("complex8", gfc_complex8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
/* Hmm, this will not work. Ref. g77 */
gfc_complex16_type_node = complex_long_double_type_node;
PUSH_TYPE ("complex16", gfc_complex16_type_node);
#endif
for (index = 0; gfc_real_kinds[index].kind != 0; index++)
{
type = gfc_build_real_type (&gfc_real_kinds[index]);
gfc_real_types[index] = type;
snprintf (name_buf, sizeof(name_buf), "real%d",
gfc_real_kinds[index].kind);
PUSH_TYPE (name_buf, type);
gfc_logical1_type_node = make_node (BOOLEAN_TYPE);
TYPE_PRECISION (gfc_logical1_type_node) = 8;
fixup_unsigned_type (gfc_logical1_type_node);
PUSH_TYPE ("logical1", gfc_logical1_type_node);
gfc_logical2_type_node = make_node (BOOLEAN_TYPE);
TYPE_PRECISION (gfc_logical2_type_node) = 16;
fixup_unsigned_type (gfc_logical2_type_node);
PUSH_TYPE ("logical2", gfc_logical2_type_node);
gfc_logical4_type_node = make_node (BOOLEAN_TYPE);
TYPE_PRECISION (gfc_logical4_type_node) = 32;
fixup_unsigned_type (gfc_logical4_type_node);
PUSH_TYPE ("logical4", gfc_logical4_type_node);
gfc_logical8_type_node = make_node (BOOLEAN_TYPE);
TYPE_PRECISION (gfc_logical8_type_node) = 64;
fixup_unsigned_type (gfc_logical8_type_node);
PUSH_TYPE ("logical8", gfc_logical8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
gfc_logical16_type_node = make_node (BOOLEAN_TYPE);
TYPE_PRECISION (gfc_logical16_type_node) = 128;
fixup_unsigned_type (gfc_logical16_type_node);
PUSH_TYPE ("logical16", gfc_logical16_type_node);
#endif
type = gfc_build_complex_type (type);
gfc_complex_types[index] = type;
snprintf (name_buf, sizeof(name_buf), "complex%d",
gfc_real_kinds[index].kind);
PUSH_TYPE (name_buf, type);
}
gfc_character1_type_node = build_type_variant (signed_char_type_node, 0, 0);
PUSH_TYPE ("char", gfc_character1_type_node);
@ -407,6 +512,7 @@ gfc_init_types (void)
PUSH_TYPE ("c_integer", integer_type_node);
if (!TYPE_NAME (char_type_node))
PUSH_TYPE ("c_char", char_type_node);
#undef PUSH_TYPE
pvoid_type_node = build_pointer_type (void_type_node);
@ -419,116 +525,53 @@ gfc_init_types (void)
by the number of bits available to store this field in the array
descriptor. */
n = TREE_INT_CST_LOW (TYPE_SIZE (gfc_array_index_type))
- GFC_DTYPE_SIZE_SHIFT;
if (n > sizeof (HOST_WIDE_INT) * 8)
{
lo = ~(unsigned HOST_WIDE_INT) 0;
hi = lo >> (sizeof (HOST_WIDE_INT) * 16 - n);
}
n = TYPE_PRECISION (gfc_array_index_type) - GFC_DTYPE_SIZE_SHIFT;
lo = ~ (unsigned HOST_WIDE_INT) 0;
if (n > HOST_BITS_PER_WIDE_INT)
hi = lo >> (2*HOST_BITS_PER_WIDE_INT - n);
else
{
hi = 0;
lo = (~(unsigned HOST_WIDE_INT) 0) >> (sizeof (HOST_WIDE_INT) * 8 - n);
}
hi = 0, lo >>= HOST_BITS_PER_WIDE_INT - n;
gfc_max_array_element_size
= build_int_cst_wide (long_unsigned_type_node, lo, hi);
size_type_node = gfc_array_index_type;
boolean_type_node = gfc_get_logical_type (gfc_default_logical_kind);
boolean_type_node = gfc_get_logical_type (gfc_default_logical_kind);
boolean_true_node = build_int_cst (boolean_type_node, 1);
boolean_false_node = build_int_cst (boolean_type_node, 0);
/* ??? Shouldn't this be based on gfc_index_integer_kind or so? */
gfc_strlen_type_node = gfc_get_int_type (4);
}
/* Get a type node for an integer kind. */
/* Get the type node for the given type and kind. */
tree
gfc_get_int_type (int kind)
{
switch (kind)
{
case 1:
return (gfc_int1_type_node);
case 2:
return (gfc_int2_type_node);
case 4:
return (gfc_int4_type_node);
case 8:
return (gfc_int8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
case 16:
return (95 _int16_type_node);
#endif
default:
fatal_error ("integer kind=%d not available", kind);
}
int index = gfc_validate_kind (BT_INTEGER, kind, false);
return gfc_integer_types[index];
}
/* Get a type node for a real kind. */
tree
gfc_get_real_type (int kind)
{
switch (kind)
{
case 4:
return (gfc_real4_type_node);
case 8:
return (gfc_real8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
case 16:
return (gfc_real16_type_node);
#endif
default:
fatal_error ("real kind=%d not available", kind);
}
int index = gfc_validate_kind (BT_REAL, kind, false);
return gfc_real_types[index];
}
/* Get a type node for a complex kind. */
tree
gfc_get_complex_type (int kind)
{
switch (kind)
{
case 4:
return (gfc_complex4_type_node);
case 8:
return (gfc_complex8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
case 16:
return (gfc_complex16_type_node);
#endif
default:
fatal_error ("complex kind=%d not available", kind);
}
int index = gfc_validate_kind (BT_COMPLEX, kind, false);
return gfc_complex_types[index];
}
/* Get a type node for a logical kind. */
tree
gfc_get_logical_type (int kind)
{
switch (kind)
{
case 1:
return (gfc_logical1_type_node);
case 2:
return (gfc_logical2_type_node);
case 4:
return (gfc_logical4_type_node);
case 8:
return (gfc_logical8_type_node);
#if (GFC_USE_TYPES16 && (HOST_BITS_PER_WIDE_INT >= 64))
case 16:
return (gfc_logical16_type_node);
#endif
default:
fatal_error ("logical kind=%d not available", kind);
}
int index = gfc_validate_kind (BT_LOGICAL, kind, false);
return gfc_logical_types[index];
}
/* Create a character type with the given kind and length. */
@ -536,22 +579,12 @@ gfc_get_logical_type (int kind)
tree
gfc_get_character_type_len (int kind, tree len)
{
tree base;
tree bounds;
tree type;
tree bounds, type;
switch (kind)
{
case 1:
base = gfc_character1_type_node;
break;
default:
fatal_error ("character kind=%d not available", kind);
}
gfc_validate_kind (BT_CHARACTER, kind, false);
bounds = build_range_type (gfc_array_index_type, gfc_index_one_node, len);
type = build_array_type (base, bounds);
type = build_array_type (gfc_character1_type_node, bounds);
TYPE_STRING_FLAG (type) = 1;
return type;
@ -1534,8 +1567,7 @@ gfc_get_function_type (gfc_symbol * sym)
return type;
}
/* Routines for getting integer type nodes. */
/* Language hooks for middle-end access to type nodes. */
/* Return an integer type with BITS bits of precision,
that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
@ -1543,185 +1575,67 @@ gfc_get_function_type (gfc_symbol * sym)
tree
gfc_type_for_size (unsigned bits, int unsignedp)
{
if (bits == TYPE_PRECISION (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
if (!unsignedp)
{
int i;
for (i = 0; i <= MAX_INT_KINDS; ++i)
{
tree type = gfc_integer_types[i];
if (type && bits == TYPE_PRECISION (type))
return type;
}
}
else
{
if (bits == TYPE_PRECISION (unsigned_intQI_type_node))
return unsigned_intQI_type_node;
if (bits == TYPE_PRECISION (unsigned_intHI_type_node))
return unsigned_intHI_type_node;
if (bits == TYPE_PRECISION (unsigned_intSI_type_node))
return unsigned_intSI_type_node;
if (bits == TYPE_PRECISION (unsigned_intDI_type_node))
return unsigned_intDI_type_node;
if (bits == TYPE_PRECISION (unsigned_intTI_type_node))
return unsigned_intTI_type_node;
}
if (bits == TYPE_PRECISION (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
if (bits == TYPE_PRECISION (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
if (bits == TYPE_PRECISION (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
if (bits == TYPE_PRECISION (long_long_integer_type_node))
return (unsignedp ? long_long_unsigned_type_node
: long_long_integer_type_node);
/*TODO: We currently don't initialise this...
if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
return (unsignedp ? widest_unsigned_literal_type_node
: widest_integer_literal_type_node);*/
if (bits <= TYPE_PRECISION (intQI_type_node))
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
if (bits <= TYPE_PRECISION (intHI_type_node))
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
if (bits <= TYPE_PRECISION (intSI_type_node))
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
if (bits <= TYPE_PRECISION (intDI_type_node))
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
return 0;
return NULL_TREE;
}
/* Return a data type that has machine mode MODE.
If the mode is an integer,
then UNSIGNEDP selects between signed and unsigned types. */
/* Return a data type that has machine mode MODE. If the mode is an
integer, then UNSIGNEDP selects between signed and unsigned types. */
tree
gfc_type_for_mode (enum machine_mode mode, int unsignedp)
{
if (mode == TYPE_MODE (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
int i;
tree *base;
if (mode == TYPE_MODE (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
if (mode == TYPE_MODE (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
if (mode == TYPE_MODE (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
if (mode == TYPE_MODE (long_long_integer_type_node))
return unsignedp ? long_long_unsigned_type_node :
long_long_integer_type_node;
/*TODO: see above
if (mode == TYPE_MODE (widest_integer_literal_type_node))
return unsignedp ? widest_unsigned_literal_type_node
: widest_integer_literal_type_node;
*/
if (mode == QImode)
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
if (mode == HImode)
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
if (mode == SImode)
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
if (mode == DImode)
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
#if HOST_BITS_PER_WIDE_INT >= 64
if (mode == TYPE_MODE (intTI_type_node))
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
#endif
if (mode == TYPE_MODE (float_type_node))
return float_type_node;
if (mode == TYPE_MODE (double_type_node))
return double_type_node;
if (mode == TYPE_MODE (long_double_type_node))
return long_double_type_node;
if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
return build_pointer_type (char_type_node);
if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
return build_pointer_type (integer_type_node);
if (VECTOR_MODE_P (mode))
if (GET_MODE_CLASS (mode) == MODE_FLOAT)
base = gfc_real_types;
else if (GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
base = gfc_complex_types;
else if (SCALAR_INT_MODE_P (mode))
return gfc_type_for_size (GET_MODE_PRECISION (mode), unsignedp);
else if (VECTOR_MODE_P (mode))
{
enum machine_mode inner_mode = GET_MODE_INNER (mode);
tree inner_type = gfc_type_for_mode (inner_mode, unsignedp);
if (inner_type != NULL_TREE)
return build_vector_type_for_mode (inner_type, mode);
return NULL_TREE;
}
else
abort ();
for (i = 0; i <= MAX_REAL_KINDS; ++i)
{
tree type = base[i];
if (type && mode == TYPE_MODE (type))
return type;
}
return 0;
}
/* Return an unsigned type the same as TYPE in other respects. */
tree
gfc_unsigned_type (tree type)
{
tree type1 = TYPE_MAIN_VARIANT (type);
if (type1 == signed_char_type_node || type1 == char_type_node)
return unsigned_char_type_node;
if (type1 == integer_type_node)
return unsigned_type_node;
if (type1 == short_integer_type_node)
return short_unsigned_type_node;
if (type1 == long_integer_type_node)
return long_unsigned_type_node;
if (type1 == long_long_integer_type_node)
return long_long_unsigned_type_node;
/*TODO :see others
if (type1 == widest_integer_literal_type_node)
return widest_unsigned_literal_type_node;
*/
#if HOST_BITS_PER_WIDE_INT >= 64
if (type1 == intTI_type_node)
return unsigned_intTI_type_node;
#endif
if (type1 == intDI_type_node)
return unsigned_intDI_type_node;
if (type1 == intSI_type_node)
return unsigned_intSI_type_node;
if (type1 == intHI_type_node)
return unsigned_intHI_type_node;
if (type1 == intQI_type_node)
return unsigned_intQI_type_node;
return gfc_signed_or_unsigned_type (1, type);
}
/* Return a signed type the same as TYPE in other respects. */
tree
gfc_signed_type (tree type)
{
tree type1 = TYPE_MAIN_VARIANT (type);
if (type1 == unsigned_char_type_node || type1 == char_type_node)
return signed_char_type_node;
if (type1 == unsigned_type_node)
return integer_type_node;
if (type1 == short_unsigned_type_node)
return short_integer_type_node;
if (type1 == long_unsigned_type_node)
return long_integer_type_node;
if (type1 == long_long_unsigned_type_node)
return long_long_integer_type_node;
/*TODO: see others
if (type1 == widest_unsigned_literal_type_node)
return widest_integer_literal_type_node;
*/
#if HOST_BITS_PER_WIDE_INT >= 64
if (type1 == unsigned_intTI_type_node)
return intTI_type_node;
#endif
if (type1 == unsigned_intDI_type_node)
return intDI_type_node;
if (type1 == unsigned_intSI_type_node)
return intSI_type_node;
if (type1 == unsigned_intHI_type_node)
return intHI_type_node;
if (type1 == unsigned_intQI_type_node)
return intQI_type_node;
return gfc_signed_or_unsigned_type (0, type);
return NULL_TREE;
}
/* Return a type the same as TYPE except unsigned or
@ -1730,39 +1644,26 @@ gfc_signed_type (tree type)
tree
gfc_signed_or_unsigned_type (int unsignedp, tree type)
{
if (!INTEGRAL_TYPE_P (type) || TYPE_UNSIGNED (type) == unsignedp)
if (TREE_CODE (type) != INTEGER_TYPE || TYPE_UNSIGNED (type) == unsignedp)
return type;
else
return gfc_type_for_size (TYPE_PRECISION (type), unsignedp);
}
if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
return unsignedp ? unsigned_char_type_node : signed_char_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
return unsignedp ? unsigned_type_node : integer_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
return unsignedp ? short_unsigned_type_node : short_integer_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
return unsignedp ? long_unsigned_type_node : long_integer_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
return (unsignedp ? long_long_unsigned_type_node
: long_long_integer_type_node);
/*TODO: see others
if (TYPE_PRECISION (type) == TYPE_PRECISION (widest_integer_literal_type_node))
return (unsignedp ? widest_unsigned_literal_type_node
: widest_integer_literal_type_node);
*/
#if HOST_BITS_PER_WIDE_INT >= 64
if (TYPE_PRECISION (type) == TYPE_PRECISION (intTI_type_node))
return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
#endif
if (TYPE_PRECISION (type) == TYPE_PRECISION (intDI_type_node))
return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (intSI_type_node))
return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (intHI_type_node))
return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
if (TYPE_PRECISION (type) == TYPE_PRECISION (intQI_type_node))
return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
/* Return an unsigned type the same as TYPE in other respects. */
return type;
tree
gfc_unsigned_type (tree type)
{
return gfc_signed_or_unsigned_type (1, type);
}
/* Return a signed type the same as TYPE in other respects. */
tree
gfc_signed_type (tree type)
{
return gfc_signed_or_unsigned_type (0, type);
}
#include "gt-fortran-trans-types.h"

View File

@ -24,28 +24,6 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#ifndef GFC_BACKEND_H
#define GFC_BACKEND_H
enum
{
F95_INT1_TYPE,
F95_INT2_TYPE,
F95_INT4_TYPE,
F95_INT8_TYPE,
F95_INT16_TYPE,
F95_REAL4_TYPE,
F95_REAL8_TYPE,
F95_REAl16_TYPE,
F95_COMPLEX4_TYPE,
F95_COMPLEX8_TYPE,
F95_COMPLEX16_TYPE,
F95_LOGICAL1_TYPE,
F95_LOGICAL2_TYPE,
F95_LOGICAL4_TYPE,
F95_LOGICAL8_TYPE,
F95_LOGICAL16_TYPE,
F95_CHARACTER1_TYPE,
NUM_F95_TYPES
};
#define GFC_DTYPE_RANK_MASK 0x07
#define GFC_DTYPE_TYPE_SHIFT 3
#define GFC_DTYPE_TYPE_MASK 0x38
@ -62,37 +40,12 @@ enum
GFC_DTYPE_CHARACTER
};
extern GTY(()) tree gfc_type_nodes[NUM_F95_TYPES];
extern GTY(()) tree gfc_array_index_type;
extern GTY(()) tree gfc_character1_type_node;
extern GTY(()) tree ppvoid_type_node;
extern GTY(()) tree pvoid_type_node;
extern GTY(()) tree pchar_type_node;
#define gfc_int1_type_node gfc_type_nodes[F95_INT1_TYPE]
#define gfc_int2_type_node gfc_type_nodes[F95_INT2_TYPE]
#define gfc_int4_type_node gfc_type_nodes[F95_INT4_TYPE]
#define gfc_int8_type_node gfc_type_nodes[F95_INT8_TYPE]
#define gfc_int16_type_node gfc_type_nodes[F95_INT16_TYPE]
#define gfc_real4_type_node gfc_type_nodes[F95_REAL4_TYPE]
#define gfc_real8_type_node gfc_type_nodes[F95_REAL8_TYPE]
#define gfc_real16_type_node gfc_type_nodes[F95_REAL16_TYPE]
#define gfc_complex4_type_node gfc_type_nodes[F95_COMPLEX4_TYPE]
#define gfc_complex8_type_node gfc_type_nodes[F95_COMPLEX8_TYPE]
#define gfc_complex16_type_node gfc_type_nodes[F95_COMPLEX16_TYPE]
#define gfc_logical1_type_node gfc_type_nodes[F95_LOGICAL1_TYPE]
#define gfc_logical2_type_node gfc_type_nodes[F95_LOGICAL2_TYPE]
#define gfc_logical4_type_node gfc_type_nodes[F95_LOGICAL4_TYPE]
#define gfc_logical8_type_node gfc_type_nodes[F95_LOGICAL8_TYPE]
#define gfc_logical16_type_node gfc_type_nodes[F95_LOGICAL16_TYPE]
#define gfc_character1_type_node gfc_type_nodes[F95_CHARACTER1_TYPE]
#define gfc_strlen_kind 4
#define gfc_strlen_type_node gfc_int4_type_node
extern GTY(()) tree gfc_strlen_type_node;
/* These C-specific types are used while building builtin function decls.
For now it doesn't really matter what these are defined to as we don't