1 /* Fortran language support routines for GDB, the GNU debugger.
3 Copyright (C) 1993-2019 Free Software Foundation, Inc.
5 Contributed by Motorola. Adapted from the C parser by Farooq Butt
6 (fmbutt@engage.sps.mot.com).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "expression.h"
27 #include "parser-defs.h"
34 #include "cp-support.h"
37 #include "target-float.h"
43 static void f_printchar (int c, struct type *type, struct ui_file * stream);
44 static void f_emit_char (int c, struct type *type,
45 struct ui_file * stream, int quoter);
47 /* Return the encoding that should be used for the character type
51 f_get_encoding (struct type *type)
55 switch (TYPE_LENGTH (type))
58 encoding = target_charset (get_type_arch (type));
61 if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_BIG)
62 encoding = "UTF-32BE";
64 encoding = "UTF-32LE";
68 error (_("unrecognized character type"));
74 /* Print the character C on STREAM as part of the contents of a literal
75 string whose delimiter is QUOTER. Note that that format for printing
76 characters and strings is language specific.
77 FIXME: This is a copy of the same function from c-exp.y. It should
78 be replaced with a true F77 version. */
81 f_emit_char (int c, struct type *type, struct ui_file *stream, int quoter)
83 const char *encoding = f_get_encoding (type);
85 generic_emit_char (c, type, stream, quoter, encoding);
88 /* Implementation of la_printchar. */
91 f_printchar (int c, struct type *type, struct ui_file *stream)
93 fputs_filtered ("'", stream);
94 LA_EMIT_CHAR (c, type, stream, '\'');
95 fputs_filtered ("'", stream);
98 /* Print the character string STRING, printing at most LENGTH characters.
99 Printing stops early if the number hits print_max; repeat counts
100 are printed as appropriate. Print ellipses at the end if we
101 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
102 FIXME: This is a copy of the same function from c-exp.y. It should
103 be replaced with a true F77 version. */
106 f_printstr (struct ui_file *stream, struct type *type, const gdb_byte *string,
107 unsigned int length, const char *encoding, int force_ellipses,
108 const struct value_print_options *options)
110 const char *type_encoding = f_get_encoding (type);
112 if (TYPE_LENGTH (type) == 4)
113 fputs_filtered ("4_", stream);
115 if (!encoding || !*encoding)
116 encoding = type_encoding;
118 generic_printstr (stream, type, string, length, encoding,
119 force_ellipses, '\'', 0, options);
123 /* Table of operators and their precedences for printing expressions. */
125 static const struct op_print f_op_print_tab[] =
127 {"+", BINOP_ADD, PREC_ADD, 0},
128 {"+", UNOP_PLUS, PREC_PREFIX, 0},
129 {"-", BINOP_SUB, PREC_ADD, 0},
130 {"-", UNOP_NEG, PREC_PREFIX, 0},
131 {"*", BINOP_MUL, PREC_MUL, 0},
132 {"/", BINOP_DIV, PREC_MUL, 0},
133 {"DIV", BINOP_INTDIV, PREC_MUL, 0},
134 {"MOD", BINOP_REM, PREC_MUL, 0},
135 {"=", BINOP_ASSIGN, PREC_ASSIGN, 1},
136 {".OR.", BINOP_LOGICAL_OR, PREC_LOGICAL_OR, 0},
137 {".AND.", BINOP_LOGICAL_AND, PREC_LOGICAL_AND, 0},
138 {".NOT.", UNOP_LOGICAL_NOT, PREC_PREFIX, 0},
139 {".EQ.", BINOP_EQUAL, PREC_EQUAL, 0},
140 {".NE.", BINOP_NOTEQUAL, PREC_EQUAL, 0},
141 {".LE.", BINOP_LEQ, PREC_ORDER, 0},
142 {".GE.", BINOP_GEQ, PREC_ORDER, 0},
143 {".GT.", BINOP_GTR, PREC_ORDER, 0},
144 {".LT.", BINOP_LESS, PREC_ORDER, 0},
145 {"**", UNOP_IND, PREC_PREFIX, 0},
146 {"@", BINOP_REPEAT, PREC_REPEAT, 0},
147 {NULL, OP_NULL, PREC_REPEAT, 0}
150 enum f_primitive_types {
151 f_primitive_type_character,
152 f_primitive_type_logical,
153 f_primitive_type_logical_s1,
154 f_primitive_type_logical_s2,
155 f_primitive_type_logical_s8,
156 f_primitive_type_integer,
157 f_primitive_type_integer_s2,
158 f_primitive_type_real,
159 f_primitive_type_real_s8,
160 f_primitive_type_real_s16,
161 f_primitive_type_complex_s8,
162 f_primitive_type_complex_s16,
163 f_primitive_type_void,
168 f_language_arch_info (struct gdbarch *gdbarch,
169 struct language_arch_info *lai)
171 const struct builtin_f_type *builtin = builtin_f_type (gdbarch);
173 lai->string_char_type = builtin->builtin_character;
174 lai->primitive_type_vector
175 = GDBARCH_OBSTACK_CALLOC (gdbarch, nr_f_primitive_types + 1,
178 lai->primitive_type_vector [f_primitive_type_character]
179 = builtin->builtin_character;
180 lai->primitive_type_vector [f_primitive_type_logical]
181 = builtin->builtin_logical;
182 lai->primitive_type_vector [f_primitive_type_logical_s1]
183 = builtin->builtin_logical_s1;
184 lai->primitive_type_vector [f_primitive_type_logical_s2]
185 = builtin->builtin_logical_s2;
186 lai->primitive_type_vector [f_primitive_type_logical_s8]
187 = builtin->builtin_logical_s8;
188 lai->primitive_type_vector [f_primitive_type_real]
189 = builtin->builtin_real;
190 lai->primitive_type_vector [f_primitive_type_real_s8]
191 = builtin->builtin_real_s8;
192 lai->primitive_type_vector [f_primitive_type_real_s16]
193 = builtin->builtin_real_s16;
194 lai->primitive_type_vector [f_primitive_type_complex_s8]
195 = builtin->builtin_complex_s8;
196 lai->primitive_type_vector [f_primitive_type_complex_s16]
197 = builtin->builtin_complex_s16;
198 lai->primitive_type_vector [f_primitive_type_void]
199 = builtin->builtin_void;
201 lai->bool_type_symbol = "logical";
202 lai->bool_type_default = builtin->builtin_logical_s2;
205 /* Remove the modules separator :: from the default break list. */
208 f_word_break_characters (void)
216 retval = xstrdup (default_word_break_characters ());
217 s = strchr (retval, ':');
220 char *last_char = &s[strlen (s) - 1];
229 /* Consider the modules separator :: as a valid symbol name character
233 f_collect_symbol_completion_matches (completion_tracker &tracker,
234 complete_symbol_mode mode,
235 symbol_name_match_type compare_name,
236 const char *text, const char *word,
239 default_collect_symbol_completion_matches_break_on (tracker, mode,
241 text, word, ":", code);
244 /* Special expression evaluation cases for Fortran. */
246 evaluate_subexp_f (struct type *expect_type, struct expression *exp,
247 int *pos, enum noside noside)
249 struct value *arg1 = NULL;
256 op = exp->elts[pc].opcode;
262 return evaluate_subexp_standard (expect_type, exp, pos, noside);
265 arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
266 if (noside == EVAL_SKIP)
267 return eval_skip_value (exp);
268 type = value_type (arg1);
269 switch (TYPE_CODE (type))
274 = fabs (target_float_to_host_double (value_contents (arg1),
276 return value_from_host_double (type, d);
280 LONGEST l = value_as_long (arg1);
282 return value_from_longest (type, l);
285 error (_("ABS of type %s not supported"), TYPE_SAFE_NAME (type));
287 case UNOP_FORTRAN_KIND:
288 arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
289 type = value_type (arg1);
291 switch (TYPE_CODE (type))
293 case TYPE_CODE_STRUCT:
294 case TYPE_CODE_UNION:
295 case TYPE_CODE_MODULE:
297 error (_("argument to kind must be an intrinsic type"));
300 if (!TYPE_TARGET_TYPE (type))
301 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
303 return value_from_longest (builtin_type (exp->gdbarch)->builtin_int,
304 TYPE_LENGTH (TYPE_TARGET_TYPE(type)));
307 /* Should be unreachable. */
311 /* Return true if TYPE is a string. */
314 f_is_string_type_p (struct type *type)
316 type = check_typedef (type);
317 return (TYPE_CODE (type) == TYPE_CODE_STRING
318 || (TYPE_CODE (type) == TYPE_CODE_ARRAY
319 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CHAR));
322 /* Special expression lengths for Fortran. */
325 operator_length_f (const struct expression *exp, int pc, int *oplenp,
331 switch (exp->elts[pc - 1].opcode)
334 operator_length_standard (exp, pc, oplenp, argsp);
337 case UNOP_FORTRAN_KIND:
347 /* Special expression printing for Fortran. */
350 print_subexp_f (struct expression *exp, int *pos,
351 struct ui_file *stream, enum precedence prec)
354 enum exp_opcode op = exp->elts[pc].opcode;
359 print_subexp_standard (exp, pos, stream, prec);
362 case UNOP_FORTRAN_KIND:
364 fputs_filtered ("KIND(", stream);
365 print_subexp (exp, pos, stream, PREC_SUFFIX);
366 fputs_filtered (")", stream);
371 /* Special expression names for Fortran. */
374 op_name_f (enum exp_opcode opcode)
379 return op_name_standard (opcode);
384 #include "fortran-operator.def"
389 /* Special expression dumping for Fortran. */
392 dump_subexp_body_f (struct expression *exp,
393 struct ui_file *stream, int elt)
395 int opcode = exp->elts[elt].opcode;
401 return dump_subexp_body_standard (exp, stream, elt);
403 case UNOP_FORTRAN_KIND:
404 operator_length_f (exp, (elt + 1), &oplen, &nargs);
409 for (i = 0; i < nargs; i += 1)
410 elt = dump_subexp (exp, stream, elt);
415 /* Special expression checking for Fortran. */
418 operator_check_f (struct expression *exp, int pos,
419 int (*objfile_func) (struct objfile *objfile,
423 const union exp_element *const elts = exp->elts;
425 switch (elts[pos].opcode)
427 case UNOP_FORTRAN_KIND:
428 /* Any references to objfiles are held in the arguments to this
429 expression, not within the expression itself, so no additional
430 checking is required here, the outer expression iteration code
431 will take care of checking each argument. */
435 return operator_check_standard (exp, pos, objfile_func, data);
441 static const char *f_extensions[] =
443 ".f", ".F", ".for", ".FOR", ".ftn", ".FTN", ".fpp", ".FPP",
444 ".f90", ".F90", ".f95", ".F95", ".f03", ".F03", ".f08", ".F08",
448 /* Expression processing for Fortran. */
449 static const struct exp_descriptor exp_descriptor_f =
459 extern const struct language_defn f_language_defn =
470 f_parse, /* parser */
472 f_printchar, /* Print character constant */
473 f_printstr, /* function to print string constant */
474 f_emit_char, /* Function to print a single character */
475 f_print_type, /* Print a type using appropriate syntax */
476 default_print_typedef, /* Print a typedef using appropriate syntax */
477 f_val_print, /* Print a value using appropriate syntax */
478 c_value_print, /* FIXME */
479 default_read_var_value, /* la_read_var_value */
480 NULL, /* Language specific skip_trampoline */
481 NULL, /* name_of_this */
482 false, /* la_store_sym_names_in_linkage_form_p */
483 cp_lookup_symbol_nonlocal, /* lookup_symbol_nonlocal */
484 basic_lookup_transparent_type,/* lookup_transparent_type */
486 /* We could support demangling here to provide module namespaces
487 also for inferiors with only minimal symbol table (ELF symbols).
488 Just the mangling standard is not standardized across compilers
489 and there is no DW_AT_producer available for inferiors with only
490 the ELF symbols to check the mangling kind. */
491 NULL, /* Language specific symbol demangler */
493 NULL, /* Language specific
494 class_name_from_physname */
495 f_op_print_tab, /* expression operators for printing */
496 0, /* arrays are first-class (not c-style) */
497 1, /* String lower bound */
498 f_word_break_characters,
499 f_collect_symbol_completion_matches,
500 f_language_arch_info,
501 default_print_array_index,
502 default_pass_by_reference,
504 c_watch_location_expression,
505 NULL, /* la_get_symbol_name_matcher */
506 iterate_over_symbols,
507 default_search_name_hash,
512 "(...)" /* la_struct_too_deep_ellipsis */
516 build_fortran_types (struct gdbarch *gdbarch)
518 struct builtin_f_type *builtin_f_type
519 = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct builtin_f_type);
521 builtin_f_type->builtin_void
522 = arch_type (gdbarch, TYPE_CODE_VOID, TARGET_CHAR_BIT, "VOID");
524 builtin_f_type->builtin_character
525 = arch_type (gdbarch, TYPE_CODE_CHAR, TARGET_CHAR_BIT, "character");
527 builtin_f_type->builtin_logical_s1
528 = arch_boolean_type (gdbarch, TARGET_CHAR_BIT, 1, "logical*1");
530 builtin_f_type->builtin_integer_s2
531 = arch_integer_type (gdbarch, gdbarch_short_bit (gdbarch), 0,
534 builtin_f_type->builtin_integer_s8
535 = arch_integer_type (gdbarch, gdbarch_long_long_bit (gdbarch), 0,
538 builtin_f_type->builtin_logical_s2
539 = arch_boolean_type (gdbarch, gdbarch_short_bit (gdbarch), 1,
542 builtin_f_type->builtin_logical_s8
543 = arch_boolean_type (gdbarch, gdbarch_long_long_bit (gdbarch), 1,
546 builtin_f_type->builtin_integer
547 = arch_integer_type (gdbarch, gdbarch_int_bit (gdbarch), 0,
550 builtin_f_type->builtin_logical
551 = arch_boolean_type (gdbarch, gdbarch_int_bit (gdbarch), 1,
554 builtin_f_type->builtin_real
555 = arch_float_type (gdbarch, gdbarch_float_bit (gdbarch),
556 "real", gdbarch_float_format (gdbarch));
557 builtin_f_type->builtin_real_s8
558 = arch_float_type (gdbarch, gdbarch_double_bit (gdbarch),
559 "real*8", gdbarch_double_format (gdbarch));
560 builtin_f_type->builtin_real_s16
561 = arch_float_type (gdbarch, gdbarch_long_double_bit (gdbarch),
562 "real*16", gdbarch_long_double_format (gdbarch));
564 builtin_f_type->builtin_complex_s8
565 = arch_complex_type (gdbarch, "complex*8",
566 builtin_f_type->builtin_real);
567 builtin_f_type->builtin_complex_s16
568 = arch_complex_type (gdbarch, "complex*16",
569 builtin_f_type->builtin_real_s8);
570 builtin_f_type->builtin_complex_s32
571 = arch_complex_type (gdbarch, "complex*32",
572 builtin_f_type->builtin_real_s16);
574 return builtin_f_type;
577 static struct gdbarch_data *f_type_data;
579 const struct builtin_f_type *
580 builtin_f_type (struct gdbarch *gdbarch)
582 return (const struct builtin_f_type *) gdbarch_data (gdbarch, f_type_data);
586 _initialize_f_language (void)
588 f_type_data = gdbarch_data_register_post_init (build_fortran_types);
594 fortran_argument_convert (struct value *value, bool is_artificial)
598 /* If the value is not in the inferior e.g. registers values,
599 convenience variables and user input. */
600 if (VALUE_LVAL (value) != lval_memory)
602 struct type *type = value_type (value);
603 const int length = TYPE_LENGTH (type);
605 = value_as_long (value_allocate_space_in_inferior (length));
606 write_memory (addr, value_contents (value), length);
608 = value_from_contents_and_address (type, value_contents (value),
610 return value_addr (val);
613 return value_addr (value); /* Program variables, e.g. arrays. */
621 fortran_preserve_arg_pointer (struct value *arg, struct type *type)
623 if (TYPE_CODE (value_type (arg)) == TYPE_CODE_PTR)
624 return value_type (arg);