X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;ds=sidebyside;f=gdb%2Ff-lang.c;h=5dcbd33de633725f58d8bff1f452580d6af35fc8;hb=8fbde58b702f0e1273c8292d1359e474fd96126b;hp=53dce631981d5b2b494c563b3415a1de98798b27;hpb=392a587b0562bfd8561bc15ad2625a4f49f461f0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 53dce63198..5dcbd33de6 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -1,23 +1,25 @@ /* Fortran language support routines for GDB, the GNU debugger. - Copyright 1993, 1994, 1996 Free Software Foundation, Inc. + + Copyright (C) 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003, + 2004, 2005, 2007, 2008 Free Software Foundation, Inc. + Contributed by Motorola. Adapted from the C parser by Farooq Butt (fmbutt@engage.sps.mot.com). -This file is part of GDB. + This file is part of GDB. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ #include "defs.h" #include "gdb_string.h" @@ -27,65 +29,49 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "parser-defs.h" #include "language.h" #include "f-lang.h" +#include "valprint.h" +#include "value.h" -/* The built-in types of F77. FIXME: integer*4 is missing, plain - logical is missing (builtin_type_logical is logical*4). */ - -struct type *builtin_type_f_character; -struct type *builtin_type_f_logical; -struct type *builtin_type_f_logical_s1; -struct type *builtin_type_f_logical_s2; -struct type *builtin_type_f_integer; -struct type *builtin_type_f_integer_s2; -struct type *builtin_type_f_real; -struct type *builtin_type_f_real_s8; -struct type *builtin_type_f_real_s16; -struct type *builtin_type_f_complex_s8; -struct type *builtin_type_f_complex_s16; -struct type *builtin_type_f_complex_s32; -struct type *builtin_type_f_void; /* Following is dubious stuff that had been in the xcoff reader. */ struct saved_fcn -{ - long line_offset; /* Line offset for function */ - struct saved_fcn *next; -}; + { + long line_offset; /* Line offset for function */ + struct saved_fcn *next; + }; -struct saved_bf_symnum -{ - long symnum_fcn; /* Symnum of function (i.e. .function directive) */ - long symnum_bf; /* Symnum of .bf for this function */ - struct saved_bf_symnum *next; -}; +struct saved_bf_symnum + { + long symnum_fcn; /* Symnum of function (i.e. .function directive) */ + long symnum_bf; /* Symnum of .bf for this function */ + struct saved_bf_symnum *next; + }; -typedef struct saved_fcn SAVED_FUNCTION, *SAVED_FUNCTION_PTR; -typedef struct saved_bf_symnum SAVED_BF, *SAVED_BF_PTR; +typedef struct saved_fcn SAVED_FUNCTION, *SAVED_FUNCTION_PTR; +typedef struct saved_bf_symnum SAVED_BF, *SAVED_BF_PTR; /* Local functions */ -extern void _initialize_f_language PARAMS ((void)); +extern void _initialize_f_language (void); #if 0 -static void clear_function_list PARAMS ((void)); -static long get_bf_for_fcn PARAMS ((long)); -static void clear_bf_list PARAMS ((void)); -static void patch_all_commons_by_name PARAMS ((char *, CORE_ADDR, int)); -static SAVED_F77_COMMON_PTR find_first_common_named PARAMS ((char *)); -static void add_common_entry PARAMS ((struct symbol *)); -static void add_common_block PARAMS ((char *, CORE_ADDR, int, char *)); -static SAVED_FUNCTION *allocate_saved_function_node PARAMS ((void)); -static SAVED_BF_PTR allocate_saved_bf_node PARAMS ((void)); -static COMMON_ENTRY_PTR allocate_common_entry_node PARAMS ((void)); -static SAVED_F77_COMMON_PTR allocate_saved_f77_common_node PARAMS ((void)); -static void patch_common_entries PARAMS ((SAVED_F77_COMMON_PTR, CORE_ADDR, int)); +static void clear_function_list (void); +static long get_bf_for_fcn (long); +static void clear_bf_list (void); +static void patch_all_commons_by_name (char *, CORE_ADDR, int); +static SAVED_F77_COMMON_PTR find_first_common_named (char *); +static void add_common_entry (struct symbol *); +static void add_common_block (char *, CORE_ADDR, int, char *); +static SAVED_FUNCTION *allocate_saved_function_node (void); +static SAVED_BF_PTR allocate_saved_bf_node (void); +static COMMON_ENTRY_PTR allocate_common_entry_node (void); +static SAVED_F77_COMMON_PTR allocate_saved_f77_common_node (void); +static void patch_common_entries (SAVED_F77_COMMON_PTR, CORE_ADDR, int); #endif -static struct type *f_create_fundamental_type PARAMS ((struct objfile *, int)); -static void f_printstr PARAMS ((GDB_FILE *stream, char *string, unsigned int length, int width, int force_ellipses)); -static void f_printchar PARAMS ((int c, GDB_FILE *stream)); -static void f_emit_char PARAMS ((int c, GDB_FILE *stream, int quoter)); +static void f_printchar (int c, struct ui_file * stream); +static void f_emit_char (int c, struct ui_file * stream, int quoter); /* Print the character C on STREAM as part of the contents of a literal string whose delimiter is QUOTER. Note that that format for printing @@ -94,13 +80,10 @@ static void f_emit_char PARAMS ((int c, GDB_FILE *stream, int quoter)); be replaced with a true F77 version. */ static void -f_emit_char (c, stream, quoter) - register int c; - GDB_FILE *stream; - int quoter; +f_emit_char (int c, struct ui_file *stream, int quoter) { c &= 0xFF; /* Avoid sign bit follies */ - + if (PRINT_LITERAL_FORM (c)) { if (c == '\\' || c == quoter) @@ -143,9 +126,7 @@ f_emit_char (c, stream, quoter) be replaced with a true F77version. */ static void -f_printchar (c, stream) - int c; - GDB_FILE *stream; +f_printchar (int c, struct ui_file *stream) { fputs_filtered ("'", stream); LA_EMIT_CHAR (c, stream, '\''); @@ -160,43 +141,36 @@ f_printchar (c, stream) be replaced with a true F77 version. */ static void -f_printstr (stream, string, length, width, force_ellipses) - GDB_FILE *stream; - char *string; - unsigned int length; - int width; - int force_ellipses; +f_printstr (struct ui_file *stream, const gdb_byte *string, + unsigned int length, int width, int force_ellipses) { - register unsigned int i; + unsigned int i; unsigned int things_printed = 0; int in_quotes = 0; int need_comma = 0; - extern int inspect_it; - extern int repeat_count_threshold; - extern int print_max; - + if (length == 0) { fputs_filtered ("''", gdb_stdout); return; } - + for (i = 0; i < length && things_printed < print_max; ++i) { /* Position of the character we are examining - to see whether it is repeated. */ + to see whether it is repeated. */ unsigned int rep1; /* Number of repetitions we have detected so far. */ unsigned int reps; - + QUIT; - + if (need_comma) { fputs_filtered (", ", stream); need_comma = 0; } - + rep1 = i + 1; reps = 1; while (rep1 < length && string[rep1] == string[i]) @@ -204,7 +178,7 @@ f_printstr (stream, string, length, width, force_ellipses) ++rep1; ++reps; } - + if (reps > repeat_count_threshold) { if (in_quotes) @@ -235,7 +209,7 @@ f_printstr (stream, string, length, width, force_ellipses) ++things_printed; } } - + /* Terminate the quotes if necessary. */ if (in_quotes) { @@ -244,536 +218,433 @@ f_printstr (stream, string, length, width, force_ellipses) else fputs_filtered ("'", stream); } - + if (force_ellipses || i < length) fputs_filtered ("...", stream); } - -/* FIXME: This is a copy of c_create_fundamental_type(), before - all the non-C types were stripped from it. Needs to be fixed - by an experienced F77 programmer. */ - -static struct type * -f_create_fundamental_type (objfile, typeid) - struct objfile *objfile; - int typeid; -{ - register struct type *type = NULL; - - switch (typeid) - { - case FT_VOID: - type = init_type (TYPE_CODE_VOID, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "VOID", objfile); - break; - case FT_BOOLEAN: - type = init_type (TYPE_CODE_BOOL, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "boolean", objfile); - break; - case FT_STRING: - type = init_type (TYPE_CODE_STRING, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "string", objfile); - break; - case FT_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "character", objfile); - break; - case FT_SIGNED_CHAR: - type = init_type (TYPE_CODE_INT, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, "integer*1", objfile); - break; - case FT_UNSIGNED_CHAR: - type = init_type (TYPE_CODE_BOOL, - TARGET_CHAR_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "logical*1", objfile); - break; - case FT_SHORT: - type = init_type (TYPE_CODE_INT, - TARGET_SHORT_BIT / TARGET_CHAR_BIT, - 0, "integer*2", objfile); - break; - case FT_SIGNED_SHORT: - type = init_type (TYPE_CODE_INT, - TARGET_SHORT_BIT / TARGET_CHAR_BIT, - 0, "short", objfile); /* FIXME-fnf */ - break; - case FT_UNSIGNED_SHORT: - type = init_type (TYPE_CODE_BOOL, - TARGET_SHORT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "logical*2", objfile); - break; - case FT_INTEGER: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, "integer*4", objfile); - break; - case FT_SIGNED_INTEGER: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, "integer", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_INTEGER: - type = init_type (TYPE_CODE_BOOL, - TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "logical*4", objfile); - break; - case FT_FIXED_DECIMAL: - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, "fixed decimal", objfile); - break; - case FT_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_BIT / TARGET_CHAR_BIT, - 0, "long", objfile); - break; - case FT_SIGNED_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_BIT / TARGET_CHAR_BIT, - 0, "long", objfile); /* FIXME -fnf */ - break; - case FT_UNSIGNED_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long", objfile); - break; - case FT_LONG_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - 0, "long long", objfile); - break; - case FT_SIGNED_LONG_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - 0, "signed long long", objfile); - break; - case FT_UNSIGNED_LONG_LONG: - type = init_type (TYPE_CODE_INT, - TARGET_LONG_LONG_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, "unsigned long long", objfile); - break; - case FT_FLOAT: - type = init_type (TYPE_CODE_FLT, - TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - 0, "real", objfile); - break; - case FT_DBL_PREC_FLOAT: - type = init_type (TYPE_CODE_FLT, - TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, "real*8", objfile); - break; - case FT_FLOAT_DECIMAL: - type = init_type (TYPE_CODE_FLT, - TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, "floating decimal", objfile); - break; - case FT_EXT_PREC_FLOAT: - type = init_type (TYPE_CODE_FLT, - TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, "real*16", objfile); - break; - case FT_COMPLEX: - type = init_type (TYPE_CODE_COMPLEX, - 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT, - 0, "complex*8", objfile); - TYPE_TARGET_TYPE (type) = builtin_type_f_real; - break; - case FT_DBL_PREC_COMPLEX: - type = init_type (TYPE_CODE_COMPLEX, - 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, "complex*16", objfile); - TYPE_TARGET_TYPE (type) = builtin_type_f_real_s8; - break; - case FT_EXT_PREC_COMPLEX: - type = init_type (TYPE_CODE_COMPLEX, - 2 * TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, - 0, "complex*32", objfile); - TYPE_TARGET_TYPE (type) = builtin_type_f_real_s16; - break; - default: - /* FIXME: For now, if we are asked to produce a type not in this - language, create the equivalent of a C integer type with the - name "". When all the dust settles from the type - reconstruction work, this should probably become an error. */ - type = init_type (TYPE_CODE_INT, - TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, "", objfile); - warning ("internal error: no F77 fundamental type %d", typeid); - break; - } - return (type); -} - + /* Table of operators and their precedences for printing expressions. */ -static const struct op_print f_op_print_tab[] = { - { "+", BINOP_ADD, PREC_ADD, 0 }, - { "+", UNOP_PLUS, PREC_PREFIX, 0 }, - { "-", BINOP_SUB, PREC_ADD, 0 }, - { "-", UNOP_NEG, PREC_PREFIX, 0 }, - { "*", BINOP_MUL, PREC_MUL, 0 }, - { "/", BINOP_DIV, PREC_MUL, 0 }, - { "DIV", BINOP_INTDIV, PREC_MUL, 0 }, - { "MOD", BINOP_REM, PREC_MUL, 0 }, - { "=", BINOP_ASSIGN, PREC_ASSIGN, 1 }, - { ".OR.", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0 }, - { ".AND.", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0 }, - { ".NOT.", UNOP_LOGICAL_NOT, PREC_PREFIX, 0 }, - { ".EQ.", BINOP_EQUAL, PREC_EQUAL, 0 }, - { ".NE.", BINOP_NOTEQUAL, PREC_EQUAL, 0 }, - { ".LE.", BINOP_LEQ, PREC_ORDER, 0 }, - { ".GE.", BINOP_GEQ, PREC_ORDER, 0 }, - { ".GT.", BINOP_GTR, PREC_ORDER, 0 }, - { ".LT.", BINOP_LESS, PREC_ORDER, 0 }, - { "**", UNOP_IND, PREC_PREFIX, 0 }, - { "@", BINOP_REPEAT, PREC_REPEAT, 0 }, - { NULL, 0, 0, 0 } +static const struct op_print f_op_print_tab[] = +{ + {"+", BINOP_ADD, PREC_ADD, 0}, + {"+", UNOP_PLUS, PREC_PREFIX, 0}, + {"-", BINOP_SUB, PREC_ADD, 0}, + {"-", UNOP_NEG, PREC_PREFIX, 0}, + {"*", BINOP_MUL, PREC_MUL, 0}, + {"/", BINOP_DIV, PREC_MUL, 0}, + {"DIV", BINOP_INTDIV, PREC_MUL, 0}, + {"MOD", BINOP_REM, PREC_MUL, 0}, + {"=", BINOP_ASSIGN, PREC_ASSIGN, 1}, + {".OR.", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0}, + {".AND.", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0}, + {".NOT.", UNOP_LOGICAL_NOT, PREC_PREFIX, 0}, + {".EQ.", BINOP_EQUAL, PREC_EQUAL, 0}, + {".NE.", BINOP_NOTEQUAL, PREC_EQUAL, 0}, + {".LE.", BINOP_LEQ, PREC_ORDER, 0}, + {".GE.", BINOP_GEQ, PREC_ORDER, 0}, + {".GT.", BINOP_GTR, PREC_ORDER, 0}, + {".LT.", BINOP_LESS, PREC_ORDER, 0}, + {"**", UNOP_IND, PREC_PREFIX, 0}, + {"@", BINOP_REPEAT, PREC_REPEAT, 0}, + {NULL, 0, 0, 0} }; -struct type ** CONST_PTR (f_builtin_types[]) = -{ - &builtin_type_f_character, - &builtin_type_f_logical, - &builtin_type_f_logical_s1, - &builtin_type_f_logical_s2, - &builtin_type_f_integer, - &builtin_type_f_integer_s2, - &builtin_type_f_real, - &builtin_type_f_real_s8, - &builtin_type_f_real_s16, - &builtin_type_f_complex_s8, - &builtin_type_f_complex_s16, -#if 0 - &builtin_type_f_complex_s32, -#endif - &builtin_type_f_void, - 0 +enum f_primitive_types { + f_primitive_type_character, + f_primitive_type_logical, + f_primitive_type_logical_s1, + f_primitive_type_logical_s2, + f_primitive_type_integer, + f_primitive_type_integer_s2, + f_primitive_type_real, + f_primitive_type_real_s8, + f_primitive_type_real_s16, + f_primitive_type_complex_s8, + f_primitive_type_complex_s16, + f_primitive_type_void, + nr_f_primitive_types }; +static void +f_language_arch_info (struct gdbarch *gdbarch, + struct language_arch_info *lai) +{ + const struct builtin_f_type *builtin = builtin_f_type (gdbarch); + + lai->string_char_type = builtin->builtin_character; + lai->primitive_type_vector + = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_f_primitive_types + 1, + struct type *); + + lai->primitive_type_vector [f_primitive_type_character] + = builtin->builtin_character; + lai->primitive_type_vector [f_primitive_type_logical] + = builtin->builtin_logical; + lai->primitive_type_vector [f_primitive_type_logical_s1] + = builtin->builtin_logical_s1; + lai->primitive_type_vector [f_primitive_type_logical_s2] + = builtin->builtin_logical_s2; + lai->primitive_type_vector [f_primitive_type_real] + = builtin->builtin_real; + lai->primitive_type_vector [f_primitive_type_real_s8] + = builtin->builtin_real_s8; + lai->primitive_type_vector [f_primitive_type_real_s16] + = builtin->builtin_real_s16; + lai->primitive_type_vector [f_primitive_type_complex_s8] + = builtin->builtin_complex_s8; + lai->primitive_type_vector [f_primitive_type_complex_s16] + = builtin->builtin_complex_s16; + lai->primitive_type_vector [f_primitive_type_void] + = builtin->builtin_void; +} + /* This is declared in c-lang.h but it is silly to import that file for what is already just a hack. */ -extern int -c_value_print PARAMS ((struct value *, GDB_FILE *, int, enum val_prettyprint)); +extern int c_value_print (struct value *, struct ui_file *, int, + enum val_prettyprint); -const struct language_defn f_language_defn = { +const struct language_defn f_language_defn = +{ "fortran", language_fortran, - f_builtin_types, range_check_on, type_check_on, + case_sensitive_off, + array_column_major, + &exp_descriptor_standard, f_parse, /* parser */ f_error, /* parser error function */ - evaluate_subexp_standard, + null_post_parser, f_printchar, /* Print character constant */ f_printstr, /* function to print string constant */ f_emit_char, /* Function to print a single character */ - f_create_fundamental_type, /* Create fundamental type in this language */ - f_print_type, /* Print a type using appropriate syntax */ + f_print_type, /* Print a type using appropriate syntax */ f_val_print, /* Print a value using appropriate syntax */ - c_value_print, /* FIXME */ - {"", "", "", ""}, /* Binary format info */ - {"0%o", "0", "o", ""}, /* Octal format info */ - {"%d", "", "d", ""}, /* Decimal format info */ - {"0x%x", "0x", "x", ""}, /* Hex format info */ + c_value_print, /* FIXME */ + NULL, /* Language specific skip_trampoline */ + NULL, /* name_of_this */ + basic_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */ + basic_lookup_transparent_type,/* lookup_transparent_type */ + NULL, /* Language specific symbol demangler */ + NULL, /* Language specific class_name_from_physname */ f_op_print_tab, /* expression operators for printing */ 0, /* arrays are first-class (not c-style) */ 1, /* String lower bound */ - &builtin_type_f_character, /* Type of string elements */ + default_word_break_characters, + default_make_symbol_completion_list, + f_language_arch_info, + default_print_array_index, + default_pass_by_reference, LANG_MAGIC - }; +}; -void -_initialize_f_language () +static void * +build_fortran_types (struct gdbarch *gdbarch) { - builtin_type_f_void = + struct builtin_f_type *builtin_f_type + = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type); + + builtin_f_type->builtin_void = init_type (TYPE_CODE_VOID, 1, 0, "VOID", (struct objfile *) NULL); - - builtin_type_f_character = + + builtin_f_type->builtin_character = init_type (TYPE_CODE_INT, TARGET_CHAR_BIT / TARGET_CHAR_BIT, 0, "character", (struct objfile *) NULL); - - builtin_type_f_logical_s1 = + + builtin_f_type->builtin_logical_s1 = init_type (TYPE_CODE_BOOL, TARGET_CHAR_BIT / TARGET_CHAR_BIT, TYPE_FLAG_UNSIGNED, "logical*1", (struct objfile *) NULL); - - builtin_type_f_integer_s2 = - init_type (TYPE_CODE_INT, TARGET_SHORT_BIT / TARGET_CHAR_BIT, - 0, - "integer*2", (struct objfile *) NULL); - - builtin_type_f_logical_s2 = - init_type (TYPE_CODE_BOOL, TARGET_SHORT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "logical*2", (struct objfile *) NULL); - - builtin_type_f_integer = - init_type (TYPE_CODE_INT, TARGET_INT_BIT / TARGET_CHAR_BIT, - 0, - "integer", (struct objfile *) NULL); - - builtin_type_f_logical = - init_type (TYPE_CODE_BOOL, TARGET_INT_BIT / TARGET_CHAR_BIT, - TYPE_FLAG_UNSIGNED, - "logical*4", (struct objfile *) NULL); - - builtin_type_f_real = - init_type (TYPE_CODE_FLT, TARGET_FLOAT_BIT / TARGET_CHAR_BIT, + + builtin_f_type->builtin_integer_s2 = + init_type (TYPE_CODE_INT, + gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "integer*2", (struct objfile *) NULL); + + builtin_f_type->builtin_logical_s2 = + init_type (TYPE_CODE_BOOL, + gdbarch_short_bit (gdbarch) / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "logical*2", (struct objfile *) NULL); + + builtin_f_type->builtin_integer = + init_type (TYPE_CODE_INT, + gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, + 0, "integer", (struct objfile *) NULL); + + builtin_f_type->builtin_logical = + init_type (TYPE_CODE_BOOL, + gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, + TYPE_FLAG_UNSIGNED, "logical*4", (struct objfile *) NULL); + + builtin_f_type->builtin_real = + init_type (TYPE_CODE_FLT, + gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, "real", (struct objfile *) NULL); - - builtin_type_f_real_s8 = - init_type (TYPE_CODE_FLT, TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, + + builtin_f_type->builtin_real_s8 = + init_type (TYPE_CODE_FLT, + gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, "real*8", (struct objfile *) NULL); - - builtin_type_f_real_s16 = - init_type (TYPE_CODE_FLT, TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, + + builtin_f_type->builtin_real_s16 = + init_type (TYPE_CODE_FLT, + gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, "real*16", (struct objfile *) NULL); - - builtin_type_f_complex_s8 = - init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT, + + builtin_f_type->builtin_complex_s8 = + init_type (TYPE_CODE_COMPLEX, + 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, "complex*8", (struct objfile *) NULL); - TYPE_TARGET_TYPE (builtin_type_f_complex_s8) = builtin_type_f_real; - - builtin_type_f_complex_s16 = - init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT, + TYPE_TARGET_TYPE (builtin_f_type->builtin_complex_s8) + = builtin_f_type->builtin_real; + + builtin_f_type->builtin_complex_s16 = + init_type (TYPE_CODE_COMPLEX, + 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, "complex*16", (struct objfile *) NULL); - TYPE_TARGET_TYPE (builtin_type_f_complex_s16) = builtin_type_f_real_s8; - + TYPE_TARGET_TYPE (builtin_f_type->builtin_complex_s16) + = builtin_f_type->builtin_real_s8; + /* We have a new size == 4 double floats for the complex*32 data type */ - - builtin_type_f_complex_s32 = - init_type (TYPE_CODE_COMPLEX, 2 * TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT, + + builtin_f_type->builtin_complex_s32 = + init_type (TYPE_CODE_COMPLEX, + 2 * gdbarch_long_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, "complex*32", (struct objfile *) NULL); - TYPE_TARGET_TYPE (builtin_type_f_complex_s32) = builtin_type_f_real_s16; + TYPE_TARGET_TYPE (builtin_f_type->builtin_complex_s32) + = builtin_f_type->builtin_real_s16; + + return builtin_f_type; +} + +static struct gdbarch_data *f_type_data; + +const struct builtin_f_type * +builtin_f_type (struct gdbarch *gdbarch) +{ + return gdbarch_data (gdbarch, f_type_data); +} + +void +_initialize_f_language (void) +{ + f_type_data = gdbarch_data_register_post_init (build_fortran_types); - builtin_type_string = - init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT, - 0, - "character string", (struct objfile *) NULL); - add_language (&f_language_defn); } #if 0 static SAVED_BF_PTR -allocate_saved_bf_node() +allocate_saved_bf_node (void) { SAVED_BF_PTR new; - + new = (SAVED_BF_PTR) xmalloc (sizeof (SAVED_BF)); - return(new); + return (new); } static SAVED_FUNCTION * -allocate_saved_function_node() +allocate_saved_function_node (void) { SAVED_FUNCTION *new; - + new = (SAVED_FUNCTION *) xmalloc (sizeof (SAVED_FUNCTION)); - return(new); + return (new); } -static SAVED_F77_COMMON_PTR allocate_saved_f77_common_node() +static SAVED_F77_COMMON_PTR +allocate_saved_f77_common_node (void) { SAVED_F77_COMMON_PTR new; - + new = (SAVED_F77_COMMON_PTR) xmalloc (sizeof (SAVED_F77_COMMON)); - return(new); + return (new); } -static COMMON_ENTRY_PTR allocate_common_entry_node() +static COMMON_ENTRY_PTR +allocate_common_entry_node (void) { COMMON_ENTRY_PTR new; - + new = (COMMON_ENTRY_PTR) xmalloc (sizeof (COMMON_ENTRY)); - return(new); + return (new); } #endif -SAVED_F77_COMMON_PTR head_common_list=NULL; /* Ptr to 1st saved COMMON */ -SAVED_F77_COMMON_PTR tail_common_list=NULL; /* Ptr to last saved COMMON */ -SAVED_F77_COMMON_PTR current_common=NULL; /* Ptr to current COMMON */ +SAVED_F77_COMMON_PTR head_common_list = NULL; /* Ptr to 1st saved COMMON */ +SAVED_F77_COMMON_PTR tail_common_list = NULL; /* Ptr to last saved COMMON */ +SAVED_F77_COMMON_PTR current_common = NULL; /* Ptr to current COMMON */ #if 0 -static SAVED_BF_PTR saved_bf_list=NULL; /* Ptr to (.bf,function) - list*/ -static SAVED_BF_PTR saved_bf_list_end=NULL; /* Ptr to above list's end */ -static SAVED_BF_PTR current_head_bf_list=NULL; /* Current head of above list - */ +static SAVED_BF_PTR saved_bf_list = NULL; /* Ptr to (.bf,function) + list */ +static SAVED_BF_PTR saved_bf_list_end = NULL; /* Ptr to above list's end */ +static SAVED_BF_PTR current_head_bf_list = NULL; /* Current head of above list + */ -static SAVED_BF_PTR tmp_bf_ptr; /* Generic temporary for use - in macros */ +static SAVED_BF_PTR tmp_bf_ptr; /* Generic temporary for use + in macros */ /* The following function simply enters a given common block onto the global common block chain */ static void -add_common_block(name,offset,secnum,func_stab) - char *name; - CORE_ADDR offset; - int secnum; - char *func_stab; +add_common_block (char *name, CORE_ADDR offset, int secnum, char *func_stab) { SAVED_F77_COMMON_PTR tmp; - char *c,*local_copy_func_stab; - + char *c, *local_copy_func_stab; + /* If the COMMON block we are trying to add has a blank name (i.e. "#BLNK_COM") then we set it to __BLANK because the darn "#" character makes GDB's input - parser have fits. */ - - - if (STREQ(name,BLANK_COMMON_NAME_ORIGINAL) || - STREQ(name,BLANK_COMMON_NAME_MF77)) + parser have fits. */ + + + if (strcmp (name, BLANK_COMMON_NAME_ORIGINAL) == 0 + || strcmp (name, BLANK_COMMON_NAME_MF77) == 0) { - - free(name); - name = alloca(strlen(BLANK_COMMON_NAME_LOCAL) + 1); - strcpy(name,BLANK_COMMON_NAME_LOCAL); + + xfree (name); + name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1); + strcpy (name, BLANK_COMMON_NAME_LOCAL); } - - tmp = allocate_saved_f77_common_node(); - - local_copy_func_stab = xmalloc (strlen(func_stab) + 1); - strcpy(local_copy_func_stab,func_stab); - - tmp->name = xmalloc(strlen(name) + 1); - + + tmp = allocate_saved_f77_common_node (); + + local_copy_func_stab = xmalloc (strlen (func_stab) + 1); + strcpy (local_copy_func_stab, func_stab); + + tmp->name = xmalloc (strlen (name) + 1); + /* local_copy_func_stab is a stabstring, let us first extract the - function name from the stab by NULLing out the ':' character. */ - - - c = NULL; - c = strchr(local_copy_func_stab,':'); - + function name from the stab by NULLing out the ':' character. */ + + + c = NULL; + c = strchr (local_copy_func_stab, ':'); + if (c) *c = '\0'; else - error("Malformed function STAB found in add_common_block()"); - - - tmp->owning_function = xmalloc (strlen(local_copy_func_stab) + 1); - - strcpy(tmp->owning_function,local_copy_func_stab); - - strcpy(tmp->name,name); - tmp->offset = offset; + error (_("Malformed function STAB found in add_common_block()")); + + + tmp->owning_function = xmalloc (strlen (local_copy_func_stab) + 1); + + strcpy (tmp->owning_function, local_copy_func_stab); + + strcpy (tmp->name, name); + tmp->offset = offset; tmp->next = NULL; tmp->entries = NULL; - tmp->secnum = secnum; - + tmp->secnum = secnum; + current_common = tmp; - + if (head_common_list == NULL) { head_common_list = tail_common_list = tmp; } else { - tail_common_list->next = tmp; + tail_common_list->next = tmp; tail_common_list = tmp; } } #endif /* The following function simply enters a given common entry onto - the "current_common" block that has been saved away. */ + the "current_common" block that has been saved away. */ #if 0 static void -add_common_entry(entry_sym_ptr) - struct symbol *entry_sym_ptr; +add_common_entry (struct symbol *entry_sym_ptr) { COMMON_ENTRY_PTR tmp; - - - + + + /* The order of this list is important, since we expect the entries to appear in decl. - order when we later issue "info common" calls */ - - tmp = allocate_common_entry_node(); - + order when we later issue "info common" calls */ + + tmp = allocate_common_entry_node (); + tmp->next = NULL; tmp->symbol = entry_sym_ptr; - + if (current_common == NULL) - error("Attempt to add COMMON entry with no block open!"); - else + error (_("Attempt to add COMMON entry with no block open!")); + else { if (current_common->entries == NULL) { current_common->entries = tmp; - current_common->end_of_entries = tmp; + current_common->end_of_entries = tmp; } else { - current_common->end_of_entries->next = tmp; - current_common->end_of_entries = tmp; + current_common->end_of_entries->next = tmp; + current_common->end_of_entries = tmp; } } } #endif -/* This routine finds the first encountred COMMON block named "name" */ +/* This routine finds the first encountred COMMON block named "name" */ #if 0 static SAVED_F77_COMMON_PTR -find_first_common_named(name) - char *name; +find_first_common_named (char *name) { - + SAVED_F77_COMMON_PTR tmp; - + tmp = head_common_list; - + while (tmp != NULL) { - if (STREQ(tmp->name,name)) - return(tmp); + if (strcmp (tmp->name, name) == 0) + return (tmp); else tmp = tmp->next; } - return(NULL); + return (NULL); } #endif /* This routine finds the first encountred COMMON block named "name" - that belongs to function funcname */ + that belongs to function funcname */ -SAVED_F77_COMMON_PTR find_common_for_function(name, funcname) - char *name; - char *funcname; +SAVED_F77_COMMON_PTR +find_common_for_function (char *name, char *funcname) { - + SAVED_F77_COMMON_PTR tmp; - + tmp = head_common_list; - + while (tmp != NULL) { - if (STREQ(tmp->name,name) && STREQ(tmp->owning_function,funcname)) - return(tmp); + if (strcmp (tmp->name, name) == 0 + && strcmp (tmp->owning_function, funcname) == 0) + return (tmp); else tmp = tmp->next; } - return(NULL); + return (NULL); } @@ -781,28 +652,25 @@ SAVED_F77_COMMON_PTR find_common_for_function(name, funcname) /* The following function is called to patch up the offsets for the statics contained in the COMMON block named - "name." */ + "name." */ static void -patch_common_entries (blk, offset, secnum) - SAVED_F77_COMMON_PTR blk; - CORE_ADDR offset; - int secnum; +patch_common_entries (SAVED_F77_COMMON_PTR blk, CORE_ADDR offset, int secnum) { COMMON_ENTRY_PTR entry; - - blk->offset = offset; /* Keep this around for future use. */ - + + blk->offset = offset; /* Keep this around for future use. */ + entry = blk->entries; - + while (entry != NULL) { - SYMBOL_VALUE (entry->symbol) += offset; + SYMBOL_VALUE (entry->symbol) += offset; SYMBOL_SECTION (entry->symbol) = secnum; - + entry = entry->next; } - blk->secnum = secnum; + blk->secnum = secnum; } /* Patch all commons named "name" that need patching.Since COMMON @@ -812,35 +680,32 @@ patch_common_entries (blk, offset, secnum) (which is where common data lives). */ static void -patch_all_commons_by_name (name, offset, secnum) - char *name; - CORE_ADDR offset; - int secnum; +patch_all_commons_by_name (char *name, CORE_ADDR offset, int secnum) { - + SAVED_F77_COMMON_PTR tmp; - + /* For blank common blocks, change the canonical reprsentation of a blank name */ - - if ((STREQ(name,BLANK_COMMON_NAME_ORIGINAL)) || - (STREQ(name,BLANK_COMMON_NAME_MF77))) + + if (strcmp (name, BLANK_COMMON_NAME_ORIGINAL) == 0 + || strcmp (name, BLANK_COMMON_NAME_MF77) == 0) { - free(name); - name = alloca(strlen(BLANK_COMMON_NAME_LOCAL) + 1); - strcpy(name,BLANK_COMMON_NAME_LOCAL); + xfree (name); + name = alloca (strlen (BLANK_COMMON_NAME_LOCAL) + 1); + strcpy (name, BLANK_COMMON_NAME_LOCAL); } - + tmp = head_common_list; - + while (tmp != NULL) { - if (COMMON_NEEDS_PATCHING(tmp)) - if (STREQ(tmp->name,name)) - patch_common_entries(tmp,offset,secnum); - + if (COMMON_NEEDS_PATCHING (tmp)) + if (strcmp (tmp->name, name) == 0) + patch_common_entries (tmp, offset, secnum); + tmp = tmp->next; - } + } } #endif @@ -850,7 +715,7 @@ patch_all_commons_by_name (name, offset, secnum) #line pragmas sometimes cause line ranges to get messed up we simply create a linear list. This list can then be searched first by a queueing algorithm and upon failure fall back to - a linear scan. */ + a linear scan. */ #if 0 #define ADD_BF_SYMNUM(bf_sym,fcn_sym) \ @@ -876,24 +741,24 @@ else \ \ saved_bf_list_end->next = tmp_bf_ptr; \ saved_bf_list_end = tmp_bf_ptr; \ - } + } #endif -/* This function frees the entire (.bf,function) list */ +/* This function frees the entire (.bf,function) list */ #if 0 -static void - clear_bf_list() +static void +clear_bf_list (void) { - + SAVED_BF_PTR tmp = saved_bf_list; - SAVED_BF_PTR next = NULL; - + SAVED_BF_PTR next = NULL; + while (tmp != NULL) { next = tmp->next; - free(tmp); - tmp=next; + xfree (tmp); + tmp = next; } saved_bf_list = NULL; } @@ -904,71 +769,70 @@ int global_remote_debug; #if 0 static long -get_bf_for_fcn (the_function) - long the_function; +get_bf_for_fcn (long the_function) { SAVED_BF_PTR tmp; int nprobes = 0; - + /* First use a simple queuing algorithm (i.e. look and see if the item at the head of the queue is the one you want) */ - + if (saved_bf_list == NULL) - fatal ("cannot get .bf node off empty list"); - - if (current_head_bf_list != NULL) + internal_error (__FILE__, __LINE__, + _("cannot get .bf node off empty list")); + + if (current_head_bf_list != NULL) if (current_head_bf_list->symnum_fcn == the_function) { - if (global_remote_debug) - fprintf(stderr,"*"); + if (global_remote_debug) + fprintf_unfiltered (gdb_stderr, "*"); - tmp = current_head_bf_list; + tmp = current_head_bf_list; current_head_bf_list = current_head_bf_list->next; - return(tmp->symnum_bf); + return (tmp->symnum_bf); } - + /* If the above did not work (probably because #line directives were used in the sourcefile and they messed up our internal tables) we now do the ugly linear scan */ - - if (global_remote_debug) - fprintf(stderr,"\ndefaulting to linear scan\n"); - - nprobes = 0; + + if (global_remote_debug) + fprintf_unfiltered (gdb_stderr, "\ndefaulting to linear scan\n"); + + nprobes = 0; tmp = saved_bf_list; while (tmp != NULL) { - nprobes++; + nprobes++; if (tmp->symnum_fcn == the_function) - { + { if (global_remote_debug) - fprintf(stderr,"Found in %d probes\n",nprobes); + fprintf_unfiltered (gdb_stderr, "Found in %d probes\n", nprobes); current_head_bf_list = tmp->next; - return(tmp->symnum_bf); - } - tmp= tmp->next; + return (tmp->symnum_bf); + } + tmp = tmp->next; } - - return(-1); + + return (-1); } -static SAVED_FUNCTION_PTR saved_function_list=NULL; -static SAVED_FUNCTION_PTR saved_function_list_end=NULL; +static SAVED_FUNCTION_PTR saved_function_list = NULL; +static SAVED_FUNCTION_PTR saved_function_list_end = NULL; static void -clear_function_list() +clear_function_list (void) { SAVED_FUNCTION_PTR tmp = saved_function_list; - SAVED_FUNCTION_PTR next = NULL; - + SAVED_FUNCTION_PTR next = NULL; + while (tmp != NULL) { next = tmp->next; - free(tmp); + xfree (tmp); tmp = next; } - + saved_function_list = NULL; } #endif -