Line data Source code
1 : /* Perform type resolution on the various structures.
2 : Copyright (C) 2001-2026 Free Software Foundation, Inc.
3 : Contributed by Andy Vaught
4 :
5 : This file is part of GCC.
6 :
7 : GCC is free software; you can redistribute it and/or modify it under
8 : the terms of the GNU General Public License as published by the Free
9 : Software Foundation; either version 3, or (at your option) any later
10 : version.
11 :
12 : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 : WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 : FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 : for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with GCC; see the file COPYING3. If not see
19 : <http://www.gnu.org/licenses/>. */
20 :
21 : #include "config.h"
22 : #include "system.h"
23 : #include "coretypes.h"
24 : #include "options.h"
25 : #include "bitmap.h"
26 : #include "gfortran.h"
27 : #include "arith.h" /* For gfc_compare_expr(). */
28 : #include "dependency.h"
29 : #include "data.h"
30 : #include "target-memory.h" /* for gfc_simplify_transfer */
31 : #include "constructor.h"
32 :
33 : /* Types used in equivalence statements. */
34 :
35 : enum seq_type
36 : {
37 : SEQ_NONDEFAULT, SEQ_NUMERIC, SEQ_CHARACTER, SEQ_MIXED
38 : };
39 :
40 : /* Stack to keep track of the nesting of blocks as we move through the
41 : code. See resolve_branch() and gfc_resolve_code(). */
42 :
43 : typedef struct code_stack
44 : {
45 : struct gfc_code *head, *current;
46 : struct code_stack *prev;
47 :
48 : /* This bitmap keeps track of the targets valid for a branch from
49 : inside this block except for END {IF|SELECT}s of enclosing
50 : blocks. */
51 : bitmap reachable_labels;
52 : }
53 : code_stack;
54 :
55 : static code_stack *cs_base = NULL;
56 :
57 : struct check_default_none_data
58 : {
59 : gfc_code *code;
60 : hash_set<gfc_symbol *> *sym_hash;
61 : gfc_namespace *ns;
62 : bool default_none;
63 : };
64 :
65 : /* Nonzero if we're inside a FORALL or DO CONCURRENT block. */
66 :
67 : static int forall_flag;
68 : int gfc_do_concurrent_flag;
69 :
70 : /* True when we are resolving an expression that is an actual argument to
71 : a procedure. */
72 : static bool actual_arg = false;
73 : /* True when we are resolving an expression that is the first actual argument
74 : to a procedure. */
75 : static bool first_actual_arg = false;
76 :
77 :
78 : /* Nonzero if we're inside a OpenMP WORKSHARE or PARALLEL WORKSHARE block. */
79 :
80 : static int omp_workshare_flag;
81 :
82 :
83 : /* True if we are resolving a specification expression. */
84 : static bool specification_expr = false;
85 : /* The dummy whose character length or array bounds are currently being
86 : resolved as a specification expression. */
87 : static gfc_symbol *specification_expr_symbol = NULL;
88 :
89 : /* The id of the last entry seen. */
90 : static int current_entry_id;
91 :
92 : /* We use bitmaps to determine if a branch target is valid. */
93 : static bitmap_obstack labels_obstack;
94 :
95 : /* True when simplifying a EXPR_VARIABLE argument to an inquiry function. */
96 : static bool inquiry_argument = false;
97 :
98 : static bool
99 464 : entry_dummy_seen_p (gfc_symbol *sym)
100 : {
101 464 : gfc_entry_list *entry;
102 464 : gfc_formal_arglist *formal;
103 :
104 464 : gcc_checking_assert (sym->attr.dummy && sym->ns == gfc_current_ns);
105 :
106 464 : for (entry = gfc_current_ns->entries;
107 471 : entry && entry->id <= current_entry_id;
108 7 : entry = entry->next)
109 765 : for (formal = entry->sym->formal; formal; formal = formal->next)
110 758 : if (formal->sym && sym->name == formal->sym->name)
111 : return true;
112 :
113 : return false;
114 : }
115 :
116 :
117 : /* Is the symbol host associated? */
118 : static bool
119 57269 : is_sym_host_assoc (gfc_symbol *sym, gfc_namespace *ns)
120 : {
121 62540 : for (ns = ns->parent; ns; ns = ns->parent)
122 : {
123 5529 : if (sym->ns == ns)
124 : return true;
125 : }
126 :
127 : return false;
128 : }
129 :
130 : /* Ensure a typespec used is valid; for instance, TYPE(t) is invalid if t is
131 : an ABSTRACT derived-type. If where is not NULL, an error message with that
132 : locus is printed, optionally using name. */
133 :
134 : static bool
135 1632703 : resolve_typespec_used (gfc_typespec* ts, locus* where, const char* name)
136 : {
137 1632703 : if (ts->type == BT_DERIVED && ts->u.derived->attr.abstract)
138 : {
139 5 : if (where)
140 : {
141 5 : if (name)
142 4 : gfc_error ("%qs at %L is of the ABSTRACT type %qs",
143 : name, where, ts->u.derived->name);
144 : else
145 1 : gfc_error ("ABSTRACT type %qs used at %L",
146 : ts->u.derived->name, where);
147 : }
148 :
149 : return false;
150 : }
151 :
152 : return true;
153 : }
154 :
155 :
156 : static bool
157 5954 : check_proc_interface (gfc_symbol *ifc, locus *where)
158 : {
159 : /* Several checks for F08:C1216. */
160 5954 : if (ifc->attr.procedure)
161 : {
162 2 : gfc_error ("Interface %qs at %L is declared "
163 : "in a later PROCEDURE statement", ifc->name, where);
164 2 : return false;
165 : }
166 5952 : if (ifc->generic)
167 : {
168 : /* For generic interfaces, check if there is
169 : a specific procedure with the same name. */
170 : gfc_interface *gen = ifc->generic;
171 12 : while (gen && strcmp (gen->sym->name, ifc->name) != 0)
172 5 : gen = gen->next;
173 7 : if (!gen)
174 : {
175 4 : gfc_error ("Interface %qs at %L may not be generic",
176 : ifc->name, where);
177 4 : return false;
178 : }
179 : }
180 5948 : if (ifc->attr.proc == PROC_ST_FUNCTION)
181 : {
182 4 : gfc_error ("Interface %qs at %L may not be a statement function",
183 : ifc->name, where);
184 4 : return false;
185 : }
186 5944 : if (gfc_is_intrinsic (ifc, 0, ifc->declared_at)
187 5944 : || gfc_is_intrinsic (ifc, 1, ifc->declared_at))
188 17 : ifc->attr.intrinsic = 1;
189 5944 : if (ifc->attr.intrinsic && !gfc_intrinsic_actual_ok (ifc->name, 0))
190 : {
191 3 : gfc_error ("Intrinsic procedure %qs not allowed in "
192 : "PROCEDURE statement at %L", ifc->name, where);
193 3 : return false;
194 : }
195 5941 : if (!ifc->attr.if_source && !ifc->attr.intrinsic && ifc->name[0] != '\0')
196 : {
197 7 : gfc_error ("Interface %qs at %L must be explicit", ifc->name, where);
198 7 : return false;
199 : }
200 : return true;
201 : }
202 :
203 :
204 : static void resolve_symbol (gfc_symbol *sym);
205 :
206 :
207 : /* Resolve the interface for a PROCEDURE declaration or procedure pointer. */
208 :
209 : static bool
210 2153 : resolve_procedure_interface (gfc_symbol *sym)
211 : {
212 2153 : gfc_symbol *ifc = sym->ts.interface;
213 :
214 2153 : if (!ifc)
215 : return true;
216 :
217 1992 : if (ifc == sym)
218 : {
219 2 : gfc_error ("PROCEDURE %qs at %L may not be used as its own interface",
220 : sym->name, &sym->declared_at);
221 2 : return false;
222 : }
223 1990 : if (!check_proc_interface (ifc, &sym->declared_at))
224 : return false;
225 :
226 1981 : if (ifc->attr.if_source || ifc->attr.intrinsic)
227 : {
228 : /* Resolve interface and copy attributes. */
229 1695 : resolve_symbol (ifc);
230 1695 : if (ifc->attr.intrinsic)
231 14 : gfc_resolve_intrinsic (ifc, &ifc->declared_at);
232 :
233 1695 : if (ifc->result)
234 : {
235 784 : sym->ts = ifc->result->ts;
236 784 : sym->attr.allocatable = ifc->result->attr.allocatable;
237 784 : sym->attr.pointer = ifc->result->attr.pointer;
238 784 : sym->attr.dimension = ifc->result->attr.dimension;
239 784 : sym->attr.class_ok = ifc->result->attr.class_ok;
240 784 : sym->as = gfc_copy_array_spec (ifc->result->as);
241 784 : sym->result = sym;
242 : }
243 : else
244 : {
245 911 : sym->ts = ifc->ts;
246 911 : sym->attr.allocatable = ifc->attr.allocatable;
247 911 : sym->attr.pointer = ifc->attr.pointer;
248 911 : sym->attr.dimension = ifc->attr.dimension;
249 911 : sym->attr.class_ok = ifc->attr.class_ok;
250 911 : sym->as = gfc_copy_array_spec (ifc->as);
251 : }
252 1695 : sym->ts.interface = ifc;
253 1695 : sym->attr.function = ifc->attr.function;
254 1695 : sym->attr.subroutine = ifc->attr.subroutine;
255 :
256 1695 : sym->attr.pure = ifc->attr.pure;
257 1695 : sym->attr.elemental = ifc->attr.elemental;
258 1695 : sym->attr.contiguous = ifc->attr.contiguous;
259 1695 : sym->attr.recursive = ifc->attr.recursive;
260 1695 : sym->attr.always_explicit = ifc->attr.always_explicit;
261 1695 : sym->attr.ext_attr |= ifc->attr.ext_attr;
262 1695 : sym->attr.is_bind_c = ifc->attr.is_bind_c;
263 : /* Copy char length. */
264 1695 : if (ifc->ts.type == BT_CHARACTER && ifc->ts.u.cl)
265 : {
266 45 : sym->ts.u.cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl);
267 45 : if (sym->ts.u.cl->length && !sym->ts.u.cl->resolved
268 53 : && !gfc_resolve_expr (sym->ts.u.cl->length))
269 : return false;
270 : }
271 : }
272 :
273 : return true;
274 : }
275 :
276 :
277 : /* Resolve types of formal argument lists. These have to be done early so that
278 : the formal argument lists of module procedures can be copied to the
279 : containing module before the individual procedures are resolved
280 : individually. We also resolve argument lists of procedures in interface
281 : blocks because they are self-contained scoping units.
282 :
283 : Since a dummy argument cannot be a non-dummy procedure, the only
284 : resort left for untyped names are the IMPLICIT types. */
285 :
286 : void
287 566558 : gfc_resolve_formal_arglist (gfc_symbol *proc)
288 : {
289 566558 : gfc_formal_arglist *f;
290 566558 : gfc_symbol *sym;
291 566558 : bool saved_specification_expr;
292 566558 : int i;
293 :
294 566558 : if (proc->result != NULL)
295 352252 : sym = proc->result;
296 : else
297 : sym = proc;
298 :
299 566558 : if (gfc_elemental (proc)
300 403347 : || sym->attr.pointer || sym->attr.allocatable
301 957319 : || (sym->as && sym->as->rank != 0))
302 : {
303 178139 : proc->attr.always_explicit = 1;
304 178139 : sym->attr.always_explicit = 1;
305 : }
306 :
307 566558 : gfc_namespace *orig_current_ns = gfc_current_ns;
308 566558 : gfc_current_ns = gfc_get_procedure_ns (proc);
309 :
310 1464435 : for (f = proc->formal; f; f = f->next)
311 : {
312 897879 : gfc_array_spec *as;
313 897879 : gfc_symbol *saved_specification_expr_symbol;
314 :
315 897879 : sym = f->sym;
316 :
317 897879 : if (sym == NULL)
318 : {
319 : /* Alternate return placeholder. */
320 171 : if (gfc_elemental (proc))
321 1 : gfc_error ("Alternate return specifier in elemental subroutine "
322 : "%qs at %L is not allowed", proc->name,
323 : &proc->declared_at);
324 171 : if (proc->attr.function)
325 1 : gfc_error ("Alternate return specifier in function "
326 : "%qs at %L is not allowed", proc->name,
327 : &proc->declared_at);
328 171 : continue;
329 : }
330 :
331 611 : if (sym->attr.procedure && sym->attr.if_source != IFSRC_DECL
332 898319 : && !resolve_procedure_interface (sym))
333 : break;
334 :
335 897708 : if (strcmp (proc->name, sym->name) == 0)
336 : {
337 2 : gfc_error ("Self-referential argument "
338 : "%qs at %L is not allowed", sym->name,
339 : &proc->declared_at);
340 2 : break;
341 : }
342 :
343 897706 : if (sym->attr.if_source != IFSRC_UNKNOWN)
344 903 : gfc_resolve_formal_arglist (sym);
345 :
346 897706 : if (sym->attr.subroutine || sym->attr.external)
347 : {
348 913 : if (sym->attr.flavor == FL_UNKNOWN)
349 9 : gfc_add_flavor (&sym->attr, FL_PROCEDURE, sym->name, &sym->declared_at);
350 : }
351 : else
352 : {
353 896793 : if (sym->ts.type == BT_UNKNOWN && !proc->attr.intrinsic
354 3688 : && (!sym->attr.function || sym->result == sym))
355 3650 : gfc_set_default_type (sym, 1, sym->ns);
356 : }
357 :
358 897706 : as = sym->ts.type == BT_CLASS && sym->attr.class_ok
359 912296 : ? CLASS_DATA (sym)->as : sym->as;
360 :
361 897706 : saved_specification_expr = specification_expr;
362 897706 : saved_specification_expr_symbol = specification_expr_symbol;
363 897706 : specification_expr = true;
364 897706 : specification_expr_symbol = sym;
365 897706 : gfc_resolve_array_spec (as, 0);
366 897706 : specification_expr = saved_specification_expr;
367 897706 : specification_expr_symbol = saved_specification_expr_symbol;
368 :
369 : /* We can't tell if an array with dimension (:) is assumed or deferred
370 : shape until we know if it has the pointer or allocatable attributes.
371 : */
372 897706 : if (as && as->rank > 0 && as->type == AS_DEFERRED
373 13035 : && ((sym->ts.type != BT_CLASS
374 11792 : && !(sym->attr.pointer || sym->attr.allocatable))
375 5560 : || (sym->ts.type == BT_CLASS
376 1243 : && !(CLASS_DATA (sym)->attr.class_pointer
377 1031 : || CLASS_DATA (sym)->attr.allocatable)))
378 8043 : && sym->attr.flavor != FL_PROCEDURE)
379 : {
380 8042 : as->type = AS_ASSUMED_SHAPE;
381 18599 : for (i = 0; i < as->rank; i++)
382 10557 : as->lower[i] = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
383 : }
384 :
385 139966 : if ((as && as->rank > 0 && as->type == AS_ASSUMED_SHAPE)
386 125244 : || (as && as->type == AS_ASSUMED_RANK)
387 843042 : || sym->attr.pointer || sym->attr.allocatable || sym->attr.target
388 832631 : || (sym->ts.type == BT_CLASS && sym->attr.class_ok
389 12171 : && (CLASS_DATA (sym)->attr.class_pointer
390 11676 : || CLASS_DATA (sym)->attr.allocatable
391 10681 : || CLASS_DATA (sym)->attr.target))
392 831141 : || sym->attr.optional)
393 : {
394 83873 : proc->attr.always_explicit = 1;
395 83873 : if (proc->result)
396 38990 : proc->result->attr.always_explicit = 1;
397 : }
398 :
399 : /* If the flavor is unknown at this point, it has to be a variable.
400 : A procedure specification would have already set the type. */
401 :
402 897706 : if (sym->attr.flavor == FL_UNKNOWN)
403 52954 : gfc_add_flavor (&sym->attr, FL_VARIABLE, sym->name, &sym->declared_at);
404 :
405 897706 : if (gfc_pure (proc))
406 : {
407 329477 : if (sym->attr.flavor == FL_PROCEDURE)
408 : {
409 : /* F08:C1279. */
410 29 : if (!gfc_pure (sym))
411 : {
412 1 : gfc_error ("Dummy procedure %qs of PURE procedure at %L must "
413 : "also be PURE", sym->name, &sym->declared_at);
414 1 : continue;
415 : }
416 : }
417 329448 : else if (!sym->attr.pointer)
418 : {
419 329434 : if (proc->attr.function && sym->attr.intent != INTENT_IN)
420 : {
421 111 : if (sym->attr.value)
422 110 : gfc_notify_std (GFC_STD_F2008, "Argument %qs"
423 : " of pure function %qs at %L with VALUE "
424 : "attribute but without INTENT(IN)",
425 : sym->name, proc->name, &sym->declared_at);
426 : else
427 1 : gfc_error ("Argument %qs of pure function %qs at %L must "
428 : "be INTENT(IN) or VALUE", sym->name, proc->name,
429 : &sym->declared_at);
430 : }
431 :
432 329434 : if (proc->attr.subroutine && sym->attr.intent == INTENT_UNKNOWN)
433 : {
434 159 : if (sym->attr.value)
435 159 : gfc_notify_std (GFC_STD_F2008, "Argument %qs"
436 : " of pure subroutine %qs at %L with VALUE "
437 : "attribute but without INTENT", sym->name,
438 : proc->name, &sym->declared_at);
439 : else
440 0 : gfc_error ("Argument %qs of pure subroutine %qs at %L "
441 : "must have its INTENT specified or have the "
442 : "VALUE attribute", sym->name, proc->name,
443 : &sym->declared_at);
444 : }
445 : }
446 :
447 : /* F08:C1278a. */
448 329476 : if (sym->ts.type == BT_CLASS && sym->attr.intent == INTENT_OUT)
449 : {
450 1 : gfc_error ("INTENT(OUT) argument %qs of pure procedure %qs at %L"
451 : " may not be polymorphic", sym->name, proc->name,
452 : &sym->declared_at);
453 1 : continue;
454 : }
455 : }
456 :
457 897704 : if (proc->attr.implicit_pure)
458 : {
459 26531 : if (sym->attr.flavor == FL_PROCEDURE)
460 : {
461 337 : if (!gfc_pure (sym))
462 305 : proc->attr.implicit_pure = 0;
463 : }
464 26194 : else if (!sym->attr.pointer)
465 : {
466 25392 : if (proc->attr.function && sym->attr.intent != INTENT_IN
467 2760 : && !sym->value)
468 2760 : proc->attr.implicit_pure = 0;
469 :
470 25392 : if (proc->attr.subroutine && sym->attr.intent == INTENT_UNKNOWN
471 4342 : && !sym->value)
472 4342 : proc->attr.implicit_pure = 0;
473 : }
474 : }
475 :
476 897704 : if (gfc_elemental (proc))
477 : {
478 : /* F08:C1289. */
479 303594 : if (sym->attr.codimension
480 303593 : || (sym->ts.type == BT_CLASS && CLASS_DATA (sym)
481 977 : && CLASS_DATA (sym)->attr.codimension))
482 : {
483 3 : gfc_error ("Coarray dummy argument %qs at %L to elemental "
484 : "procedure", sym->name, &sym->declared_at);
485 3 : continue;
486 : }
487 :
488 303591 : if (sym->as || (sym->ts.type == BT_CLASS && CLASS_DATA (sym)
489 975 : && CLASS_DATA (sym)->as))
490 : {
491 2 : gfc_error ("Argument %qs of elemental procedure at %L must "
492 : "be scalar", sym->name, &sym->declared_at);
493 2 : continue;
494 : }
495 :
496 303589 : if (sym->attr.allocatable
497 303588 : || (sym->ts.type == BT_CLASS && CLASS_DATA (sym)
498 974 : && CLASS_DATA (sym)->attr.allocatable))
499 : {
500 2 : gfc_error ("Argument %qs of elemental procedure at %L cannot "
501 : "have the ALLOCATABLE attribute", sym->name,
502 : &sym->declared_at);
503 2 : continue;
504 : }
505 :
506 303587 : if (sym->attr.pointer
507 303586 : || (sym->ts.type == BT_CLASS && CLASS_DATA (sym)
508 973 : && CLASS_DATA (sym)->attr.class_pointer))
509 : {
510 2 : gfc_error ("Argument %qs of elemental procedure at %L cannot "
511 : "have the POINTER attribute", sym->name,
512 : &sym->declared_at);
513 2 : continue;
514 : }
515 :
516 303585 : if (sym->attr.flavor == FL_PROCEDURE)
517 : {
518 2 : gfc_error ("Dummy procedure %qs not allowed in elemental "
519 : "procedure %qs at %L", sym->name, proc->name,
520 : &sym->declared_at);
521 2 : continue;
522 : }
523 :
524 : /* Fortran 2008 Corrigendum 1, C1290a. */
525 303583 : if (sym->attr.intent == INTENT_UNKNOWN && !sym->attr.value)
526 : {
527 2 : gfc_error ("Argument %qs of elemental procedure %qs at %L must "
528 : "have its INTENT specified or have the VALUE "
529 : "attribute", sym->name, proc->name,
530 : &sym->declared_at);
531 2 : continue;
532 : }
533 : }
534 :
535 : /* Each dummy shall be specified to be scalar. */
536 897691 : if (proc->attr.proc == PROC_ST_FUNCTION)
537 : {
538 307 : if (sym->as != NULL)
539 : {
540 : /* F03:C1263 (R1238) The function-name and each dummy-arg-name
541 : shall be specified, explicitly or implicitly, to be scalar. */
542 1 : gfc_error ("Argument %qs of statement function %qs at %L "
543 : "must be scalar", sym->name, proc->name,
544 : &proc->declared_at);
545 1 : continue;
546 : }
547 :
548 306 : if (sym->ts.type == BT_CHARACTER)
549 : {
550 48 : gfc_charlen *cl = sym->ts.u.cl;
551 48 : if (!cl || !cl->length || cl->length->expr_type != EXPR_CONSTANT)
552 : {
553 0 : gfc_error ("Character-valued argument %qs of statement "
554 : "function at %L must have constant length",
555 : sym->name, &sym->declared_at);
556 0 : continue;
557 : }
558 : }
559 : }
560 : }
561 566558 : if (sym)
562 566466 : sym->formal_resolved = 1;
563 566558 : gfc_current_ns = orig_current_ns;
564 566558 : }
565 :
566 :
567 : /* Work function called when searching for symbols that have argument lists
568 : associated with them. */
569 :
570 : static void
571 1959302 : find_arglists (gfc_symbol *sym)
572 : {
573 1959302 : if (sym->attr.if_source == IFSRC_UNKNOWN || sym->ns != gfc_current_ns
574 356843 : || gfc_fl_struct (sym->attr.flavor) || sym->attr.intrinsic)
575 : return;
576 :
577 354008 : gfc_resolve_formal_arglist (sym);
578 : }
579 :
580 :
581 : /* Given a namespace, resolve all formal argument lists within the namespace.
582 : */
583 :
584 : static void
585 370654 : resolve_formal_arglists (gfc_namespace *ns)
586 : {
587 0 : if (ns == NULL)
588 : return;
589 :
590 370654 : gfc_traverse_ns (ns, find_arglists);
591 : }
592 :
593 :
594 : static void
595 39008 : resolve_contained_fntype (gfc_symbol *sym, gfc_namespace *ns)
596 : {
597 39008 : bool t;
598 :
599 39008 : if (sym && sym->attr.flavor == FL_PROCEDURE
600 39008 : && sym->ns->parent
601 1494 : && sym->ns->parent->proc_name
602 1494 : && sym->ns->parent->proc_name->attr.flavor == FL_PROCEDURE
603 0 : && !strcmp (sym->name, sym->ns->parent->proc_name->name))
604 0 : gfc_error ("Contained procedure %qs at %L has the same name as its "
605 : "encompassing procedure", sym->name, &sym->declared_at);
606 :
607 : /* If this namespace is not a function or an entry master function,
608 : ignore it. */
609 39008 : if (! sym || !(sym->attr.function || sym->attr.flavor == FL_VARIABLE)
610 11453 : || sym->attr.entry_master)
611 : return;
612 :
613 11264 : if (!sym->result)
614 : return;
615 :
616 : /* Try to find out of what the return type is. */
617 11264 : if (sym->result->ts.type == BT_UNKNOWN && sym->result->ts.interface == NULL)
618 : {
619 58 : t = gfc_set_default_type (sym->result, 0, ns);
620 :
621 58 : if (!t && !sym->result->attr.untyped)
622 : {
623 19 : if (sym->result == sym)
624 1 : gfc_error ("Contained function %qs at %L has no IMPLICIT type",
625 : sym->name, &sym->declared_at);
626 18 : else if (!sym->result->attr.proc_pointer)
627 0 : gfc_error ("Result %qs of contained function %qs at %L has "
628 : "no IMPLICIT type", sym->result->name, sym->name,
629 : &sym->result->declared_at);
630 19 : sym->result->attr.untyped = 1;
631 : }
632 : }
633 :
634 : /* Fortran 2008 Draft Standard, page 535, C418, on type-param-value
635 : type, lists the only ways a character length value of * can be used:
636 : dummy arguments of procedures, named constants, function results and
637 : in allocate statements if the allocate_object is an assumed length dummy
638 : in external functions. Internal function results and results of module
639 : procedures are not on this list, ergo, not permitted. */
640 :
641 11264 : if (sym->result->ts.type == BT_CHARACTER)
642 : {
643 1247 : gfc_charlen *cl = sym->result->ts.u.cl;
644 1247 : if ((!cl || !cl->length) && !sym->result->ts.deferred)
645 : {
646 : /* See if this is a module-procedure and adapt error message
647 : accordingly. */
648 4 : bool module_proc;
649 4 : gcc_assert (ns->parent && ns->parent->proc_name);
650 4 : module_proc = (ns->parent->proc_name->attr.flavor == FL_MODULE);
651 :
652 7 : gfc_error (module_proc
653 : ? G_("Character-valued module procedure %qs at %L"
654 : " must not be assumed length")
655 : : G_("Character-valued internal function %qs at %L"
656 : " must not be assumed length"),
657 : sym->name, &sym->declared_at);
658 : }
659 : }
660 : }
661 :
662 :
663 : /* Add NEW_ARGS to the formal argument list of PROC, taking care not to
664 : introduce duplicates. */
665 :
666 : static void
667 1491 : merge_argument_lists (gfc_symbol *proc, gfc_formal_arglist *new_args)
668 : {
669 1491 : gfc_formal_arglist *f, *new_arglist;
670 1491 : gfc_symbol *new_sym;
671 :
672 2644 : for (; new_args != NULL; new_args = new_args->next)
673 : {
674 1153 : new_sym = new_args->sym;
675 : /* See if this arg is already in the formal argument list. */
676 2186 : for (f = proc->formal; f; f = f->next)
677 : {
678 1481 : if (new_sym == f->sym)
679 : break;
680 : }
681 :
682 1153 : if (f)
683 448 : continue;
684 :
685 : /* Add a new argument. Argument order is not important. */
686 705 : new_arglist = gfc_get_formal_arglist ();
687 705 : new_arglist->sym = new_sym;
688 705 : new_arglist->next = proc->formal;
689 705 : proc->formal = new_arglist;
690 : }
691 1491 : }
692 :
693 :
694 : /* Flag the arguments that are not present in all entries. */
695 :
696 : static void
697 1491 : check_argument_lists (gfc_symbol *proc, gfc_formal_arglist *new_args)
698 : {
699 1491 : gfc_formal_arglist *f, *head;
700 1491 : head = new_args;
701 :
702 3086 : for (f = proc->formal; f; f = f->next)
703 : {
704 1595 : if (f->sym == NULL)
705 36 : continue;
706 :
707 2738 : for (new_args = head; new_args; new_args = new_args->next)
708 : {
709 2287 : if (new_args->sym == f->sym)
710 : break;
711 : }
712 :
713 1559 : if (new_args)
714 1108 : continue;
715 :
716 451 : f->sym->attr.not_always_present = 1;
717 : }
718 1491 : }
719 :
720 :
721 : /* Resolve alternate entry points. If a symbol has multiple entry points we
722 : create a new master symbol for the main routine, and turn the existing
723 : symbol into an entry point. */
724 :
725 : static void
726 409155 : resolve_entries (gfc_namespace *ns)
727 : {
728 409155 : gfc_namespace *old_ns;
729 409155 : gfc_code *c;
730 409155 : gfc_symbol *proc;
731 409155 : gfc_entry_list *el;
732 : /* Provide sufficient space to hold "master.%d.%s". */
733 409155 : char name[GFC_MAX_SYMBOL_LEN + 1 + 18];
734 409155 : static int master_count = 0;
735 :
736 409155 : if (ns->proc_name == NULL)
737 408452 : return;
738 :
739 : /* No need to do anything if this procedure doesn't have alternate entry
740 : points. */
741 409106 : if (!ns->entries)
742 : return;
743 :
744 : /* We may already have resolved alternate entry points. */
745 954 : if (ns->proc_name->attr.entry_master)
746 : return;
747 :
748 : /* If this isn't a procedure something has gone horribly wrong. */
749 703 : gcc_assert (ns->proc_name->attr.flavor == FL_PROCEDURE);
750 :
751 : /* Remember the current namespace. */
752 703 : old_ns = gfc_current_ns;
753 :
754 703 : gfc_current_ns = ns;
755 :
756 : /* Add the main entry point to the list of entry points. */
757 703 : el = gfc_get_entry_list ();
758 703 : el->sym = ns->proc_name;
759 703 : el->id = 0;
760 703 : el->next = ns->entries;
761 703 : ns->entries = el;
762 703 : ns->proc_name->attr.entry = 1;
763 :
764 : /* If it is a module function, it needs to be in the right namespace
765 : so that gfc_get_fake_result_decl can gather up the results. The
766 : need for this arose in get_proc_name, where these beasts were
767 : left in their own namespace, to keep prior references linked to
768 : the entry declaration.*/
769 703 : if (ns->proc_name->attr.function
770 596 : && ns->parent && ns->parent->proc_name->attr.flavor == FL_MODULE)
771 189 : el->sym->ns = ns;
772 :
773 : /* Do the same for entries where the master is not a module
774 : procedure. These are retained in the module namespace because
775 : of the module procedure declaration. */
776 1491 : for (el = el->next; el; el = el->next)
777 788 : if (el->sym->ns->proc_name->attr.flavor == FL_MODULE
778 0 : && el->sym->attr.mod_proc)
779 0 : el->sym->ns = ns;
780 703 : el = ns->entries;
781 :
782 : /* Add an entry statement for it. */
783 703 : c = gfc_get_code (EXEC_ENTRY);
784 703 : c->ext.entry = el;
785 703 : c->next = ns->code;
786 703 : ns->code = c;
787 :
788 : /* Create a new symbol for the master function. */
789 : /* Give the internal function a unique name (within this file).
790 : Also include the function name so the user has some hope of figuring
791 : out what is going on. */
792 703 : snprintf (name, GFC_MAX_SYMBOL_LEN, "master.%d.%s",
793 703 : master_count++, ns->proc_name->name);
794 703 : gfc_get_ha_symbol (name, &proc);
795 703 : gcc_assert (proc != NULL);
796 :
797 703 : gfc_add_procedure (&proc->attr, PROC_INTERNAL, proc->name, NULL);
798 703 : if (ns->proc_name->attr.subroutine)
799 107 : gfc_add_subroutine (&proc->attr, proc->name, NULL);
800 : else
801 : {
802 596 : gfc_symbol *sym;
803 596 : gfc_typespec *ts, *fts;
804 596 : gfc_array_spec *as, *fas;
805 596 : gfc_add_function (&proc->attr, proc->name, NULL);
806 596 : proc->result = proc;
807 596 : fas = ns->entries->sym->as;
808 596 : fas = fas ? fas : ns->entries->sym->result->as;
809 596 : fts = &ns->entries->sym->result->ts;
810 596 : if (fts->type == BT_UNKNOWN)
811 51 : fts = gfc_get_default_type (ns->entries->sym->result->name, NULL);
812 1120 : for (el = ns->entries->next; el; el = el->next)
813 : {
814 635 : ts = &el->sym->result->ts;
815 635 : as = el->sym->as;
816 635 : as = as ? as : el->sym->result->as;
817 635 : if (ts->type == BT_UNKNOWN)
818 61 : ts = gfc_get_default_type (el->sym->result->name, NULL);
819 :
820 635 : if (! gfc_compare_types (ts, fts)
821 527 : || (el->sym->result->attr.dimension
822 527 : != ns->entries->sym->result->attr.dimension)
823 635 : || (el->sym->result->attr.pointer
824 527 : != ns->entries->sym->result->attr.pointer))
825 : break;
826 65 : else if (as && fas && ns->entries->sym->result != el->sym->result
827 589 : && gfc_compare_array_spec (as, fas) == 0)
828 5 : gfc_error ("Function %s at %L has entries with mismatched "
829 : "array specifications", ns->entries->sym->name,
830 5 : &ns->entries->sym->declared_at);
831 : /* The characteristics need to match and thus both need to have
832 : the same string length, i.e. both len=*, or both len=4.
833 : Having both len=<variable> is also possible, but difficult to
834 : check at compile time. */
835 522 : else if (ts->type == BT_CHARACTER
836 113 : && (el->sym->result->attr.allocatable
837 113 : != ns->entries->sym->result->attr.allocatable))
838 : {
839 3 : gfc_error ("Function %s at %L has entry %s with mismatched "
840 : "characteristics", ns->entries->sym->name,
841 : &ns->entries->sym->declared_at, el->sym->name);
842 3 : goto cleanup;
843 : }
844 519 : else if (ts->type == BT_CHARACTER && ts->u.cl && fts->u.cl
845 110 : && (((ts->u.cl->length && !fts->u.cl->length)
846 109 : ||(!ts->u.cl->length && fts->u.cl->length))
847 90 : || (ts->u.cl->length
848 53 : && ts->u.cl->length->expr_type
849 53 : != fts->u.cl->length->expr_type)
850 90 : || (ts->u.cl->length
851 53 : && ts->u.cl->length->expr_type == EXPR_CONSTANT
852 52 : && mpz_cmp (ts->u.cl->length->value.integer,
853 52 : fts->u.cl->length->value.integer) != 0)))
854 21 : gfc_notify_std (GFC_STD_GNU, "Function %s at %L with "
855 : "entries returning variables of different "
856 : "string lengths", ns->entries->sym->name,
857 21 : &ns->entries->sym->declared_at);
858 498 : else if (el->sym->result->attr.allocatable
859 498 : != ns->entries->sym->result->attr.allocatable)
860 : break;
861 : }
862 :
863 593 : if (el == NULL)
864 : {
865 485 : sym = ns->entries->sym->result;
866 : /* All result types the same. */
867 485 : proc->ts = *fts;
868 485 : if (sym->attr.dimension)
869 63 : gfc_set_array_spec (proc, gfc_copy_array_spec (sym->as), NULL);
870 485 : if (sym->attr.pointer)
871 78 : gfc_add_pointer (&proc->attr, NULL);
872 485 : if (sym->attr.allocatable)
873 24 : gfc_add_allocatable (&proc->attr, NULL);
874 : }
875 : else
876 : {
877 : /* Otherwise the result will be passed through a union by
878 : reference. */
879 108 : proc->attr.mixed_entry_master = 1;
880 346 : for (el = ns->entries; el; el = el->next)
881 : {
882 238 : sym = el->sym->result;
883 238 : if (sym->attr.dimension)
884 : {
885 1 : if (el == ns->entries)
886 0 : gfc_error ("FUNCTION result %s cannot be an array in "
887 : "FUNCTION %s at %L", sym->name,
888 0 : ns->entries->sym->name, &sym->declared_at);
889 : else
890 1 : gfc_error ("ENTRY result %s cannot be an array in "
891 : "FUNCTION %s at %L", sym->name,
892 1 : ns->entries->sym->name, &sym->declared_at);
893 : }
894 237 : else if (sym->attr.pointer)
895 : {
896 1 : if (el == ns->entries)
897 1 : gfc_error ("FUNCTION result %s cannot be a POINTER in "
898 : "FUNCTION %s at %L", sym->name,
899 1 : ns->entries->sym->name, &sym->declared_at);
900 : else
901 0 : gfc_error ("ENTRY result %s cannot be a POINTER in "
902 : "FUNCTION %s at %L", sym->name,
903 0 : ns->entries->sym->name, &sym->declared_at);
904 : }
905 236 : else if (sym->attr.allocatable)
906 : {
907 0 : if (el == ns->entries)
908 0 : gfc_error ("FUNCTION result %s cannot be ALLOCATABLE in "
909 : "FUNCTION %s at %L", sym->name,
910 0 : ns->entries->sym->name, &sym->declared_at);
911 : else
912 0 : gfc_error ("ENTRY result %s cannot be ALLOCATABLE in "
913 : "FUNCTION %s at %L", sym->name,
914 0 : ns->entries->sym->name, &sym->declared_at);
915 : }
916 : else
917 : {
918 236 : ts = &sym->ts;
919 236 : if (ts->type == BT_UNKNOWN)
920 9 : ts = gfc_get_default_type (sym->name, NULL);
921 236 : switch (ts->type)
922 : {
923 85 : case BT_INTEGER:
924 85 : if (ts->kind == gfc_default_integer_kind)
925 : sym = NULL;
926 : break;
927 100 : case BT_REAL:
928 100 : if (ts->kind == gfc_default_real_kind
929 18 : || ts->kind == gfc_default_double_kind)
930 : sym = NULL;
931 : break;
932 20 : case BT_COMPLEX:
933 20 : if (ts->kind == gfc_default_complex_kind)
934 : sym = NULL;
935 : break;
936 28 : case BT_LOGICAL:
937 28 : if (ts->kind == gfc_default_logical_kind)
938 : sym = NULL;
939 : break;
940 : case BT_UNKNOWN:
941 : /* We will issue error elsewhere. */
942 : sym = NULL;
943 : break;
944 : default:
945 : break;
946 : }
947 3 : if (sym)
948 : {
949 3 : if (el == ns->entries)
950 1 : gfc_error ("FUNCTION result %s cannot be of type %s "
951 : "in FUNCTION %s at %L", sym->name,
952 1 : gfc_typename (ts), ns->entries->sym->name,
953 : &sym->declared_at);
954 : else
955 2 : gfc_error ("ENTRY result %s cannot be of type %s "
956 : "in FUNCTION %s at %L", sym->name,
957 2 : gfc_typename (ts), ns->entries->sym->name,
958 : &sym->declared_at);
959 : }
960 : }
961 : }
962 : }
963 : }
964 :
965 108 : cleanup:
966 703 : proc->attr.access = ACCESS_PRIVATE;
967 703 : proc->attr.entry_master = 1;
968 :
969 : /* Merge all the entry point arguments. */
970 2194 : for (el = ns->entries; el; el = el->next)
971 1491 : merge_argument_lists (proc, el->sym->formal);
972 :
973 : /* Check the master formal arguments for any that are not
974 : present in all entry points. */
975 2194 : for (el = ns->entries; el; el = el->next)
976 1491 : check_argument_lists (proc, el->sym->formal);
977 :
978 : /* Use the master function for the function body. */
979 703 : ns->proc_name = proc;
980 :
981 : /* Finalize the new symbols. */
982 703 : gfc_commit_symbols ();
983 :
984 : /* Restore the original namespace. */
985 703 : gfc_current_ns = old_ns;
986 : }
987 :
988 :
989 : /* Forward declaration. */
990 : static bool is_non_constant_shape_array (gfc_symbol *sym);
991 :
992 :
993 : /* Resolve common variables. */
994 : static void
995 372632 : resolve_common_vars (gfc_common_head *common_block, bool named_common)
996 : {
997 372632 : gfc_symbol *csym = common_block->head;
998 372632 : gfc_gsymbol *gsym;
999 :
1000 378685 : for (; csym; csym = csym->common_next)
1001 : {
1002 6053 : gsym = gfc_find_gsymbol (gfc_gsym_root, csym->name);
1003 6053 : if (gsym && (gsym->type == GSYM_MODULE || gsym->type == GSYM_PROGRAM))
1004 : {
1005 3 : if (csym->common_block)
1006 2 : gfc_error_now ("Global entity %qs at %L cannot appear in a "
1007 : "COMMON block at %L", gsym->name,
1008 : &gsym->where, &csym->common_block->where);
1009 : else
1010 1 : gfc_error_now ("Global entity %qs at %L cannot appear in a "
1011 : "COMMON block", gsym->name, &gsym->where);
1012 : }
1013 :
1014 : /* gfc_add_in_common may have been called before, but the reported errors
1015 : have been ignored to continue parsing.
1016 : We do the checks again here, unless the symbol is USE associated. */
1017 6053 : if (!csym->attr.use_assoc && !csym->attr.used_in_submodule)
1018 : {
1019 5780 : gfc_add_in_common (&csym->attr, csym->name, &common_block->where);
1020 5780 : gfc_notify_std (GFC_STD_F2018_OBS, "COMMON block at %L",
1021 : &common_block->where);
1022 : }
1023 :
1024 6053 : if (csym->value || csym->attr.data)
1025 : {
1026 149 : if (!csym->ns->is_block_data)
1027 33 : gfc_notify_std (GFC_STD_GNU, "Variable %qs at %L is in COMMON "
1028 : "but only in BLOCK DATA initialization is "
1029 : "allowed", csym->name, &csym->declared_at);
1030 116 : else if (!named_common)
1031 8 : gfc_notify_std (GFC_STD_GNU, "Initialized variable %qs at %L is "
1032 : "in a blank COMMON but initialization is only "
1033 : "allowed in named common blocks", csym->name,
1034 : &csym->declared_at);
1035 : }
1036 :
1037 6053 : if (UNLIMITED_POLY (csym))
1038 1 : gfc_error_now ("%qs at %L cannot appear in COMMON "
1039 : "[F2008:C5100]", csym->name, &csym->declared_at);
1040 :
1041 6053 : if (csym->attr.dimension && is_non_constant_shape_array (csym))
1042 : {
1043 1 : gfc_error_now ("Automatic object %qs at %L cannot appear in "
1044 : "COMMON at %L", csym->name, &csym->declared_at,
1045 : &common_block->where);
1046 : /* Avoid confusing follow-on error. */
1047 1 : csym->error = 1;
1048 : }
1049 :
1050 6053 : if (csym->ts.type != BT_DERIVED)
1051 6006 : continue;
1052 :
1053 47 : if (!(csym->ts.u.derived->attr.sequence
1054 3 : || csym->ts.u.derived->attr.is_bind_c))
1055 2 : gfc_error_now ("Derived type variable %qs in COMMON at %L "
1056 : "has neither the SEQUENCE nor the BIND(C) "
1057 : "attribute", csym->name, &csym->declared_at);
1058 47 : if (csym->ts.u.derived->attr.alloc_comp)
1059 3 : gfc_error_now ("Derived type variable %qs in COMMON at %L "
1060 : "has an ultimate component that is "
1061 : "allocatable", csym->name, &csym->declared_at);
1062 47 : if (gfc_has_default_initializer (csym->ts.u.derived))
1063 2 : gfc_error_now ("Derived type variable %qs in COMMON at %L "
1064 : "may not have default initializer", csym->name,
1065 : &csym->declared_at);
1066 :
1067 47 : if (csym->attr.flavor == FL_UNKNOWN && !csym->attr.proc_pointer)
1068 16 : gfc_add_flavor (&csym->attr, FL_VARIABLE, csym->name, &csym->declared_at);
1069 : }
1070 372632 : }
1071 :
1072 : /* Resolve common blocks. */
1073 : static void
1074 371185 : resolve_common_blocks (gfc_symtree *common_root)
1075 : {
1076 371185 : gfc_symbol *sym = NULL;
1077 371185 : gfc_gsymbol * gsym;
1078 :
1079 371185 : if (common_root == NULL)
1080 371063 : return;
1081 :
1082 1978 : if (common_root->left)
1083 257 : resolve_common_blocks (common_root->left);
1084 1978 : if (common_root->right)
1085 274 : resolve_common_blocks (common_root->right);
1086 :
1087 1978 : resolve_common_vars (common_root->n.common, true);
1088 :
1089 : /* The common name is a global name - in Fortran 2003 also if it has a
1090 : C binding name, since Fortran 2008 only the C binding name is a global
1091 : identifier. */
1092 1978 : if (!common_root->n.common->binding_label
1093 1978 : || gfc_notification_std (GFC_STD_F2008))
1094 : {
1095 3812 : gsym = gfc_find_gsymbol (gfc_gsym_root,
1096 1906 : common_root->n.common->name);
1097 :
1098 820 : if (gsym && gfc_notification_std (GFC_STD_F2008)
1099 14 : && gsym->type == GSYM_COMMON
1100 1919 : && ((common_root->n.common->binding_label
1101 6 : && (!gsym->binding_label
1102 0 : || strcmp (common_root->n.common->binding_label,
1103 : gsym->binding_label) != 0))
1104 7 : || (!common_root->n.common->binding_label
1105 7 : && gsym->binding_label)))
1106 : {
1107 6 : gfc_error ("In Fortran 2003 COMMON %qs block at %L is a global "
1108 : "identifier and must thus have the same binding name "
1109 : "as the same-named COMMON block at %L: %s vs %s",
1110 6 : common_root->n.common->name, &common_root->n.common->where,
1111 : &gsym->where,
1112 : common_root->n.common->binding_label
1113 : ? common_root->n.common->binding_label : "(blank)",
1114 6 : gsym->binding_label ? gsym->binding_label : "(blank)");
1115 6 : return;
1116 : }
1117 :
1118 1900 : if (gsym && gsym->type != GSYM_COMMON
1119 1 : && !common_root->n.common->binding_label)
1120 : {
1121 0 : gfc_error ("COMMON block %qs at %L uses the same global identifier "
1122 : "as entity at %L",
1123 0 : common_root->n.common->name, &common_root->n.common->where,
1124 : &gsym->where);
1125 0 : return;
1126 : }
1127 814 : if (gsym && gsym->type != GSYM_COMMON)
1128 : {
1129 1 : gfc_error ("Fortran 2008: COMMON block %qs with binding label at "
1130 : "%L sharing the identifier with global non-COMMON-block "
1131 1 : "entity at %L", common_root->n.common->name,
1132 1 : &common_root->n.common->where, &gsym->where);
1133 1 : return;
1134 : }
1135 1086 : if (!gsym)
1136 : {
1137 1086 : gsym = gfc_get_gsymbol (common_root->n.common->name, false);
1138 1086 : gsym->type = GSYM_COMMON;
1139 1086 : gsym->where = common_root->n.common->where;
1140 1086 : gsym->defined = 1;
1141 : }
1142 1899 : gsym->used = 1;
1143 : }
1144 :
1145 1971 : if (common_root->n.common->binding_label)
1146 : {
1147 76 : gsym = gfc_find_gsymbol (gfc_gsym_root,
1148 : common_root->n.common->binding_label);
1149 76 : if (gsym && gsym->type != GSYM_COMMON)
1150 : {
1151 1 : gfc_error ("COMMON block at %L with binding label %qs uses the same "
1152 : "global identifier as entity at %L",
1153 : &common_root->n.common->where,
1154 1 : common_root->n.common->binding_label, &gsym->where);
1155 1 : return;
1156 : }
1157 57 : if (!gsym)
1158 : {
1159 57 : gsym = gfc_get_gsymbol (common_root->n.common->binding_label, true);
1160 57 : gsym->type = GSYM_COMMON;
1161 57 : gsym->where = common_root->n.common->where;
1162 57 : gsym->defined = 1;
1163 : }
1164 75 : gsym->used = 1;
1165 : }
1166 :
1167 1970 : gfc_find_symbol (common_root->name, gfc_current_ns, 0, &sym);
1168 1970 : if (sym == NULL)
1169 : return;
1170 :
1171 122 : if (sym->attr.flavor == FL_PARAMETER)
1172 2 : gfc_error ("COMMON block %qs at %L is used as PARAMETER at %L",
1173 2 : sym->name, &common_root->n.common->where, &sym->declared_at);
1174 :
1175 122 : if (sym->attr.external)
1176 1 : gfc_error ("COMMON block %qs at %L cannot have the EXTERNAL attribute",
1177 1 : sym->name, &common_root->n.common->where);
1178 :
1179 122 : if (sym->attr.intrinsic)
1180 2 : gfc_error ("COMMON block %qs at %L is also an intrinsic procedure",
1181 2 : sym->name, &common_root->n.common->where);
1182 120 : else if (sym->attr.result
1183 120 : || gfc_is_function_return_value (sym, gfc_current_ns))
1184 1 : gfc_notify_std (GFC_STD_F2003, "COMMON block %qs at %L "
1185 : "that is also a function result", sym->name,
1186 1 : &common_root->n.common->where);
1187 119 : else if (sym->attr.flavor == FL_PROCEDURE && sym->attr.proc != PROC_INTERNAL
1188 5 : && sym->attr.proc != PROC_ST_FUNCTION)
1189 3 : gfc_notify_std (GFC_STD_F2003, "COMMON block %qs at %L "
1190 : "that is also a global procedure", sym->name,
1191 3 : &common_root->n.common->where);
1192 : }
1193 :
1194 :
1195 : /* Resolve contained function types. Because contained functions can call one
1196 : another, they have to be worked out before any of the contained procedures
1197 : can be resolved.
1198 :
1199 : The good news is that if a function doesn't already have a type, the only
1200 : way it can get one is through an IMPLICIT type or a RESULT variable, because
1201 : by definition contained functions are contained namespace they're contained
1202 : in, not in a sibling or parent namespace. */
1203 :
1204 : static void
1205 370654 : resolve_contained_functions (gfc_namespace *ns)
1206 : {
1207 370654 : gfc_namespace *child;
1208 370654 : gfc_entry_list *el;
1209 :
1210 370654 : resolve_formal_arglists (ns);
1211 :
1212 409155 : for (child = ns->contained; child; child = child->sibling)
1213 : {
1214 : /* Resolve alternate entry points first. */
1215 38501 : resolve_entries (child);
1216 :
1217 : /* Then check function return types. */
1218 38501 : resolve_contained_fntype (child->proc_name, child);
1219 39008 : for (el = child->entries; el; el = el->next)
1220 507 : resolve_contained_fntype (el->sym, child);
1221 : }
1222 370654 : }
1223 :
1224 :
1225 :
1226 : /* A Parameterized Derived Type constructor must contain values for
1227 : the PDT KIND parameters or they must have a default initializer.
1228 : Go through the constructor picking out the KIND expressions,
1229 : storing them in 'param_list' and then call gfc_get_pdt_instance
1230 : to obtain the PDT instance. */
1231 :
1232 : static gfc_actual_arglist *param_list, *param_tail, *param;
1233 :
1234 : static bool
1235 452 : get_pdt_spec_expr (gfc_component *c, gfc_expr *expr)
1236 : {
1237 452 : param = gfc_get_actual_arglist ();
1238 452 : if (!param_list)
1239 342 : param_list = param_tail = param;
1240 : else
1241 : {
1242 110 : param_tail->next = param;
1243 110 : param_tail = param_tail->next;
1244 : }
1245 :
1246 452 : param_tail->name = c->name;
1247 452 : if (expr)
1248 452 : param_tail->expr = gfc_copy_expr (expr);
1249 0 : else if (c->initializer)
1250 0 : param_tail->expr = gfc_copy_expr (c->initializer);
1251 : else
1252 : {
1253 0 : param_tail->spec_type = SPEC_ASSUMED;
1254 0 : if (c->attr.pdt_kind)
1255 : {
1256 0 : gfc_error ("The KIND parameter %qs in the PDT constructor "
1257 : "at %C has no value", param->name);
1258 0 : return false;
1259 : }
1260 : }
1261 :
1262 : return true;
1263 : }
1264 :
1265 : static bool
1266 390 : get_pdt_constructor (gfc_expr *expr, gfc_constructor **constr,
1267 : gfc_symbol *derived)
1268 : {
1269 390 : gfc_constructor *cons = NULL;
1270 390 : gfc_component *comp;
1271 390 : bool t = true;
1272 :
1273 390 : if (expr && expr->expr_type == EXPR_STRUCTURE)
1274 354 : cons = gfc_constructor_first (expr->value.constructor);
1275 36 : else if (constr)
1276 36 : cons = *constr;
1277 390 : gcc_assert (cons);
1278 :
1279 390 : comp = derived->components;
1280 :
1281 1240 : for (; comp && cons; comp = comp->next, cons = gfc_constructor_next (cons))
1282 : {
1283 850 : if (cons->expr
1284 850 : && cons->expr->expr_type == EXPR_STRUCTURE
1285 12 : && comp->ts.type == BT_DERIVED)
1286 : {
1287 12 : t = get_pdt_constructor (cons->expr, NULL, comp->ts.u.derived);
1288 12 : if (!t)
1289 : return t;
1290 : }
1291 838 : else if (comp->ts.type == BT_DERIVED)
1292 : {
1293 36 : t = get_pdt_constructor (NULL, &cons, comp->ts.u.derived);
1294 36 : if (!t)
1295 : return t;
1296 : }
1297 802 : else if ((comp->attr.pdt_kind || comp->attr.pdt_len)
1298 452 : && derived->attr.pdt_template)
1299 : {
1300 452 : t = get_pdt_spec_expr (comp, cons->expr);
1301 452 : if (!t)
1302 : return t;
1303 : }
1304 : }
1305 : return t;
1306 : }
1307 :
1308 :
1309 : static bool resolve_fl_derived0 (gfc_symbol *sym);
1310 : static bool resolve_fl_struct (gfc_symbol *sym);
1311 :
1312 :
1313 : /* Resolve all of the elements of a structure constructor and make sure that
1314 : the types are correct. The 'init' flag indicates that the given
1315 : constructor is an initializer. */
1316 :
1317 : static bool
1318 67028 : resolve_structure_cons (gfc_expr *expr, int init)
1319 : {
1320 67028 : gfc_constructor *cons;
1321 67028 : gfc_component *comp;
1322 67028 : bool t;
1323 67028 : symbol_attribute a;
1324 :
1325 67028 : t = true;
1326 :
1327 67028 : if (expr->ts.type == BT_DERIVED || expr->ts.type == BT_UNION)
1328 : {
1329 63886 : if (expr->ts.u.derived->attr.flavor == FL_DERIVED)
1330 63736 : resolve_fl_derived0 (expr->ts.u.derived);
1331 : else
1332 150 : resolve_fl_struct (expr->ts.u.derived);
1333 :
1334 : /* If this is a Parameterized Derived Type template, find the
1335 : instance corresponding to the PDT kind parameters. */
1336 63886 : if (expr->ts.u.derived->attr.pdt_template)
1337 : {
1338 342 : param_list = NULL;
1339 342 : t = get_pdt_constructor (expr, NULL, expr->ts.u.derived);
1340 342 : if (!t)
1341 : return t;
1342 342 : gfc_get_pdt_instance (param_list, &expr->ts.u.derived, NULL);
1343 :
1344 342 : expr->param_list = gfc_copy_actual_arglist (param_list);
1345 :
1346 342 : if (param_list)
1347 342 : gfc_free_actual_arglist (param_list);
1348 :
1349 342 : if (!expr->ts.u.derived->attr.pdt_type)
1350 : return false;
1351 : }
1352 : }
1353 :
1354 : /* A constructor may have references if it is the result of substituting a
1355 : parameter variable. In this case we just pull out the component we
1356 : want. */
1357 67028 : if (expr->ref)
1358 166 : comp = expr->ref->u.c.sym->components;
1359 66862 : else if ((expr->ts.type == BT_DERIVED || expr->ts.type == BT_CLASS
1360 : || expr->ts.type == BT_UNION)
1361 66860 : && expr->ts.u.derived)
1362 66860 : comp = expr->ts.u.derived->components;
1363 : else
1364 : return false;
1365 :
1366 67026 : cons = gfc_constructor_first (expr->value.constructor);
1367 :
1368 293061 : for (; comp && cons; comp = comp->next, cons = gfc_constructor_next (cons))
1369 : {
1370 159011 : int rank;
1371 :
1372 159011 : if (!cons->expr)
1373 10954 : continue;
1374 :
1375 : /* Unions use an EXPR_NULL contrived expression to tell the translation
1376 : phase to generate an initializer of the appropriate length.
1377 : Ignore it here. */
1378 148057 : if (cons->expr->ts.type == BT_UNION && cons->expr->expr_type == EXPR_NULL)
1379 15 : continue;
1380 :
1381 148042 : if (!gfc_resolve_expr (cons->expr))
1382 : {
1383 0 : t = false;
1384 0 : continue;
1385 : }
1386 :
1387 148042 : rank = comp->as ? comp->as->rank : 0;
1388 148042 : if (comp->ts.type == BT_CLASS
1389 2049 : && !comp->ts.u.derived->attr.unlimited_polymorphic
1390 2048 : && CLASS_DATA (comp)->as)
1391 683 : rank = CLASS_DATA (comp)->as->rank;
1392 :
1393 148042 : if (comp->ts.type == BT_CLASS && cons->expr->ts.type != BT_CLASS)
1394 276 : gfc_find_vtab (&cons->expr->ts);
1395 :
1396 148042 : if (cons->expr->expr_type != EXPR_NULL && rank != cons->expr->rank
1397 1018 : && (comp->attr.allocatable || comp->attr.pointer || cons->expr->rank))
1398 : {
1399 4 : gfc_error ("The rank of the element in the structure "
1400 : "constructor at %L does not match that of the "
1401 : "component (%d/%d)", &cons->expr->where,
1402 : cons->expr->rank, rank);
1403 4 : t = false;
1404 : }
1405 :
1406 : /* If we don't have the right type, try to convert it. */
1407 :
1408 258754 : if (!comp->attr.proc_pointer &&
1409 110712 : !gfc_compare_types (&cons->expr->ts, &comp->ts))
1410 : {
1411 13478 : if (strcmp (comp->name, "_extends") == 0)
1412 : {
1413 : /* Can afford to be brutal with the _extends initializer.
1414 : The derived type can get lost because it is PRIVATE
1415 : but it is not usage constrained by the standard. */
1416 9921 : cons->expr->ts = comp->ts;
1417 : }
1418 3557 : else if (comp->attr.pointer && cons->expr->ts.type != BT_UNKNOWN)
1419 : {
1420 2 : gfc_error ("The element in the structure constructor at %L, "
1421 : "for pointer component %qs, is %s but should be %s",
1422 2 : &cons->expr->where, comp->name,
1423 2 : gfc_basic_typename (cons->expr->ts.type),
1424 : gfc_basic_typename (comp->ts.type));
1425 2 : t = false;
1426 : }
1427 3555 : else if (!UNLIMITED_POLY (comp))
1428 : {
1429 3474 : bool t2 = gfc_convert_type (cons->expr, &comp->ts, 1);
1430 3474 : if (t)
1431 148042 : t = t2;
1432 : }
1433 : }
1434 :
1435 : /* For strings, the length of the constructor should be the same as
1436 : the one of the structure, ensure this if the lengths are known at
1437 : compile time and when we are dealing with PARAMETER or structure
1438 : constructors. Skip for PDT types which have type parameters. */
1439 148042 : if (!IS_PDT (expr) && cons->expr->ts.type == BT_CHARACTER
1440 4425 : && comp->ts.type == BT_CHARACTER
1441 4387 : && comp->ts.u.cl && comp->ts.u.cl->length
1442 2998 : && comp->ts.u.cl->length->expr_type == EXPR_CONSTANT
1443 2981 : && cons->expr->ts.u.cl && cons->expr->ts.u.cl->length
1444 1089 : && cons->expr->ts.u.cl->length->expr_type == EXPR_CONSTANT
1445 1089 : && cons->expr->ts.u.cl->length->ts.type == BT_INTEGER
1446 1089 : && comp->ts.u.cl->length->ts.type == BT_INTEGER
1447 1089 : && mpz_cmp (cons->expr->ts.u.cl->length->value.integer,
1448 1089 : comp->ts.u.cl->length->value.integer) != 0)
1449 : {
1450 11 : if (comp->attr.pointer)
1451 : {
1452 3 : HOST_WIDE_INT la, lb;
1453 3 : la = gfc_mpz_get_hwi (comp->ts.u.cl->length->value.integer);
1454 3 : lb = gfc_mpz_get_hwi (cons->expr->ts.u.cl->length->value.integer);
1455 3 : gfc_error ("Unequal character lengths (%wd/%wd) for pointer "
1456 : "component %qs in constructor at %L",
1457 3 : la, lb, comp->name, &cons->expr->where);
1458 3 : t = false;
1459 : }
1460 :
1461 11 : if (cons->expr->expr_type == EXPR_VARIABLE
1462 4 : && cons->expr->rank != 0
1463 2 : && cons->expr->symtree->n.sym->attr.flavor == FL_PARAMETER)
1464 : {
1465 : /* Wrap the parameter in an array constructor (EXPR_ARRAY)
1466 : to make use of the gfc_resolve_character_array_constructor
1467 : machinery. The expression is later simplified away to
1468 : an array of string literals. */
1469 1 : gfc_expr *para = cons->expr;
1470 1 : cons->expr = gfc_get_expr ();
1471 1 : cons->expr->ts = para->ts;
1472 1 : cons->expr->where = para->where;
1473 1 : cons->expr->expr_type = EXPR_ARRAY;
1474 1 : cons->expr->rank = para->rank;
1475 1 : cons->expr->corank = para->corank;
1476 1 : cons->expr->shape = gfc_copy_shape (para->shape, para->rank);
1477 1 : gfc_constructor_append_expr (&cons->expr->value.constructor,
1478 1 : para, &cons->expr->where);
1479 : }
1480 :
1481 11 : if (cons->expr->expr_type == EXPR_ARRAY)
1482 : {
1483 : /* Rely on the cleanup of the namespace to deal correctly with
1484 : the old charlen. (There was a block here that attempted to
1485 : remove the charlen but broke the chain in so doing.) */
1486 5 : cons->expr->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
1487 5 : cons->expr->ts.u.cl->length_from_typespec = true;
1488 5 : cons->expr->ts.u.cl->length = gfc_copy_expr (comp->ts.u.cl->length);
1489 5 : gfc_resolve_character_array_constructor (cons->expr);
1490 : }
1491 : }
1492 :
1493 148042 : if (cons->expr->expr_type == EXPR_NULL
1494 44401 : && !(comp->attr.pointer || comp->attr.allocatable
1495 22293 : || comp->attr.proc_pointer || comp->ts.f90_type == BT_VOID
1496 1342 : || (comp->ts.type == BT_CLASS
1497 1340 : && (CLASS_DATA (comp)->attr.class_pointer
1498 1105 : || CLASS_DATA (comp)->attr.allocatable))))
1499 : {
1500 2 : t = false;
1501 2 : gfc_error ("The NULL in the structure constructor at %L is "
1502 : "being applied to component %qs, which is neither "
1503 : "a POINTER nor ALLOCATABLE", &cons->expr->where,
1504 : comp->name);
1505 : }
1506 :
1507 148042 : if (comp->attr.proc_pointer && comp->ts.interface)
1508 : {
1509 : /* Check procedure pointer interface. */
1510 16756 : gfc_symbol *s2 = NULL;
1511 16756 : gfc_component *c2;
1512 16756 : const char *name;
1513 16756 : char err[200];
1514 :
1515 16756 : c2 = gfc_get_proc_ptr_comp (cons->expr);
1516 16756 : if (c2)
1517 : {
1518 12 : s2 = c2->ts.interface;
1519 12 : name = c2->name;
1520 : }
1521 16744 : else if (cons->expr->expr_type == EXPR_FUNCTION)
1522 : {
1523 0 : s2 = cons->expr->symtree->n.sym->result;
1524 0 : name = cons->expr->symtree->n.sym->result->name;
1525 : }
1526 16744 : else if (cons->expr->expr_type != EXPR_NULL)
1527 : {
1528 16274 : s2 = cons->expr->symtree->n.sym;
1529 16274 : name = cons->expr->symtree->n.sym->name;
1530 : }
1531 :
1532 16286 : if (s2 && !gfc_compare_interfaces (comp->ts.interface, s2, name, 0, 1,
1533 : err, sizeof (err), NULL, NULL))
1534 : {
1535 2 : gfc_error_opt (0, "Interface mismatch for procedure-pointer "
1536 : "component %qs in structure constructor at %L:"
1537 2 : " %s", comp->name, &cons->expr->where, err);
1538 2 : return false;
1539 : }
1540 : }
1541 :
1542 : /* Validate shape, except for dynamic or PDT arrays. */
1543 148040 : if (cons->expr->expr_type == EXPR_ARRAY && rank == cons->expr->rank
1544 2637 : && comp->as && !comp->attr.allocatable && !comp->attr.pointer
1545 1869 : && !comp->attr.pdt_array)
1546 : {
1547 1568 : mpz_t len;
1548 1568 : mpz_init (len);
1549 4815 : for (int n = 0; n < rank; n++)
1550 : {
1551 1684 : if (comp->as->upper[n]->expr_type != EXPR_CONSTANT
1552 1679 : || comp->as->lower[n]->expr_type != EXPR_CONSTANT)
1553 : {
1554 5 : gfc_error ("Bad array spec of component %qs referenced in "
1555 : "structure constructor at %L",
1556 5 : comp->name, &cons->expr->where);
1557 5 : t = false;
1558 5 : break;
1559 1679 : };
1560 1679 : if (cons->expr->shape == NULL)
1561 12 : continue;
1562 1667 : mpz_set_ui (len, 1);
1563 1667 : mpz_add (len, len, comp->as->upper[n]->value.integer);
1564 1667 : mpz_sub (len, len, comp->as->lower[n]->value.integer);
1565 1667 : if (mpz_cmp (cons->expr->shape[n], len) != 0)
1566 : {
1567 9 : gfc_error ("The shape of component %qs in the structure "
1568 : "constructor at %L differs from the shape of the "
1569 : "declared component for dimension %d (%ld/%ld)",
1570 : comp->name, &cons->expr->where, n+1,
1571 : mpz_get_si (cons->expr->shape[n]),
1572 : mpz_get_si (len));
1573 9 : t = false;
1574 : }
1575 : }
1576 1568 : mpz_clear (len);
1577 : }
1578 :
1579 148040 : if (!comp->attr.pointer || comp->attr.proc_pointer
1580 23807 : || cons->expr->expr_type == EXPR_NULL)
1581 137016 : continue;
1582 :
1583 11024 : a = gfc_expr_attr (cons->expr);
1584 :
1585 11024 : if (!a.pointer && !a.target)
1586 : {
1587 1 : t = false;
1588 1 : gfc_error ("The element in the structure constructor at %L, "
1589 : "for pointer component %qs should be a POINTER or "
1590 1 : "a TARGET", &cons->expr->where, comp->name);
1591 : }
1592 :
1593 11024 : if (init)
1594 : {
1595 : /* F08:C461. Additional checks for pointer initialization. */
1596 10953 : if (a.allocatable)
1597 : {
1598 0 : t = false;
1599 0 : gfc_error ("Pointer initialization target at %L "
1600 0 : "must not be ALLOCATABLE", &cons->expr->where);
1601 : }
1602 10953 : if (!a.save)
1603 : {
1604 0 : t = false;
1605 0 : gfc_error ("Pointer initialization target at %L "
1606 0 : "must have the SAVE attribute", &cons->expr->where);
1607 : }
1608 : }
1609 :
1610 : /* F2023:C770: A designator that is an initial-data-target shall ...
1611 : not have a vector subscript. */
1612 11024 : if (comp->attr.pointer && (a.pointer || a.target)
1613 22047 : && gfc_has_vector_index (cons->expr))
1614 : {
1615 1 : gfc_error ("Pointer assignment target at %L has a vector subscript",
1616 1 : &cons->expr->where);
1617 1 : t = false;
1618 : }
1619 :
1620 : /* F2003, C1272 (3). */
1621 11024 : bool impure = cons->expr->expr_type == EXPR_VARIABLE
1622 11024 : && (gfc_impure_variable (cons->expr->symtree->n.sym)
1623 10987 : || gfc_is_coindexed (cons->expr));
1624 34 : if (impure && gfc_pure (NULL))
1625 : {
1626 1 : t = false;
1627 1 : gfc_error ("Invalid expression in the structure constructor for "
1628 : "pointer component %qs at %L in PURE procedure",
1629 1 : comp->name, &cons->expr->where);
1630 : }
1631 :
1632 11024 : if (impure)
1633 34 : gfc_unset_implicit_pure (NULL);
1634 : }
1635 :
1636 : return t;
1637 : }
1638 :
1639 :
1640 : /****************** Expression name resolution ******************/
1641 :
1642 : /* Returns 0 if a symbol was not declared with a type or
1643 : attribute declaration statement, nonzero otherwise. */
1644 :
1645 : static bool
1646 764125 : was_declared (gfc_symbol *sym)
1647 : {
1648 764125 : symbol_attribute a;
1649 :
1650 764125 : a = sym->attr;
1651 :
1652 764125 : if (!a.implicit_type && sym->ts.type != BT_UNKNOWN)
1653 : return 1;
1654 :
1655 647323 : if (a.allocatable || a.dimension || a.dummy || a.external || a.intrinsic
1656 638437 : || a.optional || a.pointer || a.save || a.target || a.volatile_
1657 638435 : || a.value || a.access != ACCESS_UNKNOWN || a.intent != INTENT_UNKNOWN
1658 638381 : || a.asynchronous || a.codimension
1659 638381 : || (a.subroutine && a.proc != PROC_UNKNOWN) || a.result)
1660 68046 : return 1;
1661 :
1662 : return 0;
1663 : }
1664 :
1665 :
1666 : /* Determine if a symbol is generic or not. */
1667 :
1668 : static int
1669 424838 : generic_sym (gfc_symbol *sym)
1670 : {
1671 424838 : gfc_symbol *s;
1672 :
1673 424838 : if (sym->attr.generic ||
1674 394531 : (sym->attr.intrinsic && gfc_generic_intrinsic (sym->name)))
1675 : return 1;
1676 :
1677 393409 : if (was_declared (sym) || sym->ns->parent == NULL)
1678 : return 0;
1679 :
1680 80867 : gfc_find_symbol (sym->name, sym->ns->parent, 1, &s);
1681 :
1682 80867 : if (s != NULL)
1683 : {
1684 163 : if (s == sym)
1685 : return 0;
1686 : else
1687 162 : return generic_sym (s);
1688 : }
1689 :
1690 : return 0;
1691 : }
1692 :
1693 :
1694 : /* Determine if a symbol is specific or not. */
1695 :
1696 : static int
1697 393321 : specific_sym (gfc_symbol *sym)
1698 : {
1699 393321 : gfc_symbol *s;
1700 :
1701 393321 : if (sym->attr.if_source == IFSRC_IFBODY
1702 381727 : || sym->attr.proc == PROC_MODULE
1703 352007 : || sym->attr.proc == PROC_INTERNAL
1704 302900 : || sym->attr.proc == PROC_ST_FUNCTION
1705 302610 : || (sym->attr.intrinsic && gfc_specific_intrinsic (sym->name))
1706 695200 : || sym->attr.external)
1707 : return 1;
1708 :
1709 299466 : if (was_declared (sym) || sym->ns->parent == NULL)
1710 : return 0;
1711 :
1712 80765 : gfc_find_symbol (sym->name, sym->ns->parent, 1, &s);
1713 :
1714 80765 : return (s == NULL) ? 0 : specific_sym (s);
1715 : }
1716 :
1717 :
1718 : /* Figure out if the procedure is specific, generic or unknown. */
1719 :
1720 : enum proc_type
1721 : { PTYPE_GENERIC = 1, PTYPE_SPECIFIC, PTYPE_UNKNOWN };
1722 :
1723 : static proc_type
1724 424521 : procedure_kind (gfc_symbol *sym)
1725 : {
1726 424521 : if (generic_sym (sym))
1727 : return PTYPE_GENERIC;
1728 :
1729 393244 : if (specific_sym (sym))
1730 93855 : return PTYPE_SPECIFIC;
1731 :
1732 : return PTYPE_UNKNOWN;
1733 : }
1734 :
1735 : /* Check references to assumed size arrays. The flag need_full_assumed_size
1736 : is nonzero when matching actual arguments. */
1737 :
1738 : static int need_full_assumed_size = 0;
1739 :
1740 : static bool
1741 1460443 : check_assumed_size_reference (gfc_symbol *sym, gfc_expr *e)
1742 : {
1743 1460443 : if (need_full_assumed_size || !(sym->as && sym->as->type == AS_ASSUMED_SIZE))
1744 : return false;
1745 :
1746 : /* FIXME: The comparison "e->ref->u.ar.type == AR_FULL" is wrong.
1747 : What should it be? */
1748 3832 : if (e->ref
1749 3830 : && e->ref->u.ar.as
1750 3829 : && (e->ref->u.ar.end[e->ref->u.ar.as->rank - 1] == NULL)
1751 3316 : && (e->ref->u.ar.as->type == AS_ASSUMED_SIZE)
1752 3316 : && (e->ref->u.ar.type == AR_FULL))
1753 : {
1754 25 : gfc_error ("The upper bound in the last dimension must "
1755 : "appear in the reference to the assumed size "
1756 : "array %qs at %L", sym->name, &e->where);
1757 25 : return true;
1758 : }
1759 : return false;
1760 : }
1761 :
1762 :
1763 : /* Look for bad assumed size array references in argument expressions
1764 : of elemental and array valued intrinsic procedures. Since this is
1765 : called from procedure resolution functions, it only recurses at
1766 : operators. */
1767 :
1768 : static bool
1769 235539 : resolve_assumed_size_actual (gfc_expr *e)
1770 : {
1771 235539 : if (e == NULL)
1772 : return false;
1773 :
1774 234964 : switch (e->expr_type)
1775 : {
1776 113265 : case EXPR_VARIABLE:
1777 113265 : if (e->symtree && check_assumed_size_reference (e->symtree->n.sym, e))
1778 : return true;
1779 : break;
1780 :
1781 50039 : case EXPR_OP:
1782 50039 : if (resolve_assumed_size_actual (e->value.op.op1)
1783 50039 : || resolve_assumed_size_actual (e->value.op.op2))
1784 0 : return true;
1785 : break;
1786 :
1787 : default:
1788 : break;
1789 : }
1790 : return false;
1791 : }
1792 :
1793 :
1794 : /* Check a generic procedure, passed as an actual argument, to see if
1795 : there is a matching specific name. If none, it is an error, and if
1796 : more than one, the reference is ambiguous. */
1797 : static int
1798 8 : count_specific_procs (gfc_expr *e)
1799 : {
1800 8 : int n;
1801 8 : gfc_interface *p;
1802 8 : gfc_symbol *sym;
1803 :
1804 8 : n = 0;
1805 8 : sym = e->symtree->n.sym;
1806 :
1807 22 : for (p = sym->generic; p; p = p->next)
1808 14 : if (strcmp (sym->name, p->sym->name) == 0)
1809 : {
1810 8 : e->symtree = gfc_find_symtree (p->sym->ns->sym_root,
1811 : sym->name);
1812 8 : n++;
1813 : }
1814 :
1815 8 : if (n > 1)
1816 1 : gfc_error ("%qs at %L is ambiguous", e->symtree->n.sym->name,
1817 : &e->where);
1818 :
1819 8 : if (n == 0)
1820 1 : gfc_error ("GENERIC procedure %qs is not allowed as an actual "
1821 : "argument at %L", sym->name, &e->where);
1822 :
1823 8 : return n;
1824 : }
1825 :
1826 :
1827 : /* See if a call to sym could possibly be a not allowed RECURSION because of
1828 : a missing RECURSIVE declaration. This means that either sym is the current
1829 : context itself, or sym is the parent of a contained procedure calling its
1830 : non-RECURSIVE containing procedure.
1831 : This also works if sym is an ENTRY. */
1832 :
1833 : static bool
1834 156847 : is_illegal_recursion (gfc_symbol* sym, gfc_namespace* context)
1835 : {
1836 156847 : gfc_symbol* proc_sym;
1837 156847 : gfc_symbol* context_proc;
1838 156847 : gfc_namespace* real_context;
1839 :
1840 156847 : if (sym->attr.flavor == FL_PROGRAM
1841 : || gfc_fl_struct (sym->attr.flavor))
1842 : return false;
1843 :
1844 : /* If we've got an ENTRY, find real procedure. */
1845 156846 : if (sym->attr.entry && sym->ns->entries)
1846 45 : proc_sym = sym->ns->entries->sym;
1847 : else
1848 : proc_sym = sym;
1849 :
1850 : /* If sym is RECURSIVE, all is well of course. */
1851 156846 : if (proc_sym->attr.recursive || flag_recursive)
1852 : return false;
1853 :
1854 : /* Find the context procedure's "real" symbol if it has entries.
1855 : We look for a procedure symbol, so recurse on the parents if we don't
1856 : find one (like in case of a BLOCK construct). */
1857 2277 : for (real_context = context; ; real_context = real_context->parent)
1858 : {
1859 : /* We should find something, eventually! */
1860 133256 : gcc_assert (real_context);
1861 :
1862 133256 : context_proc = (real_context->entries ? real_context->entries->sym
1863 : : real_context->proc_name);
1864 :
1865 : /* In some special cases, there may not be a proc_name, like for this
1866 : invalid code:
1867 : real(bad_kind()) function foo () ...
1868 : when checking the call to bad_kind ().
1869 : In these cases, we simply return here and assume that the
1870 : call is ok. */
1871 133256 : if (!context_proc)
1872 : return false;
1873 :
1874 132992 : if (context_proc->attr.flavor != FL_LABEL)
1875 : break;
1876 : }
1877 :
1878 : /* A call from sym's body to itself is recursion, of course. */
1879 130715 : if (context_proc == proc_sym)
1880 : return true;
1881 :
1882 : /* The same is true if context is a contained procedure and sym the
1883 : containing one. */
1884 130700 : if (context_proc->attr.contained)
1885 : {
1886 22025 : gfc_symbol* parent_proc;
1887 :
1888 22025 : gcc_assert (context->parent);
1889 22025 : parent_proc = (context->parent->entries ? context->parent->entries->sym
1890 : : context->parent->proc_name);
1891 :
1892 22025 : if (parent_proc == proc_sym)
1893 9 : return true;
1894 : }
1895 :
1896 : return false;
1897 : }
1898 :
1899 :
1900 : /* Resolve an intrinsic procedure: Set its function/subroutine attribute,
1901 : its typespec and formal argument list. */
1902 :
1903 : bool
1904 47818 : gfc_resolve_intrinsic (gfc_symbol *sym, locus *loc)
1905 : {
1906 47818 : gfc_intrinsic_sym* isym = NULL;
1907 47818 : const char* symstd;
1908 :
1909 47818 : if (sym->resolve_symbol_called >= 2)
1910 : return true;
1911 :
1912 37745 : sym->resolve_symbol_called = 2;
1913 :
1914 : /* Already resolved. */
1915 37745 : if (sym->from_intmod && sym->ts.type != BT_UNKNOWN)
1916 : return true;
1917 :
1918 : /* We already know this one is an intrinsic, so we don't call
1919 : gfc_is_intrinsic for full checking but rather use gfc_find_function and
1920 : gfc_find_subroutine directly to check whether it is a function or
1921 : subroutine. */
1922 :
1923 29671 : if (sym->intmod_sym_id && sym->attr.subroutine)
1924 : {
1925 12882 : gfc_isym_id id = gfc_isym_id_by_intmod_sym (sym);
1926 12882 : isym = gfc_intrinsic_subroutine_by_id (id);
1927 12882 : }
1928 16789 : else if (sym->intmod_sym_id)
1929 : {
1930 12825 : gfc_isym_id id = gfc_isym_id_by_intmod_sym (sym);
1931 12825 : isym = gfc_intrinsic_function_by_id (id);
1932 : }
1933 3964 : else if (!sym->attr.subroutine)
1934 3877 : isym = gfc_find_function (sym->name);
1935 :
1936 29584 : if (isym && !sym->attr.subroutine)
1937 : {
1938 16657 : if (sym->ts.type != BT_UNKNOWN && warn_surprising
1939 24 : && !sym->attr.implicit_type)
1940 10 : gfc_warning (OPT_Wsurprising,
1941 : "Type specified for intrinsic function %qs at %L is"
1942 : " ignored", sym->name, &sym->declared_at);
1943 :
1944 21382 : if (!sym->attr.function &&
1945 4725 : !gfc_add_function(&sym->attr, sym->name, loc))
1946 : return false;
1947 :
1948 16657 : sym->ts = isym->ts;
1949 : }
1950 13014 : else if (isym || (isym = gfc_find_subroutine (sym->name)))
1951 : {
1952 13011 : if (sym->ts.type != BT_UNKNOWN && !sym->attr.implicit_type)
1953 : {
1954 1 : gfc_error ("Intrinsic subroutine %qs at %L shall not have a type"
1955 : " specifier", sym->name, &sym->declared_at);
1956 1 : return false;
1957 : }
1958 :
1959 13051 : if (!sym->attr.subroutine &&
1960 41 : !gfc_add_subroutine(&sym->attr, sym->name, loc))
1961 : return false;
1962 : }
1963 : else
1964 : {
1965 3 : gfc_error ("%qs declared INTRINSIC at %L does not exist", sym->name,
1966 : &sym->declared_at);
1967 3 : return false;
1968 : }
1969 :
1970 29666 : gfc_copy_formal_args_intr (sym, isym, NULL);
1971 :
1972 29666 : sym->attr.pure = isym->pure;
1973 29666 : sym->attr.elemental = isym->elemental;
1974 :
1975 : /* Check it is actually available in the standard settings. */
1976 29666 : if (!gfc_check_intrinsic_standard (isym, &symstd, false, sym->declared_at))
1977 : {
1978 31 : gfc_error ("The intrinsic %qs declared INTRINSIC at %L is not "
1979 : "available in the current standard settings but %s. Use "
1980 : "an appropriate %<-std=*%> option or enable "
1981 : "%<-fall-intrinsics%> in order to use it.",
1982 : sym->name, &sym->declared_at, symstd);
1983 31 : return false;
1984 : }
1985 :
1986 : return true;
1987 : }
1988 :
1989 :
1990 : /* Resolve a procedure expression, like passing it to a called procedure or as
1991 : RHS for a procedure pointer assignment. */
1992 :
1993 : static bool
1994 1361168 : resolve_procedure_expression (gfc_expr* expr)
1995 : {
1996 1361168 : gfc_symbol* sym;
1997 :
1998 1361168 : if (expr->expr_type != EXPR_VARIABLE)
1999 : return true;
2000 1361151 : gcc_assert (expr->symtree);
2001 :
2002 1361151 : sym = expr->symtree->n.sym;
2003 :
2004 1361151 : if (sym->attr.intrinsic)
2005 1360 : gfc_resolve_intrinsic (sym, &expr->where);
2006 :
2007 1361151 : if (sym->attr.flavor != FL_PROCEDURE
2008 33384 : || (sym->attr.function && sym->result == sym))
2009 : return true;
2010 :
2011 : /* A non-RECURSIVE procedure that is used as procedure expression within its
2012 : own body is in danger of being called recursively. */
2013 18417 : if (is_illegal_recursion (sym, gfc_current_ns))
2014 : {
2015 10 : if (sym->attr.use_assoc && expr->symtree->name[0] == '@')
2016 0 : gfc_warning (0, "Non-RECURSIVE procedure %qs from module %qs is"
2017 : " possibly calling itself recursively in procedure %qs. "
2018 : " Declare it RECURSIVE or use %<-frecursive%>",
2019 0 : sym->name, sym->module, gfc_current_ns->proc_name->name);
2020 : else
2021 10 : gfc_warning (0, "Non-RECURSIVE procedure %qs at %L is possibly calling"
2022 : " itself recursively. Declare it RECURSIVE or use"
2023 : " %<-frecursive%>", sym->name, &expr->where);
2024 : }
2025 :
2026 : return true;
2027 : }
2028 :
2029 :
2030 : /* Check that name is not a derived type. */
2031 :
2032 : static bool
2033 3435 : is_dt_name (const char *name)
2034 : {
2035 3435 : gfc_symbol *dt_list, *dt_first;
2036 :
2037 3435 : dt_list = dt_first = gfc_derived_types;
2038 5889 : for (; dt_list; dt_list = dt_list->dt_next)
2039 : {
2040 3577 : if (strcmp(dt_list->name, name) == 0)
2041 : return true;
2042 3574 : if (dt_first == dt_list->dt_next)
2043 : break;
2044 : }
2045 : return false;
2046 : }
2047 :
2048 :
2049 : /* Resolve an actual argument list. Most of the time, this is just
2050 : resolving the expressions in the list.
2051 : The exception is that we sometimes have to decide whether arguments
2052 : that look like procedure arguments are really simple variable
2053 : references. */
2054 :
2055 : static bool
2056 439773 : resolve_actual_arglist (gfc_actual_arglist *arg, procedure_type ptype,
2057 : bool no_formal_args)
2058 : {
2059 439773 : gfc_symbol *sym = NULL;
2060 439773 : gfc_symtree *parent_st;
2061 439773 : gfc_expr *e;
2062 439773 : gfc_component *comp;
2063 439773 : int save_need_full_assumed_size;
2064 439773 : bool return_value = false;
2065 439773 : bool actual_arg_sav = actual_arg, first_actual_arg_sav = first_actual_arg;
2066 :
2067 439773 : actual_arg = true;
2068 439773 : first_actual_arg = true;
2069 :
2070 1124384 : for (; arg; arg = arg->next)
2071 : {
2072 684712 : e = arg->expr;
2073 684712 : if (e == NULL)
2074 : {
2075 : /* Check the label is a valid branching target. */
2076 2617 : if (arg->label)
2077 : {
2078 236 : if (arg->label->defined == ST_LABEL_UNKNOWN)
2079 : {
2080 0 : gfc_error ("Label %d referenced at %L is never defined",
2081 : arg->label->value, &arg->label->where);
2082 0 : goto cleanup;
2083 : }
2084 : }
2085 2617 : first_actual_arg = false;
2086 2617 : continue;
2087 : }
2088 :
2089 682095 : if (e->expr_type == EXPR_VARIABLE
2090 301764 : && e->symtree->n.sym->attr.generic
2091 8 : && no_formal_args
2092 682100 : && count_specific_procs (e) != 1)
2093 2 : goto cleanup;
2094 :
2095 682093 : if (e->ts.type != BT_PROCEDURE)
2096 : {
2097 607408 : save_need_full_assumed_size = need_full_assumed_size;
2098 607408 : if (e->expr_type != EXPR_VARIABLE)
2099 380331 : need_full_assumed_size = 0;
2100 607408 : if (!gfc_resolve_expr (e))
2101 60 : goto cleanup;
2102 607348 : need_full_assumed_size = save_need_full_assumed_size;
2103 607348 : goto argument_list;
2104 : }
2105 :
2106 : /* See if the expression node should really be a variable reference. */
2107 :
2108 74685 : sym = e->symtree->n.sym;
2109 :
2110 74685 : if (sym->attr.flavor == FL_PROCEDURE && is_dt_name (sym->name))
2111 : {
2112 3 : gfc_error ("Derived type %qs is used as an actual "
2113 : "argument at %L", sym->name, &e->where);
2114 3 : goto cleanup;
2115 : }
2116 :
2117 74682 : if (sym->attr.flavor == FL_PROCEDURE
2118 71250 : || sym->attr.intrinsic
2119 71250 : || sym->attr.external)
2120 : {
2121 3432 : int actual_ok;
2122 :
2123 : /* If a procedure is not already determined to be something else
2124 : check if it is intrinsic. */
2125 3432 : if (gfc_is_intrinsic (sym, sym->attr.subroutine, e->where))
2126 1254 : sym->attr.intrinsic = 1;
2127 :
2128 3432 : if (sym->attr.proc == PROC_ST_FUNCTION)
2129 : {
2130 2 : gfc_error ("Statement function %qs at %L is not allowed as an "
2131 : "actual argument", sym->name, &e->where);
2132 : }
2133 :
2134 6864 : actual_ok = gfc_intrinsic_actual_ok (sym->name,
2135 3432 : sym->attr.subroutine);
2136 3432 : if (sym->attr.intrinsic && actual_ok == 0)
2137 : {
2138 0 : gfc_error ("Intrinsic %qs at %L is not allowed as an "
2139 : "actual argument", sym->name, &e->where);
2140 : }
2141 :
2142 3432 : if (sym->attr.contained && !sym->attr.use_assoc
2143 444 : && sym->ns->proc_name->attr.flavor != FL_MODULE)
2144 : {
2145 256 : if (!gfc_notify_std (GFC_STD_F2008, "Internal procedure %qs is"
2146 : " used as actual argument at %L",
2147 : sym->name, &e->where))
2148 3 : goto cleanup;
2149 : }
2150 :
2151 3429 : if (sym->attr.elemental && !sym->attr.intrinsic)
2152 : {
2153 2 : gfc_error ("ELEMENTAL non-INTRINSIC procedure %qs is not "
2154 : "allowed as an actual argument at %L", sym->name,
2155 : &e->where);
2156 : }
2157 :
2158 : /* Check if a generic interface has a specific procedure
2159 : with the same name before emitting an error. */
2160 3429 : if (sym->attr.generic && count_specific_procs (e) != 1)
2161 0 : goto cleanup;
2162 :
2163 : /* Just in case a specific was found for the expression. */
2164 3429 : sym = e->symtree->n.sym;
2165 :
2166 : /* If the symbol is the function that names the current (or
2167 : parent) scope, then we really have a variable reference. */
2168 :
2169 3429 : if (gfc_is_function_return_value (sym, sym->ns))
2170 0 : goto got_variable;
2171 :
2172 : /* If all else fails, see if we have a specific intrinsic. */
2173 3429 : if (sym->ts.type == BT_UNKNOWN && sym->attr.intrinsic)
2174 : {
2175 0 : gfc_intrinsic_sym *isym;
2176 :
2177 0 : isym = gfc_find_function (sym->name);
2178 0 : if (isym == NULL || !isym->specific)
2179 : {
2180 0 : gfc_error ("Unable to find a specific INTRINSIC procedure "
2181 : "for the reference %qs at %L", sym->name,
2182 : &e->where);
2183 0 : goto cleanup;
2184 : }
2185 0 : sym->ts = isym->ts;
2186 0 : sym->attr.intrinsic = 1;
2187 0 : sym->attr.function = 1;
2188 : }
2189 :
2190 3429 : if (!gfc_resolve_expr (e))
2191 0 : goto cleanup;
2192 3429 : goto argument_list;
2193 : }
2194 :
2195 : /* See if the name is a module procedure in a parent unit. */
2196 :
2197 71250 : if (was_declared (sym) || sym->ns->parent == NULL)
2198 71156 : goto got_variable;
2199 :
2200 94 : if (gfc_find_sym_tree (sym->name, sym->ns->parent, 1, &parent_st))
2201 : {
2202 0 : gfc_error ("Symbol %qs at %L is ambiguous", sym->name, &e->where);
2203 0 : goto cleanup;
2204 : }
2205 :
2206 94 : if (parent_st == NULL)
2207 94 : goto got_variable;
2208 :
2209 0 : sym = parent_st->n.sym;
2210 0 : e->symtree = parent_st; /* Point to the right thing. */
2211 :
2212 0 : if (sym->attr.flavor == FL_PROCEDURE
2213 0 : || sym->attr.intrinsic
2214 0 : || sym->attr.external)
2215 : {
2216 0 : if (!gfc_resolve_expr (e))
2217 0 : goto cleanup;
2218 0 : goto argument_list;
2219 : }
2220 :
2221 0 : got_variable:
2222 71250 : e->expr_type = EXPR_VARIABLE;
2223 71250 : e->ts = sym->ts;
2224 71250 : if ((sym->as != NULL && sym->ts.type != BT_CLASS)
2225 36739 : || (sym->ts.type == BT_CLASS && sym->attr.class_ok
2226 3972 : && CLASS_DATA (sym)->as))
2227 : {
2228 40231 : gfc_array_spec *as
2229 37371 : = sym->ts.type == BT_CLASS ? CLASS_DATA (sym)->as : sym->as;
2230 37371 : e->rank = as->rank;
2231 37371 : e->corank = as->corank;
2232 37371 : e->ref = gfc_get_ref ();
2233 37371 : e->ref->type = REF_ARRAY;
2234 37371 : e->ref->u.ar.type = AR_FULL;
2235 37371 : e->ref->u.ar.as = as;
2236 : }
2237 :
2238 : /* These symbols are set untyped by calls to gfc_set_default_type
2239 : with 'error_flag' = false. Reset the untyped attribute so that
2240 : the error will be generated in gfc_resolve_expr. */
2241 71250 : if (e->expr_type == EXPR_VARIABLE
2242 71250 : && sym->ts.type == BT_UNKNOWN
2243 36 : && sym->attr.untyped)
2244 5 : sym->attr.untyped = 0;
2245 :
2246 : /* Expressions are assigned a default ts.type of BT_PROCEDURE in
2247 : primary.cc (match_actual_arg). If above code determines that it
2248 : is a variable instead, it needs to be resolved as it was not
2249 : done at the beginning of this function. */
2250 71250 : save_need_full_assumed_size = need_full_assumed_size;
2251 71250 : if (e->expr_type != EXPR_VARIABLE)
2252 0 : need_full_assumed_size = 0;
2253 71250 : if (!gfc_resolve_expr (e))
2254 22 : goto cleanup;
2255 71228 : need_full_assumed_size = save_need_full_assumed_size;
2256 :
2257 682005 : argument_list:
2258 : /* Check argument list functions %VAL, %LOC and %REF. There is
2259 : nothing to do for %REF. */
2260 682005 : if (arg->name && arg->name[0] == '%')
2261 : {
2262 42 : if (strcmp ("%VAL", arg->name) == 0)
2263 : {
2264 28 : if (e->ts.type == BT_CHARACTER || e->ts.type == BT_DERIVED)
2265 : {
2266 2 : gfc_error ("By-value argument at %L is not of numeric "
2267 : "type", &e->where);
2268 2 : goto cleanup;
2269 : }
2270 :
2271 26 : if (e->rank)
2272 : {
2273 1 : gfc_error ("By-value argument at %L cannot be an array or "
2274 : "an array section", &e->where);
2275 1 : goto cleanup;
2276 : }
2277 :
2278 : /* Intrinsics are still PROC_UNKNOWN here. However,
2279 : since same file external procedures are not resolvable
2280 : in gfortran, it is a good deal easier to leave them to
2281 : intrinsic.cc. */
2282 25 : if (ptype != PROC_UNKNOWN
2283 25 : && ptype != PROC_DUMMY
2284 9 : && ptype != PROC_EXTERNAL
2285 9 : && ptype != PROC_MODULE)
2286 : {
2287 3 : gfc_error ("By-value argument at %L is not allowed "
2288 : "in this context", &e->where);
2289 3 : goto cleanup;
2290 : }
2291 : }
2292 :
2293 : /* Statement functions have already been excluded above. */
2294 14 : else if (strcmp ("%LOC", arg->name) == 0
2295 8 : && e->ts.type == BT_PROCEDURE)
2296 : {
2297 0 : if (e->symtree->n.sym->attr.proc == PROC_INTERNAL)
2298 : {
2299 0 : gfc_error ("Passing internal procedure at %L by location "
2300 : "not allowed", &e->where);
2301 0 : goto cleanup;
2302 : }
2303 : }
2304 : }
2305 :
2306 681999 : comp = gfc_get_proc_ptr_comp(e);
2307 681999 : if (e->expr_type == EXPR_VARIABLE
2308 300377 : && comp && comp->attr.elemental)
2309 : {
2310 1 : gfc_error ("ELEMENTAL procedure pointer component %qs is not "
2311 : "allowed as an actual argument at %L", comp->name,
2312 : &e->where);
2313 : }
2314 :
2315 : /* Fortran 2008, C1237. */
2316 300377 : if (e->expr_type == EXPR_VARIABLE && gfc_is_coindexed (e)
2317 682450 : && gfc_has_ultimate_pointer (e))
2318 : {
2319 3 : gfc_error ("Coindexed actual argument at %L with ultimate pointer "
2320 : "component", &e->where);
2321 3 : goto cleanup;
2322 : }
2323 :
2324 681996 : if (e->expr_type == EXPR_VARIABLE
2325 300374 : && e->ts.type == BT_PROCEDURE
2326 3429 : && no_formal_args
2327 1505 : && sym->attr.flavor == FL_PROCEDURE
2328 1505 : && sym->attr.if_source == IFSRC_UNKNOWN
2329 142 : && !sym->attr.external
2330 2 : && !sym->attr.intrinsic
2331 2 : && !sym->attr.artificial
2332 2 : && !sym->ts.interface)
2333 : {
2334 : /* Emit a warning for -std=legacy and an error otherwise. */
2335 2 : if (gfc_option.warn_std == 0)
2336 0 : gfc_warning (0, "Procedure %qs at %L used as actual argument but "
2337 : "does neither have an explicit interface nor the "
2338 : "EXTERNAL attribute", sym->name, &e->where);
2339 : else
2340 : {
2341 2 : gfc_error ("Procedure %qs at %L used as actual argument but "
2342 : "does neither have an explicit interface nor the "
2343 : "EXTERNAL attribute", sym->name, &e->where);
2344 2 : goto cleanup;
2345 : }
2346 : }
2347 :
2348 681994 : first_actual_arg = false;
2349 : }
2350 :
2351 : return_value = true;
2352 :
2353 439773 : cleanup:
2354 439773 : actual_arg = actual_arg_sav;
2355 439773 : first_actual_arg = first_actual_arg_sav;
2356 :
2357 439773 : return return_value;
2358 : }
2359 :
2360 :
2361 : /* Do the checks of the actual argument list that are specific to elemental
2362 : procedures. If called with c == NULL, we have a function, otherwise if
2363 : expr == NULL, we have a subroutine. */
2364 :
2365 : static bool
2366 335186 : resolve_elemental_actual (gfc_expr *expr, gfc_code *c)
2367 : {
2368 335186 : gfc_actual_arglist *arg0;
2369 335186 : gfc_actual_arglist *arg;
2370 335186 : gfc_symbol *esym = NULL;
2371 335186 : gfc_intrinsic_sym *isym = NULL;
2372 335186 : gfc_expr *e = NULL;
2373 335186 : gfc_intrinsic_arg *iformal = NULL;
2374 335186 : gfc_formal_arglist *eformal = NULL;
2375 335186 : bool formal_optional = false;
2376 335186 : bool set_by_optional = false;
2377 335186 : int i;
2378 335186 : int rank = 0;
2379 :
2380 : /* Is this an elemental procedure? */
2381 335186 : if (expr && expr->value.function.actual != NULL)
2382 : {
2383 242824 : if (expr->value.function.esym != NULL
2384 44784 : && expr->value.function.esym->attr.elemental)
2385 : {
2386 : arg0 = expr->value.function.actual;
2387 : esym = expr->value.function.esym;
2388 : }
2389 226504 : else if (expr->value.function.isym != NULL
2390 196973 : && expr->value.function.isym->elemental)
2391 : {
2392 : arg0 = expr->value.function.actual;
2393 : isym = expr->value.function.isym;
2394 : }
2395 : else
2396 : return true;
2397 : }
2398 92362 : else if (c && c->ext.actual != NULL)
2399 : {
2400 72804 : arg0 = c->ext.actual;
2401 :
2402 72804 : if (c->resolved_sym)
2403 : esym = c->resolved_sym;
2404 : else
2405 323 : esym = c->symtree->n.sym;
2406 72804 : gcc_assert (esym);
2407 :
2408 72804 : if (!esym->attr.elemental)
2409 : return true;
2410 : }
2411 : else
2412 : return true;
2413 :
2414 : /* The rank of an elemental is the rank of its array argument(s). */
2415 178858 : for (arg = arg0; arg; arg = arg->next)
2416 : {
2417 115501 : if (arg->expr != NULL && arg->expr->rank != 0)
2418 : {
2419 10830 : rank = arg->expr->rank;
2420 10830 : if (arg->expr->expr_type == EXPR_VARIABLE
2421 5538 : && arg->expr->symtree->n.sym->attr.optional)
2422 10830 : set_by_optional = true;
2423 :
2424 : /* Function specific; set the result rank and shape. */
2425 10830 : if (expr)
2426 : {
2427 8416 : expr->rank = rank;
2428 8416 : expr->corank = arg->expr->corank;
2429 8416 : if (!expr->shape && arg->expr->shape)
2430 : {
2431 3998 : expr->shape = gfc_get_shape (rank);
2432 8791 : for (i = 0; i < rank; i++)
2433 4793 : mpz_init_set (expr->shape[i], arg->expr->shape[i]);
2434 : }
2435 : }
2436 : break;
2437 : }
2438 : }
2439 :
2440 : /* If it is an array, it shall not be supplied as an actual argument
2441 : to an elemental procedure unless an array of the same rank is supplied
2442 : as an actual argument corresponding to a nonoptional dummy argument of
2443 : that elemental procedure(12.4.1.5). */
2444 74187 : formal_optional = false;
2445 74187 : if (isym)
2446 51648 : iformal = isym->formal;
2447 : else
2448 22539 : eformal = esym->formal;
2449 :
2450 195222 : for (arg = arg0; arg; arg = arg->next)
2451 : {
2452 121035 : if (eformal)
2453 : {
2454 40435 : if (eformal->sym && eformal->sym->attr.optional)
2455 40435 : formal_optional = true;
2456 40435 : eformal = eformal->next;
2457 : }
2458 80600 : else if (isym && iformal)
2459 : {
2460 69669 : if (iformal->optional)
2461 13726 : formal_optional = true;
2462 69669 : iformal = iformal->next;
2463 : }
2464 10931 : else if (isym)
2465 10923 : formal_optional = true;
2466 :
2467 121035 : if (pedantic && arg->expr != NULL
2468 69372 : && arg->expr->expr_type == EXPR_VARIABLE
2469 32899 : && arg->expr->symtree->n.sym->attr.optional
2470 578 : && formal_optional
2471 485 : && arg->expr->rank
2472 159 : && (set_by_optional || arg->expr->rank != rank)
2473 42 : && !(isym && isym->id == GFC_ISYM_CONVERSION))
2474 : {
2475 114 : bool t = false;
2476 : gfc_actual_arglist *a;
2477 :
2478 : /* Scan the argument list for a non-optional argument with the
2479 : same rank as arg. */
2480 114 : for (a = arg0; a; a = a->next)
2481 87 : if (a != arg
2482 45 : && a->expr->rank == arg->expr->rank
2483 39 : && (a->expr->expr_type != EXPR_VARIABLE
2484 37 : || (a->expr->expr_type == EXPR_VARIABLE
2485 37 : && !a->expr->symtree->n.sym->attr.optional)))
2486 : {
2487 : t = true;
2488 : break;
2489 : }
2490 :
2491 42 : if (!t)
2492 27 : gfc_warning (OPT_Wpedantic,
2493 : "%qs at %L is an array and OPTIONAL; If it is not "
2494 : "present, then it cannot be the actual argument of "
2495 : "an ELEMENTAL procedure unless there is a non-optional"
2496 : " argument with the same rank "
2497 : "(Fortran 2018, 15.5.2.12)",
2498 : arg->expr->symtree->n.sym->name, &arg->expr->where);
2499 : }
2500 : }
2501 :
2502 195211 : for (arg = arg0; arg; arg = arg->next)
2503 : {
2504 121033 : if (arg->expr == NULL || arg->expr->rank == 0)
2505 107297 : continue;
2506 :
2507 : /* Being elemental, the last upper bound of an assumed size array
2508 : argument must be present. */
2509 13736 : if (resolve_assumed_size_actual (arg->expr))
2510 : return false;
2511 :
2512 : /* Elemental procedure's array actual arguments must conform. */
2513 13733 : if (e != NULL)
2514 : {
2515 2906 : if (!gfc_check_conformance (arg->expr, e, _("elemental procedure")))
2516 : return false;
2517 : }
2518 : else
2519 10827 : e = arg->expr;
2520 : }
2521 :
2522 : /* INTENT(OUT) is only allowed for subroutines; if any actual argument
2523 : is an array, the intent inout/out variable needs to be also an array. */
2524 74178 : if (rank > 0 && esym && expr == NULL)
2525 7345 : for (eformal = esym->formal, arg = arg0; arg && eformal;
2526 4937 : arg = arg->next, eformal = eformal->next)
2527 4939 : if (eformal->sym
2528 4938 : && (eformal->sym->attr.intent == INTENT_OUT
2529 3856 : || eformal->sym->attr.intent == INTENT_INOUT)
2530 1716 : && arg->expr && arg->expr->rank == 0)
2531 : {
2532 2 : gfc_error ("Actual argument at %L for INTENT(%s) dummy %qs of "
2533 : "ELEMENTAL subroutine %qs is a scalar, but another "
2534 : "actual argument is an array", &arg->expr->where,
2535 : (eformal->sym->attr.intent == INTENT_OUT) ? "OUT"
2536 : : "INOUT", eformal->sym->name, esym->name);
2537 2 : return false;
2538 : }
2539 : return true;
2540 : }
2541 :
2542 :
2543 : /* This function does the checking of references to global procedures
2544 : as defined in sections 18.1 and 14.1, respectively, of the Fortran
2545 : 77 and 95 standards. It checks for a gsymbol for the name, making
2546 : one if it does not already exist. If it already exists, then the
2547 : reference being resolved must correspond to the type of gsymbol.
2548 : Otherwise, the new symbol is equipped with the attributes of the
2549 : reference. The corresponding code that is called in creating
2550 : global entities is parse.cc.
2551 :
2552 : In addition, for all but -std=legacy, the gsymbols are used to
2553 : check the interfaces of external procedures from the same file.
2554 : The namespace of the gsymbol is resolved and then, once this is
2555 : done the interface is checked. */
2556 :
2557 :
2558 : static bool
2559 15015 : not_in_recursive (gfc_symbol *sym, gfc_namespace *gsym_ns)
2560 : {
2561 15015 : if (!gsym_ns->proc_name->attr.recursive)
2562 : return true;
2563 :
2564 151 : if (sym->ns == gsym_ns)
2565 : return false;
2566 :
2567 151 : if (sym->ns->parent && sym->ns->parent == gsym_ns)
2568 0 : return false;
2569 :
2570 : return true;
2571 : }
2572 :
2573 : static bool
2574 15015 : not_entry_self_reference (gfc_symbol *sym, gfc_namespace *gsym_ns)
2575 : {
2576 15015 : if (gsym_ns->entries)
2577 : {
2578 : gfc_entry_list *entry = gsym_ns->entries;
2579 :
2580 3312 : for (; entry; entry = entry->next)
2581 : {
2582 2333 : if (strcmp (sym->name, entry->sym->name) == 0)
2583 : {
2584 971 : if (strcmp (gsym_ns->proc_name->name,
2585 971 : sym->ns->proc_name->name) == 0)
2586 : return false;
2587 :
2588 971 : if (sym->ns->parent
2589 0 : && strcmp (gsym_ns->proc_name->name,
2590 0 : sym->ns->parent->proc_name->name) == 0)
2591 : return false;
2592 : }
2593 : }
2594 : }
2595 : return true;
2596 : }
2597 :
2598 :
2599 : /* Check for the requirement of an explicit interface. F08:12.4.2.2. */
2600 :
2601 : bool
2602 15881 : gfc_explicit_interface_required (gfc_symbol *sym, char *errmsg, int err_len)
2603 : {
2604 15881 : gfc_formal_arglist *arg = gfc_sym_get_dummy_args (sym);
2605 :
2606 59227 : for ( ; arg; arg = arg->next)
2607 : {
2608 27885 : if (!arg->sym)
2609 157 : continue;
2610 :
2611 27728 : if (arg->sym->attr.allocatable) /* (2a) */
2612 : {
2613 0 : strncpy (errmsg, _("allocatable argument"), err_len);
2614 0 : return true;
2615 : }
2616 27728 : else if (arg->sym->attr.asynchronous)
2617 : {
2618 0 : strncpy (errmsg, _("asynchronous argument"), err_len);
2619 0 : return true;
2620 : }
2621 27728 : else if (arg->sym->attr.optional)
2622 : {
2623 75 : strncpy (errmsg, _("optional argument"), err_len);
2624 75 : return true;
2625 : }
2626 27653 : else if (arg->sym->attr.pointer)
2627 : {
2628 12 : strncpy (errmsg, _("pointer argument"), err_len);
2629 12 : return true;
2630 : }
2631 27641 : else if (arg->sym->attr.target)
2632 : {
2633 72 : strncpy (errmsg, _("target argument"), err_len);
2634 72 : return true;
2635 : }
2636 27569 : else if (arg->sym->attr.value)
2637 : {
2638 12 : strncpy (errmsg, _("value argument"), err_len);
2639 12 : return true;
2640 : }
2641 27557 : else if (arg->sym->attr.volatile_)
2642 : {
2643 1 : strncpy (errmsg, _("volatile argument"), err_len);
2644 1 : return true;
2645 : }
2646 27556 : else if (arg->sym->as && arg->sym->as->type == AS_ASSUMED_SHAPE) /* (2b) */
2647 : {
2648 81 : strncpy (errmsg, _("assumed-shape argument"), err_len);
2649 81 : return true;
2650 : }
2651 27475 : else if (arg->sym->as && arg->sym->as->type == AS_ASSUMED_RANK) /* TS 29113, 6.2. */
2652 : {
2653 1 : strncpy (errmsg, _("assumed-rank argument"), err_len);
2654 1 : return true;
2655 : }
2656 27474 : else if (arg->sym->attr.codimension) /* (2c) */
2657 : {
2658 1 : strncpy (errmsg, _("coarray argument"), err_len);
2659 1 : return true;
2660 : }
2661 27473 : else if (false) /* (2d) TODO: parametrized derived type */
2662 : {
2663 : strncpy (errmsg, _("parametrized derived type argument"), err_len);
2664 : return true;
2665 : }
2666 27473 : else if (arg->sym->ts.type == BT_CLASS) /* (2e) */
2667 : {
2668 164 : strncpy (errmsg, _("polymorphic argument"), err_len);
2669 164 : return true;
2670 : }
2671 27309 : else if (arg->sym->attr.ext_attr & (1 << EXT_ATTR_NO_ARG_CHECK))
2672 : {
2673 0 : strncpy (errmsg, _("NO_ARG_CHECK attribute"), err_len);
2674 0 : return true;
2675 : }
2676 27309 : else if (arg->sym->ts.type == BT_ASSUMED)
2677 : {
2678 : /* As assumed-type is unlimited polymorphic (cf. above).
2679 : See also TS 29113, Note 6.1. */
2680 1 : strncpy (errmsg, _("assumed-type argument"), err_len);
2681 1 : return true;
2682 : }
2683 : }
2684 :
2685 15461 : if (sym->attr.function)
2686 : {
2687 3511 : gfc_symbol *res = sym->result ? sym->result : sym;
2688 :
2689 3511 : if (res->attr.dimension) /* (3a) */
2690 : {
2691 93 : strncpy (errmsg, _("array result"), err_len);
2692 93 : return true;
2693 : }
2694 3418 : else if (res->attr.pointer || res->attr.allocatable) /* (3b) */
2695 : {
2696 38 : strncpy (errmsg, _("pointer or allocatable result"), err_len);
2697 38 : return true;
2698 : }
2699 3380 : else if (res->ts.type == BT_CHARACTER && res->ts.u.cl
2700 347 : && res->ts.u.cl->length
2701 166 : && res->ts.u.cl->length->expr_type != EXPR_CONSTANT) /* (3c) */
2702 : {
2703 12 : strncpy (errmsg, _("result with non-constant character length"), err_len);
2704 12 : return true;
2705 : }
2706 : }
2707 :
2708 15318 : if (sym->attr.elemental && !sym->attr.intrinsic) /* (4) */
2709 : {
2710 7 : strncpy (errmsg, _("elemental procedure"), err_len);
2711 7 : return true;
2712 : }
2713 15311 : else if (sym->attr.is_bind_c) /* (5) */
2714 : {
2715 0 : strncpy (errmsg, _("bind(c) procedure"), err_len);
2716 0 : return true;
2717 : }
2718 :
2719 : return false;
2720 : }
2721 :
2722 :
2723 : static void
2724 30050 : resolve_global_procedure (gfc_symbol *sym, locus *where, int sub)
2725 : {
2726 30050 : gfc_gsymbol * gsym;
2727 30050 : gfc_namespace *ns;
2728 30050 : enum gfc_symbol_type type;
2729 30050 : char reason[200];
2730 :
2731 30050 : type = sub ? GSYM_SUBROUTINE : GSYM_FUNCTION;
2732 :
2733 30050 : gsym = gfc_get_gsymbol (sym->binding_label ? sym->binding_label : sym->name,
2734 30050 : sym->binding_label != NULL);
2735 :
2736 30050 : if ((gsym->type != GSYM_UNKNOWN && gsym->type != type))
2737 9 : gfc_global_used (gsym, where);
2738 :
2739 30050 : if ((sym->attr.if_source == IFSRC_UNKNOWN
2740 9797 : || sym->attr.if_source == IFSRC_IFBODY)
2741 25228 : && gsym->type != GSYM_UNKNOWN
2742 23034 : && !gsym->binding_label
2743 20681 : && gsym->ns
2744 15015 : && gsym->ns->proc_name
2745 15015 : && not_in_recursive (sym, gsym->ns)
2746 45065 : && not_entry_self_reference (sym, gsym->ns))
2747 : {
2748 15015 : gfc_symbol *def_sym;
2749 15015 : def_sym = gsym->ns->proc_name;
2750 :
2751 15015 : if (gsym->ns->resolved != -1)
2752 : {
2753 :
2754 : /* Resolve the gsymbol namespace if needed. */
2755 14993 : if (!gsym->ns->resolved)
2756 : {
2757 2794 : gfc_symbol *old_dt_list;
2758 :
2759 : /* Stash away derived types so that the backend_decls
2760 : do not get mixed up. */
2761 2794 : old_dt_list = gfc_derived_types;
2762 2794 : gfc_derived_types = NULL;
2763 :
2764 2794 : gfc_resolve (gsym->ns);
2765 :
2766 : /* Store the new derived types with the global namespace. */
2767 2794 : if (gfc_derived_types)
2768 306 : gsym->ns->derived_types = gfc_derived_types;
2769 :
2770 : /* Restore the derived types of this namespace. */
2771 2794 : gfc_derived_types = old_dt_list;
2772 : }
2773 :
2774 : /* Make sure that translation for the gsymbol occurs before
2775 : the procedure currently being resolved. */
2776 14993 : ns = gfc_global_ns_list;
2777 25466 : for (; ns && ns != gsym->ns; ns = ns->sibling)
2778 : {
2779 17051 : if (ns->sibling == gsym->ns)
2780 : {
2781 6578 : ns->sibling = gsym->ns->sibling;
2782 6578 : gsym->ns->sibling = gfc_global_ns_list;
2783 6578 : gfc_global_ns_list = gsym->ns;
2784 6578 : break;
2785 : }
2786 : }
2787 :
2788 : /* This can happen if a binding name has been specified. */
2789 14993 : if (gsym->binding_label && gsym->sym_name != def_sym->name)
2790 0 : gfc_find_symbol (gsym->sym_name, gsym->ns, 0, &def_sym);
2791 : }
2792 :
2793 : /* Look up the specific entry symbol so that interface checks use
2794 : the entry's own formal argument list, not the entry master's.
2795 : This must run even when resolved == -1 (recursive resolution in
2796 : progress), because def_sym starts as the namespace proc_name
2797 : which is the entry master with the combined formals. */
2798 15015 : if (def_sym->attr.entry_master || def_sym->attr.entry)
2799 : {
2800 979 : gfc_entry_list *entry;
2801 1699 : for (entry = gsym->ns->entries; entry; entry = entry->next)
2802 1699 : if (strcmp (entry->sym->name, sym->name) == 0)
2803 : {
2804 979 : def_sym = entry->sym;
2805 979 : break;
2806 : }
2807 : }
2808 :
2809 15015 : if (sym->attr.function && !gfc_compare_types (&sym->ts, &def_sym->ts))
2810 : {
2811 6 : gfc_error ("Return type mismatch of function %qs at %L (%s/%s)",
2812 : sym->name, &sym->declared_at, gfc_typename (&sym->ts),
2813 6 : gfc_typename (&def_sym->ts));
2814 28 : goto done;
2815 : }
2816 :
2817 15009 : if (sym->attr.if_source == IFSRC_UNKNOWN
2818 15009 : && gfc_explicit_interface_required (def_sym, reason, sizeof(reason)))
2819 : {
2820 8 : gfc_error ("Explicit interface required for %qs at %L: %s",
2821 : sym->name, &sym->declared_at, reason);
2822 8 : goto done;
2823 : }
2824 :
2825 15001 : bool bad_result_characteristics;
2826 15001 : if (!gfc_compare_interfaces (sym, def_sym, sym->name, 0, 1,
2827 : reason, sizeof(reason), NULL, NULL,
2828 : &bad_result_characteristics))
2829 : {
2830 : /* Turn errors into warnings with -std=gnu and -std=legacy,
2831 : unless a function returns a wrong type, which can lead
2832 : to all kinds of ICEs and wrong code. */
2833 :
2834 14 : if (!pedantic && (gfc_option.allow_std & GFC_STD_GNU)
2835 2 : && !bad_result_characteristics)
2836 2 : gfc_errors_to_warnings (true);
2837 :
2838 14 : gfc_error ("Interface mismatch in global procedure %qs at %L: %s",
2839 : sym->name, &sym->declared_at, reason);
2840 14 : sym->error = 1;
2841 14 : gfc_errors_to_warnings (false);
2842 14 : goto done;
2843 : }
2844 : }
2845 :
2846 30050 : done:
2847 :
2848 30050 : if (gsym->type == GSYM_UNKNOWN)
2849 : {
2850 4222 : gsym->type = type;
2851 4222 : gsym->where = *where;
2852 : }
2853 :
2854 30050 : gsym->used = 1;
2855 30050 : }
2856 :
2857 :
2858 : /************* Function resolution *************/
2859 :
2860 : /* Resolve a function call known to be generic.
2861 : Section 14.1.2.4.1. */
2862 :
2863 : static match
2864 28537 : resolve_generic_f0 (gfc_expr *expr, gfc_symbol *sym)
2865 : {
2866 28537 : gfc_symbol *s;
2867 :
2868 28537 : if (sym->attr.generic)
2869 : {
2870 27373 : s = gfc_search_interface (sym->generic, 0, &expr->value.function.actual);
2871 27373 : if (s != NULL)
2872 : {
2873 20203 : expr->value.function.name = s->name;
2874 20203 : expr->value.function.esym = s;
2875 :
2876 20203 : if (s->ts.type != BT_UNKNOWN)
2877 20186 : expr->ts = s->ts;
2878 17 : else if (s->result != NULL && s->result->ts.type != BT_UNKNOWN)
2879 15 : expr->ts = s->result->ts;
2880 :
2881 20203 : if (s->as != NULL)
2882 : {
2883 55 : expr->rank = s->as->rank;
2884 55 : expr->corank = s->as->corank;
2885 : }
2886 20148 : else if (s->result != NULL && s->result->as != NULL)
2887 : {
2888 0 : expr->rank = s->result->as->rank;
2889 0 : expr->corank = s->result->as->corank;
2890 : }
2891 :
2892 20203 : gfc_set_sym_referenced (expr->value.function.esym);
2893 :
2894 20203 : return MATCH_YES;
2895 : }
2896 :
2897 : /* TODO: Need to search for elemental references in generic
2898 : interface. */
2899 : }
2900 :
2901 8334 : if (sym->attr.intrinsic)
2902 1121 : return gfc_intrinsic_func_interface (expr, 0);
2903 :
2904 : return MATCH_NO;
2905 : }
2906 :
2907 :
2908 : static bool
2909 28387 : resolve_generic_f (gfc_expr *expr)
2910 : {
2911 28387 : gfc_symbol *sym;
2912 28387 : match m;
2913 28387 : gfc_interface *intr = NULL;
2914 :
2915 28387 : sym = expr->symtree->n.sym;
2916 :
2917 28537 : for (;;)
2918 : {
2919 28537 : m = resolve_generic_f0 (expr, sym);
2920 28537 : if (m == MATCH_YES)
2921 : return true;
2922 7215 : else if (m == MATCH_ERROR)
2923 : return false;
2924 :
2925 7215 : generic:
2926 7218 : if (!intr)
2927 7180 : for (intr = sym->generic; intr; intr = intr->next)
2928 7096 : if (gfc_fl_struct (intr->sym->attr.flavor))
2929 : break;
2930 :
2931 7218 : if (sym->ns->parent == NULL)
2932 : break;
2933 322 : gfc_find_symbol (sym->name, sym->ns->parent, 1, &sym);
2934 :
2935 322 : if (sym == NULL)
2936 : break;
2937 153 : if (!generic_sym (sym))
2938 3 : goto generic;
2939 : }
2940 :
2941 : /* Last ditch attempt. See if the reference is to an intrinsic
2942 : that possesses a matching interface. 14.1.2.4 */
2943 7065 : if (sym && !intr && !gfc_is_intrinsic (sym, 0, expr->where))
2944 : {
2945 5 : if (gfc_init_expr_flag)
2946 1 : gfc_error ("Function %qs in initialization expression at %L "
2947 : "must be an intrinsic function",
2948 1 : expr->symtree->n.sym->name, &expr->where);
2949 : else
2950 4 : gfc_error ("There is no specific function for the generic %qs "
2951 4 : "at %L", expr->symtree->n.sym->name, &expr->where);
2952 : return false;
2953 : }
2954 :
2955 7060 : if (intr)
2956 : {
2957 7025 : if (!gfc_convert_to_structure_constructor (expr, intr->sym, NULL,
2958 : NULL, false))
2959 : return false;
2960 6998 : if (!gfc_use_derived (expr->ts.u.derived))
2961 : return false;
2962 6998 : return resolve_structure_cons (expr, 0);
2963 : }
2964 :
2965 35 : m = gfc_intrinsic_func_interface (expr, 0);
2966 35 : if (m == MATCH_YES)
2967 : return true;
2968 :
2969 3 : if (m == MATCH_NO)
2970 3 : gfc_error ("Generic function %qs at %L is not consistent with a "
2971 3 : "specific intrinsic interface", expr->symtree->n.sym->name,
2972 : &expr->where);
2973 :
2974 : return false;
2975 : }
2976 :
2977 :
2978 : /* Resolve a function call known to be specific. */
2979 :
2980 : static match
2981 29094 : resolve_specific_f0 (gfc_symbol *sym, gfc_expr *expr)
2982 : {
2983 29094 : match m;
2984 :
2985 29094 : if (sym->attr.external || sym->attr.if_source == IFSRC_IFBODY)
2986 : {
2987 8346 : if (sym->attr.dummy)
2988 : {
2989 282 : sym->attr.proc = PROC_DUMMY;
2990 282 : goto found;
2991 : }
2992 :
2993 8064 : sym->attr.proc = PROC_EXTERNAL;
2994 8064 : goto found;
2995 : }
2996 :
2997 20748 : if (sym->attr.proc == PROC_MODULE
2998 11415 : || sym->attr.proc == PROC_ST_FUNCTION
2999 11125 : || sym->attr.proc == PROC_INTERNAL)
3000 20010 : goto found;
3001 :
3002 738 : if (sym->attr.intrinsic)
3003 : {
3004 731 : m = gfc_intrinsic_func_interface (expr, 1);
3005 731 : if (m == MATCH_YES)
3006 : return MATCH_YES;
3007 0 : if (m == MATCH_NO)
3008 0 : gfc_error ("Function %qs at %L is INTRINSIC but is not compatible "
3009 : "with an intrinsic", sym->name, &expr->where);
3010 :
3011 : return MATCH_ERROR;
3012 : }
3013 :
3014 : return MATCH_NO;
3015 :
3016 28356 : found:
3017 28356 : gfc_procedure_use (sym, &expr->value.function.actual, &expr->where);
3018 :
3019 28356 : if (sym->result)
3020 28356 : expr->ts = sym->result->ts;
3021 : else
3022 0 : expr->ts = sym->ts;
3023 28356 : expr->value.function.name = sym->name;
3024 28356 : expr->value.function.esym = sym;
3025 : /* Prevent crash when sym->ts.u.derived->components is not set due to previous
3026 : error(s). */
3027 28356 : if (sym->ts.type == BT_CLASS && !CLASS_DATA (sym))
3028 : return MATCH_ERROR;
3029 28355 : if (sym->ts.type == BT_CLASS && CLASS_DATA (sym)->as)
3030 : {
3031 334 : expr->rank = CLASS_DATA (sym)->as->rank;
3032 334 : expr->corank = CLASS_DATA (sym)->as->corank;
3033 : }
3034 28021 : else if (sym->as != NULL)
3035 : {
3036 2557 : expr->rank = sym->as->rank;
3037 2557 : expr->corank = sym->as->corank;
3038 : }
3039 :
3040 : return MATCH_YES;
3041 : }
3042 :
3043 :
3044 : static bool
3045 29087 : resolve_specific_f (gfc_expr *expr)
3046 : {
3047 29087 : gfc_symbol *sym;
3048 29087 : match m;
3049 :
3050 29087 : sym = expr->symtree->n.sym;
3051 :
3052 29094 : for (;;)
3053 : {
3054 29094 : m = resolve_specific_f0 (sym, expr);
3055 29094 : if (m == MATCH_YES)
3056 : return true;
3057 8 : if (m == MATCH_ERROR)
3058 : return false;
3059 :
3060 7 : if (sym->ns->parent == NULL)
3061 : break;
3062 :
3063 7 : gfc_find_symbol (sym->name, sym->ns->parent, 1, &sym);
3064 :
3065 7 : if (sym == NULL)
3066 : break;
3067 : }
3068 :
3069 0 : gfc_error ("Unable to resolve the specific function %qs at %L",
3070 0 : expr->symtree->n.sym->name, &expr->where);
3071 :
3072 0 : return true;
3073 : }
3074 :
3075 : /* Recursively append candidate SYM to CANDIDATES. Store the number of
3076 : candidates in CANDIDATES_LEN. */
3077 :
3078 : static void
3079 212 : lookup_function_fuzzy_find_candidates (gfc_symtree *sym,
3080 : char **&candidates,
3081 : size_t &candidates_len)
3082 : {
3083 388 : gfc_symtree *p;
3084 :
3085 388 : if (sym == NULL)
3086 : return;
3087 388 : if ((sym->n.sym->ts.type != BT_UNKNOWN || sym->n.sym->attr.external)
3088 126 : && sym->n.sym->attr.flavor == FL_PROCEDURE)
3089 51 : vec_push (candidates, candidates_len, sym->name);
3090 :
3091 388 : p = sym->left;
3092 388 : if (p)
3093 155 : lookup_function_fuzzy_find_candidates (p, candidates, candidates_len);
3094 :
3095 388 : p = sym->right;
3096 388 : if (p)
3097 : lookup_function_fuzzy_find_candidates (p, candidates, candidates_len);
3098 : }
3099 :
3100 :
3101 : /* Lookup function FN fuzzily, taking names in SYMROOT into account. */
3102 :
3103 : const char*
3104 57 : gfc_lookup_function_fuzzy (const char *fn, gfc_symtree *symroot)
3105 : {
3106 57 : char **candidates = NULL;
3107 57 : size_t candidates_len = 0;
3108 57 : lookup_function_fuzzy_find_candidates (symroot, candidates, candidates_len);
3109 57 : return gfc_closest_fuzzy_match (fn, candidates);
3110 : }
3111 :
3112 :
3113 : /* Resolve a procedure call not known to be generic nor specific. */
3114 :
3115 : static bool
3116 283402 : resolve_unknown_f (gfc_expr *expr)
3117 : {
3118 283402 : gfc_symbol *sym;
3119 283402 : gfc_typespec *ts;
3120 :
3121 283402 : sym = expr->symtree->n.sym;
3122 :
3123 283402 : if (sym->attr.dummy)
3124 : {
3125 293 : sym->attr.proc = PROC_DUMMY;
3126 293 : expr->value.function.name = sym->name;
3127 293 : goto set_type;
3128 : }
3129 :
3130 : /* See if we have an intrinsic function reference. */
3131 :
3132 283109 : if (gfc_is_intrinsic (sym, 0, expr->where))
3133 : {
3134 280847 : if (gfc_intrinsic_func_interface (expr, 1) == MATCH_YES)
3135 : return true;
3136 819 : return false;
3137 : }
3138 :
3139 : /* IMPLICIT NONE (external) procedures require an explicit EXTERNAL attr. */
3140 : /* Intrinsics were handled above, only non-intrinsics left here. */
3141 2262 : if (sym->attr.flavor == FL_PROCEDURE
3142 2259 : && sym->attr.implicit_type
3143 376 : && sym->ns
3144 376 : && sym->ns->has_implicit_none_export)
3145 : {
3146 3 : gfc_error ("Missing explicit declaration with EXTERNAL attribute "
3147 : "for symbol %qs at %L", sym->name, &sym->declared_at);
3148 3 : sym->error = 1;
3149 3 : return false;
3150 : }
3151 :
3152 : /* The reference is to an external name. */
3153 :
3154 2259 : sym->attr.proc = PROC_EXTERNAL;
3155 2259 : expr->value.function.name = sym->name;
3156 2259 : expr->value.function.esym = expr->symtree->n.sym;
3157 :
3158 2259 : if (sym->as != NULL)
3159 : {
3160 1 : expr->rank = sym->as->rank;
3161 1 : expr->corank = sym->as->corank;
3162 : }
3163 :
3164 : /* Type of the expression is either the type of the symbol or the
3165 : default type of the symbol. */
3166 :
3167 2258 : set_type:
3168 2552 : gfc_procedure_use (sym, &expr->value.function.actual, &expr->where);
3169 :
3170 2552 : if (sym->ts.type != BT_UNKNOWN)
3171 2501 : expr->ts = sym->ts;
3172 : else
3173 : {
3174 51 : ts = gfc_get_default_type (sym->name, sym->ns);
3175 :
3176 51 : if (ts->type == BT_UNKNOWN)
3177 : {
3178 41 : const char *guessed
3179 41 : = gfc_lookup_function_fuzzy (sym->name, sym->ns->sym_root);
3180 41 : if (guessed)
3181 3 : gfc_error ("Function %qs at %L has no IMPLICIT type"
3182 : "; did you mean %qs?",
3183 : sym->name, &expr->where, guessed);
3184 : else
3185 38 : gfc_error ("Function %qs at %L has no IMPLICIT type",
3186 : sym->name, &expr->where);
3187 : return false;
3188 : }
3189 : else
3190 10 : expr->ts = *ts;
3191 : }
3192 :
3193 : return true;
3194 : }
3195 :
3196 :
3197 : /* Return true, if the symbol is an external procedure. */
3198 : static bool
3199 876817 : is_external_proc (gfc_symbol *sym)
3200 : {
3201 875094 : if (!sym->attr.dummy && !sym->attr.contained
3202 764114 : && !gfc_is_intrinsic (sym, sym->attr.subroutine, sym->declared_at)
3203 167332 : && sym->attr.proc != PROC_ST_FUNCTION
3204 166735 : && !sym->attr.proc_pointer
3205 165523 : && !sym->attr.use_assoc
3206 936948 : && sym->name)
3207 60131 : return true;
3208 :
3209 : return false;
3210 : }
3211 :
3212 :
3213 : /* Figure out if a function reference is pure or not. Also set the name
3214 : of the function for a potential error message. Return nonzero if the
3215 : function is PURE, zero if not. */
3216 : static bool
3217 : pure_stmt_function (gfc_expr *, gfc_symbol *);
3218 :
3219 : bool
3220 264020 : gfc_pure_function (gfc_expr *e, const char **name)
3221 : {
3222 264020 : bool pure;
3223 264020 : gfc_component *comp;
3224 :
3225 264020 : *name = NULL;
3226 :
3227 264020 : if (e->symtree != NULL
3228 263646 : && e->symtree->n.sym != NULL
3229 263646 : && e->symtree->n.sym->attr.proc == PROC_ST_FUNCTION)
3230 306 : return pure_stmt_function (e, e->symtree->n.sym);
3231 :
3232 263714 : comp = gfc_get_proc_ptr_comp (e);
3233 263714 : if (comp)
3234 : {
3235 498 : pure = gfc_pure (comp->ts.interface);
3236 498 : *name = comp->name;
3237 : }
3238 263216 : else if (e->value.function.esym)
3239 : {
3240 54234 : pure = gfc_pure (e->value.function.esym);
3241 54234 : *name = e->value.function.esym->name;
3242 : }
3243 208982 : else if (e->value.function.isym)
3244 : {
3245 415800 : pure = e->value.function.isym->pure
3246 207900 : || e->value.function.isym->elemental;
3247 207900 : *name = e->value.function.isym->name;
3248 : }
3249 1082 : else if (e->symtree && e->symtree->n.sym && e->symtree->n.sym->attr.dummy)
3250 : {
3251 : /* The function has been resolved, but esym is not yet set.
3252 : This can happen with functions as dummy argument. */
3253 291 : pure = e->symtree->n.sym->attr.pure;
3254 291 : *name = e->symtree->n.sym->name;
3255 : }
3256 : else
3257 : {
3258 : /* Implicit functions are not pure. */
3259 791 : pure = 0;
3260 791 : *name = e->value.function.name;
3261 : }
3262 :
3263 : return pure;
3264 : }
3265 :
3266 :
3267 : /* Check if the expression is a reference to an implicitly pure function. */
3268 :
3269 : bool
3270 39549 : gfc_implicit_pure_function (gfc_expr *e)
3271 : {
3272 39549 : gfc_component *comp = gfc_get_proc_ptr_comp (e);
3273 39549 : if (comp)
3274 476 : return gfc_implicit_pure (comp->ts.interface);
3275 39073 : else if (e->value.function.esym)
3276 33651 : return gfc_implicit_pure (e->value.function.esym);
3277 : else
3278 : return 0;
3279 : }
3280 :
3281 :
3282 : static bool
3283 983 : impure_stmt_fcn (gfc_expr *e, gfc_symbol *sym,
3284 : int *f ATTRIBUTE_UNUSED)
3285 : {
3286 983 : const char *name;
3287 :
3288 : /* Don't bother recursing into other statement functions
3289 : since they will be checked individually for purity. */
3290 983 : if (e->expr_type != EXPR_FUNCTION
3291 344 : || !e->symtree
3292 344 : || e->symtree->n.sym == sym
3293 20 : || e->symtree->n.sym->attr.proc == PROC_ST_FUNCTION)
3294 : return false;
3295 :
3296 19 : return !gfc_pure_function (e, &name);
3297 : }
3298 :
3299 :
3300 : static bool
3301 306 : pure_stmt_function (gfc_expr *e, gfc_symbol *sym)
3302 : {
3303 306 : return gfc_traverse_expr (e, sym, impure_stmt_fcn, 0) ? 0 : 1;
3304 : }
3305 :
3306 :
3307 : /* Check if an impure function is allowed in the current context. */
3308 :
3309 251909 : static bool check_pure_function (gfc_expr *e)
3310 : {
3311 251909 : const char *name = NULL;
3312 251909 : code_stack *stack;
3313 251909 : bool saw_block = false;
3314 :
3315 : /* A BLOCK construct within a DO CONCURRENT construct leads to
3316 : gfc_do_concurrent_flag = 0 when the check for an impure function
3317 : occurs. Check the stack to see if the source code has a nested
3318 : BLOCK construct. */
3319 :
3320 583366 : for (stack = cs_base; stack; stack = stack->prev)
3321 : {
3322 331459 : if (!saw_block && stack->current->op == EXEC_BLOCK)
3323 : {
3324 8188 : saw_block = true;
3325 8188 : continue;
3326 : }
3327 :
3328 5652 : if (saw_block && stack->current->op == EXEC_DO_CONCURRENT)
3329 : {
3330 16 : bool is_pure;
3331 331457 : is_pure = (e->value.function.isym
3332 15 : && (e->value.function.isym->pure
3333 1 : || e->value.function.isym->elemental))
3334 17 : || (e->value.function.esym
3335 1 : && (e->value.function.esym->attr.pure
3336 1 : || e->value.function.esym->attr.elemental));
3337 2 : if (!is_pure)
3338 : {
3339 2 : gfc_error ("Reference to impure function at %L inside a "
3340 : "DO CONCURRENT", &e->where);
3341 2 : return false;
3342 : }
3343 : }
3344 : }
3345 :
3346 251907 : if (!gfc_pure_function (e, &name) && name)
3347 : {
3348 38233 : if (forall_flag)
3349 : {
3350 4 : gfc_error ("Reference to impure function %qs at %L inside a "
3351 : "FORALL %s", name, &e->where,
3352 : forall_flag == 2 ? "mask" : "block");
3353 4 : return false;
3354 : }
3355 38229 : else if (gfc_do_concurrent_flag)
3356 : {
3357 2 : gfc_error ("Reference to impure function %qs at %L inside a "
3358 : "DO CONCURRENT %s", name, &e->where,
3359 : gfc_do_concurrent_flag == 2 ? "mask" : "block");
3360 2 : return false;
3361 : }
3362 38227 : else if (gfc_pure (NULL))
3363 : {
3364 5 : gfc_error ("Reference to impure function %qs at %L "
3365 : "within a PURE procedure", name, &e->where);
3366 5 : return false;
3367 : }
3368 38222 : if (!gfc_implicit_pure_function (e))
3369 31315 : gfc_unset_implicit_pure (NULL);
3370 : }
3371 : return true;
3372 : }
3373 :
3374 :
3375 : /* Update current procedure's array_outer_dependency flag, considering
3376 : a call to procedure SYM. */
3377 :
3378 : static void
3379 136314 : update_current_proc_array_outer_dependency (gfc_symbol *sym)
3380 : {
3381 : /* Check to see if this is a sibling function that has not yet
3382 : been resolved. */
3383 136314 : gfc_namespace *sibling = gfc_current_ns->sibling;
3384 254813 : for (; sibling; sibling = sibling->sibling)
3385 : {
3386 125823 : if (sibling->proc_name == sym)
3387 : {
3388 7324 : gfc_resolve (sibling);
3389 7324 : break;
3390 : }
3391 : }
3392 :
3393 : /* If SYM has references to outer arrays, so has the procedure calling
3394 : SYM. If SYM is a procedure pointer, we can assume the worst. */
3395 136314 : if ((sym->attr.array_outer_dependency || sym->attr.proc_pointer)
3396 69355 : && gfc_current_ns->proc_name)
3397 69311 : gfc_current_ns->proc_name->attr.array_outer_dependency = 1;
3398 136314 : }
3399 :
3400 :
3401 : /* Resolve a function call, which means resolving the arguments, then figuring
3402 : out which entity the name refers to. */
3403 :
3404 : static bool
3405 355135 : resolve_function (gfc_expr *expr)
3406 : {
3407 355135 : gfc_actual_arglist *arg;
3408 355135 : gfc_symbol *sym;
3409 355135 : bool t;
3410 355135 : int temp;
3411 355135 : procedure_type p = PROC_INTRINSIC;
3412 355135 : bool no_formal_args;
3413 :
3414 355135 : sym = NULL;
3415 355135 : if (expr->symtree)
3416 354761 : sym = expr->symtree->n.sym;
3417 :
3418 : /* If this is a procedure pointer component, it has already been resolved. */
3419 355135 : if (gfc_is_proc_ptr_comp (expr))
3420 : return true;
3421 :
3422 : /* Avoid re-resolving the arguments of caf_get, which can lead to inserting
3423 : another caf_get. */
3424 354719 : if (sym && sym->attr.intrinsic
3425 8786 : && (sym->intmod_sym_id == GFC_ISYM_CAF_GET
3426 8786 : || sym->intmod_sym_id == GFC_ISYM_CAF_SEND))
3427 : return true;
3428 :
3429 354719 : if (expr->ref)
3430 : {
3431 1 : gfc_error ("Unexpected junk after %qs at %L", expr->symtree->n.sym->name,
3432 : &expr->where);
3433 1 : return false;
3434 : }
3435 :
3436 354344 : if (sym && sym->attr.intrinsic
3437 363504 : && !gfc_resolve_intrinsic (sym, &expr->where))
3438 : return false;
3439 :
3440 354718 : if (sym && (sym->attr.flavor == FL_VARIABLE || sym->attr.subroutine))
3441 : {
3442 4 : gfc_error ("%qs at %L is not a function", sym->name, &expr->where);
3443 4 : return false;
3444 : }
3445 :
3446 : /* If this is a deferred TBP with an abstract interface (which may
3447 : of course be referenced), expr->value.function.esym will be set. */
3448 354340 : if (sym && sym->attr.abstract && !expr->value.function.esym)
3449 : {
3450 1 : gfc_error ("ABSTRACT INTERFACE %qs must not be referenced at %L",
3451 : sym->name, &expr->where);
3452 1 : return false;
3453 : }
3454 :
3455 : /* If this is a deferred TBP with an abstract interface, its result
3456 : cannot be an assumed length character (F2003: C418). */
3457 354339 : if (sym && sym->attr.abstract && sym->attr.function
3458 192 : && sym->result->ts.u.cl
3459 158 : && sym->result->ts.u.cl->length == NULL
3460 2 : && !sym->result->ts.deferred)
3461 : {
3462 1 : gfc_error ("ABSTRACT INTERFACE %qs at %L must not have an assumed "
3463 : "character length result (F2008: C418)", sym->name,
3464 : &sym->declared_at);
3465 1 : return false;
3466 : }
3467 :
3468 : /* Switch off assumed size checking and do this again for certain kinds
3469 : of procedure, once the procedure itself is resolved. */
3470 354712 : need_full_assumed_size++;
3471 :
3472 354712 : if (expr->symtree && expr->symtree->n.sym)
3473 354338 : p = expr->symtree->n.sym->attr.proc;
3474 :
3475 354712 : if (expr->value.function.isym && expr->value.function.isym->inquiry)
3476 1260 : inquiry_argument = true;
3477 354338 : no_formal_args = sym && is_external_proc (sym)
3478 369046 : && gfc_sym_get_dummy_args (sym) == NULL;
3479 :
3480 354712 : if (!resolve_actual_arglist (expr->value.function.actual,
3481 : p, no_formal_args))
3482 : {
3483 67 : inquiry_argument = false;
3484 67 : return false;
3485 : }
3486 :
3487 354645 : inquiry_argument = false;
3488 :
3489 : /* Resume assumed_size checking. */
3490 354645 : need_full_assumed_size--;
3491 :
3492 : /* If the procedure is external, check for usage. */
3493 354645 : if (sym && is_external_proc (sym))
3494 14314 : resolve_global_procedure (sym, &expr->where, 0);
3495 :
3496 354645 : if (sym && sym->ts.type == BT_CHARACTER
3497 3437 : && sym->ts.u.cl
3498 3343 : && sym->ts.u.cl->length == NULL
3499 701 : && !sym->attr.dummy
3500 694 : && !sym->ts.deferred
3501 2 : && expr->value.function.esym == NULL
3502 2 : && !sym->attr.contained)
3503 : {
3504 : /* Internal procedures are taken care of in resolve_contained_fntype. */
3505 1 : gfc_error ("Function %qs is declared CHARACTER(*) and cannot "
3506 : "be used at %L since it is not a dummy argument",
3507 : sym->name, &expr->where);
3508 1 : return false;
3509 : }
3510 :
3511 : /* Add and check formal interface when -fc-prototypes-external is in
3512 : force, see comment in resolve_call(). */
3513 :
3514 354644 : if (warn_external_argument_mismatch && sym && sym->attr.dummy
3515 18 : && sym->attr.external)
3516 : {
3517 18 : if (sym->formal)
3518 : {
3519 6 : bool conflict;
3520 6 : conflict = !gfc_compare_actual_formal (&expr->value.function.actual,
3521 : sym->formal, 0, 0, 0, NULL);
3522 6 : if (conflict)
3523 : {
3524 6 : sym->ext_dummy_arglist_mismatch = 1;
3525 6 : gfc_warning (OPT_Wexternal_argument_mismatch,
3526 : "Different argument lists in external dummy "
3527 : "function %s at %L and %L", sym->name,
3528 : &expr->where, &sym->other_loc);
3529 : }
3530 : }
3531 12 : else if (!sym->formal_resolved)
3532 : {
3533 6 : gfc_get_formal_from_actual_arglist (sym, expr->value.function.actual);
3534 6 : sym->other_loc = expr->where;
3535 : }
3536 : }
3537 : /* See if function is already resolved. */
3538 :
3539 354644 : if (expr->value.function.name != NULL
3540 341734 : || expr->value.function.isym != NULL)
3541 : {
3542 13768 : if (expr->ts.type == BT_UNKNOWN)
3543 3 : expr->ts = sym->ts;
3544 : t = true;
3545 : }
3546 : else
3547 : {
3548 : /* Apply the rules of section 14.1.2. */
3549 :
3550 340876 : switch (procedure_kind (sym))
3551 : {
3552 28387 : case PTYPE_GENERIC:
3553 28387 : t = resolve_generic_f (expr);
3554 28387 : break;
3555 :
3556 29087 : case PTYPE_SPECIFIC:
3557 29087 : t = resolve_specific_f (expr);
3558 29087 : break;
3559 :
3560 283402 : case PTYPE_UNKNOWN:
3561 283402 : t = resolve_unknown_f (expr);
3562 283402 : break;
3563 :
3564 : default:
3565 : gfc_internal_error ("resolve_function(): bad function type");
3566 : }
3567 : }
3568 :
3569 : /* If the expression is still a function (it might have simplified),
3570 : then we check to see if we are calling an elemental function. */
3571 :
3572 354644 : if (expr->expr_type != EXPR_FUNCTION)
3573 : return t;
3574 :
3575 : /* Walk the argument list looking for invalid BOZ. */
3576 760647 : for (arg = expr->value.function.actual; arg; arg = arg->next)
3577 509213 : if (arg->expr && arg->expr->ts.type == BT_BOZ)
3578 : {
3579 5 : gfc_error ("A BOZ literal constant at %L cannot appear as an "
3580 : "actual argument in a function reference",
3581 : &arg->expr->where);
3582 5 : return false;
3583 : }
3584 :
3585 251434 : temp = need_full_assumed_size;
3586 251434 : need_full_assumed_size = 0;
3587 :
3588 251434 : if (!resolve_elemental_actual (expr, NULL))
3589 : return false;
3590 :
3591 251431 : if (omp_workshare_flag
3592 32 : && expr->value.function.esym
3593 251436 : && ! gfc_elemental (expr->value.function.esym))
3594 : {
3595 4 : gfc_error ("User defined non-ELEMENTAL function %qs at %L not allowed "
3596 4 : "in WORKSHARE construct", expr->value.function.esym->name,
3597 : &expr->where);
3598 4 : t = false;
3599 : }
3600 :
3601 : #define GENERIC_ID expr->value.function.isym->id
3602 251427 : else if (expr->value.function.actual != NULL
3603 242821 : && expr->value.function.isym != NULL
3604 196972 : && GENERIC_ID != GFC_ISYM_LBOUND
3605 : && GENERIC_ID != GFC_ISYM_LCOBOUND
3606 : && GENERIC_ID != GFC_ISYM_UCOBOUND
3607 : && GENERIC_ID != GFC_ISYM_LEN
3608 : && GENERIC_ID != GFC_ISYM_LOC
3609 : && GENERIC_ID != GFC_ISYM_C_LOC
3610 : && GENERIC_ID != GFC_ISYM_PRESENT)
3611 : {
3612 : /* Array intrinsics must also have the last upper bound of an
3613 : assumed size array argument. UBOUND and SIZE have to be
3614 : excluded from the check if the second argument is anything
3615 : than a constant. */
3616 :
3617 554249 : for (arg = expr->value.function.actual; arg; arg = arg->next)
3618 : {
3619 383630 : if ((GENERIC_ID == GFC_ISYM_UBOUND || GENERIC_ID == GFC_ISYM_SIZE)
3620 46958 : && arg == expr->value.function.actual
3621 17280 : && arg->next != NULL && arg->next->expr)
3622 : {
3623 8483 : if (arg->next->expr->expr_type != EXPR_CONSTANT)
3624 : break;
3625 :
3626 8259 : if (arg->next->name && strcmp (arg->next->name, "kind") == 0)
3627 : break;
3628 :
3629 8259 : if ((int)mpz_get_si (arg->next->expr->value.integer)
3630 8259 : < arg->expr->rank)
3631 : break;
3632 : }
3633 :
3634 381191 : if (arg->expr != NULL
3635 253145 : && arg->expr->rank > 0
3636 502916 : && resolve_assumed_size_actual (arg->expr))
3637 : return false;
3638 : }
3639 : }
3640 : #undef GENERIC_ID
3641 :
3642 251428 : need_full_assumed_size = temp;
3643 :
3644 251428 : if (!check_pure_function(expr))
3645 12 : t = false;
3646 :
3647 : /* Functions without the RECURSIVE attribution are not allowed to
3648 : * call themselves. */
3649 251428 : if (expr->value.function.esym && !expr->value.function.esym->attr.recursive)
3650 : {
3651 52941 : gfc_symbol *esym;
3652 52941 : esym = expr->value.function.esym;
3653 :
3654 52941 : if (is_illegal_recursion (esym, gfc_current_ns))
3655 : {
3656 5 : if (esym->attr.entry && esym->ns->entries)
3657 3 : gfc_error ("ENTRY %qs at %L cannot be called recursively, as"
3658 : " function %qs is not RECURSIVE",
3659 3 : esym->name, &expr->where, esym->ns->entries->sym->name);
3660 : else
3661 2 : gfc_error ("Function %qs at %L cannot be called recursively, as it"
3662 : " is not RECURSIVE", esym->name, &expr->where);
3663 :
3664 : t = false;
3665 : }
3666 : }
3667 :
3668 : /* Character lengths of use associated functions may contains references to
3669 : symbols not referenced from the current program unit otherwise. Make sure
3670 : those symbols are marked as referenced. */
3671 :
3672 251428 : if (expr->ts.type == BT_CHARACTER && expr->value.function.esym
3673 3541 : && expr->value.function.esym->attr.use_assoc)
3674 : {
3675 1328 : gfc_expr_set_symbols_referenced (expr->ts.u.cl->length);
3676 : }
3677 :
3678 : /* Make sure that the expression has a typespec that works. */
3679 251428 : if (expr->ts.type == BT_UNKNOWN)
3680 : {
3681 930 : if (expr->symtree->n.sym->result
3682 921 : && expr->symtree->n.sym->result->ts.type != BT_UNKNOWN
3683 561 : && !expr->symtree->n.sym->result->attr.proc_pointer)
3684 561 : expr->ts = expr->symtree->n.sym->result->ts;
3685 : }
3686 :
3687 : /* These derived types with an incomplete namespace, arising from use
3688 : association, cause gfc_get_derived_vtab to segfault. If the function
3689 : namespace does not suffice, something is badly wrong. */
3690 251428 : if (expr->ts.type == BT_DERIVED
3691 9830 : && !expr->ts.u.derived->ns->proc_name)
3692 : {
3693 3 : gfc_symbol *der;
3694 3 : gfc_find_symbol (expr->ts.u.derived->name, expr->symtree->n.sym->ns, 1, &der);
3695 3 : if (der)
3696 : {
3697 3 : expr->ts.u.derived->refs--;
3698 3 : expr->ts.u.derived = der;
3699 3 : der->refs++;
3700 : }
3701 : else
3702 0 : expr->ts.u.derived->ns = expr->symtree->n.sym->ns;
3703 : }
3704 :
3705 251428 : if (!expr->ref && !expr->value.function.isym)
3706 : {
3707 54335 : if (expr->value.function.esym)
3708 53253 : update_current_proc_array_outer_dependency (expr->value.function.esym);
3709 : else
3710 1082 : update_current_proc_array_outer_dependency (sym);
3711 : }
3712 197093 : else if (expr->ref)
3713 : /* typebound procedure: Assume the worst. */
3714 0 : gfc_current_ns->proc_name->attr.array_outer_dependency = 1;
3715 :
3716 251428 : if (expr->value.function.esym
3717 53253 : && expr->value.function.esym->attr.ext_attr & (1 << EXT_ATTR_DEPRECATED))
3718 26 : gfc_warning (OPT_Wdeprecated_declarations,
3719 : "Using function %qs at %L is deprecated",
3720 : sym->name, &expr->where);
3721 :
3722 : /* Check an external function supplied as a dummy argument has an external
3723 : attribute when a program unit uses 'implicit none (external)'. */
3724 251428 : if (expr->expr_type == EXPR_FUNCTION
3725 251428 : && expr->symtree
3726 251054 : && expr->symtree->n.sym->attr.dummy
3727 574 : && expr->symtree->n.sym->ns->has_implicit_none_export
3728 251429 : && !gfc_is_intrinsic(expr->symtree->n.sym, 0, expr->where))
3729 : {
3730 1 : gfc_error ("Dummy procedure %qs at %L requires an EXTERNAL attribute",
3731 : sym->name, &expr->where);
3732 1 : return false;
3733 : }
3734 :
3735 : return t;
3736 : }
3737 :
3738 :
3739 : /************* Subroutine resolution *************/
3740 :
3741 : static bool
3742 79409 : pure_subroutine (gfc_symbol *sym, const char *name, locus *loc)
3743 : {
3744 79409 : code_stack *stack;
3745 79409 : bool saw_block = false;
3746 :
3747 79409 : if (gfc_pure (sym))
3748 : return true;
3749 :
3750 : /* A BLOCK construct within a DO CONCURRENT construct leads to
3751 : gfc_do_concurrent_flag = 0 when the check for an impure subroutine
3752 : occurs. Walk up the stack to see if the source code has a nested
3753 : construct. */
3754 :
3755 163874 : for (stack = cs_base; stack; stack = stack->prev)
3756 : {
3757 90128 : if (stack->current->op == EXEC_BLOCK)
3758 : {
3759 1995 : saw_block = true;
3760 1995 : continue;
3761 : }
3762 :
3763 88133 : if (saw_block && stack->current->op == EXEC_DO_CONCURRENT)
3764 : {
3765 :
3766 2 : bool is_pure = true;
3767 90128 : is_pure = sym->attr.pure || sym->attr.elemental;
3768 :
3769 2 : if (!is_pure)
3770 : {
3771 2 : gfc_error ("Subroutine call at %L in a DO CONCURRENT block "
3772 : "is not PURE", loc);
3773 2 : return false;
3774 : }
3775 : }
3776 : }
3777 :
3778 73746 : if (forall_flag)
3779 : {
3780 0 : gfc_error ("Subroutine call to %qs in FORALL block at %L is not PURE",
3781 : name, loc);
3782 0 : return false;
3783 : }
3784 73746 : else if (gfc_do_concurrent_flag)
3785 : {
3786 6 : gfc_error ("Subroutine call to %qs in DO CONCURRENT block at %L is not "
3787 : "PURE", name, loc);
3788 6 : return false;
3789 : }
3790 73740 : else if (gfc_pure (NULL))
3791 : {
3792 4 : gfc_error ("Subroutine call to %qs at %L is not PURE", name, loc);
3793 4 : return false;
3794 : }
3795 :
3796 73736 : gfc_unset_implicit_pure (NULL);
3797 73736 : return true;
3798 : }
3799 :
3800 :
3801 : static match
3802 2892 : resolve_generic_s0 (gfc_code *c, gfc_symbol *sym)
3803 : {
3804 2892 : gfc_symbol *s;
3805 :
3806 2892 : if (sym->attr.generic)
3807 : {
3808 2891 : s = gfc_search_interface (sym->generic, 1, &c->ext.actual);
3809 2891 : if (s != NULL)
3810 : {
3811 2882 : c->resolved_sym = s;
3812 2882 : if (!pure_subroutine (s, s->name, &c->loc))
3813 : return MATCH_ERROR;
3814 2882 : return MATCH_YES;
3815 : }
3816 :
3817 : /* TODO: Need to search for elemental references in generic interface. */
3818 : }
3819 :
3820 10 : if (sym->attr.intrinsic)
3821 1 : return gfc_intrinsic_sub_interface (c, 0);
3822 :
3823 : return MATCH_NO;
3824 : }
3825 :
3826 :
3827 : static bool
3828 2890 : resolve_generic_s (gfc_code *c)
3829 : {
3830 2890 : gfc_symbol *sym;
3831 2890 : match m;
3832 :
3833 2890 : sym = c->symtree->n.sym;
3834 :
3835 2892 : for (;;)
3836 : {
3837 2892 : m = resolve_generic_s0 (c, sym);
3838 2892 : if (m == MATCH_YES)
3839 : return true;
3840 9 : else if (m == MATCH_ERROR)
3841 : return false;
3842 :
3843 9 : generic:
3844 9 : if (sym->ns->parent == NULL)
3845 : break;
3846 3 : gfc_find_symbol (sym->name, sym->ns->parent, 1, &sym);
3847 :
3848 3 : if (sym == NULL)
3849 : break;
3850 2 : if (!generic_sym (sym))
3851 0 : goto generic;
3852 : }
3853 :
3854 : /* Last ditch attempt. See if the reference is to an intrinsic
3855 : that possesses a matching interface. 14.1.2.4 */
3856 7 : sym = c->symtree->n.sym;
3857 :
3858 7 : if (!gfc_is_intrinsic (sym, 1, c->loc))
3859 : {
3860 4 : gfc_error ("There is no specific subroutine for the generic %qs at %L",
3861 : sym->name, &c->loc);
3862 4 : return false;
3863 : }
3864 :
3865 3 : m = gfc_intrinsic_sub_interface (c, 0);
3866 3 : if (m == MATCH_YES)
3867 : return true;
3868 1 : if (m == MATCH_NO)
3869 1 : gfc_error ("Generic subroutine %qs at %L is not consistent with an "
3870 : "intrinsic subroutine interface", sym->name, &c->loc);
3871 :
3872 : return false;
3873 : }
3874 :
3875 :
3876 : /* Resolve a subroutine call known to be specific. */
3877 :
3878 : static match
3879 64774 : resolve_specific_s0 (gfc_code *c, gfc_symbol *sym)
3880 : {
3881 64774 : match m;
3882 :
3883 64774 : if (sym->attr.external || sym->attr.if_source == IFSRC_IFBODY)
3884 : {
3885 5747 : if (sym->attr.dummy)
3886 : {
3887 263 : sym->attr.proc = PROC_DUMMY;
3888 263 : goto found;
3889 : }
3890 :
3891 5484 : sym->attr.proc = PROC_EXTERNAL;
3892 5484 : goto found;
3893 : }
3894 :
3895 59027 : if (sym->attr.proc == PROC_MODULE || sym->attr.proc == PROC_INTERNAL)
3896 59021 : goto found;
3897 :
3898 6 : if (sym->attr.intrinsic)
3899 : {
3900 0 : m = gfc_intrinsic_sub_interface (c, 1);
3901 0 : if (m == MATCH_YES)
3902 : return MATCH_YES;
3903 0 : if (m == MATCH_NO)
3904 0 : gfc_error ("Subroutine %qs at %L is INTRINSIC but is not compatible "
3905 : "with an intrinsic", sym->name, &c->loc);
3906 :
3907 : return MATCH_ERROR;
3908 : }
3909 :
3910 : return MATCH_NO;
3911 :
3912 64768 : found:
3913 64768 : gfc_procedure_use (sym, &c->ext.actual, &c->loc);
3914 :
3915 64768 : c->resolved_sym = sym;
3916 64768 : if (!pure_subroutine (sym, sym->name, &c->loc))
3917 7 : return MATCH_ERROR;
3918 :
3919 : return MATCH_YES;
3920 : }
3921 :
3922 :
3923 : static bool
3924 64768 : resolve_specific_s (gfc_code *c)
3925 : {
3926 64768 : gfc_symbol *sym;
3927 64768 : match m;
3928 :
3929 64768 : sym = c->symtree->n.sym;
3930 :
3931 64774 : for (;;)
3932 : {
3933 64774 : m = resolve_specific_s0 (c, sym);
3934 64774 : if (m == MATCH_YES)
3935 : return true;
3936 13 : if (m == MATCH_ERROR)
3937 : return false;
3938 :
3939 6 : if (sym->ns->parent == NULL)
3940 : break;
3941 :
3942 6 : gfc_find_symbol (sym->name, sym->ns->parent, 1, &sym);
3943 :
3944 6 : if (sym == NULL)
3945 : break;
3946 : }
3947 :
3948 0 : sym = c->symtree->n.sym;
3949 0 : gfc_error ("Unable to resolve the specific subroutine %qs at %L",
3950 : sym->name, &c->loc);
3951 :
3952 0 : return false;
3953 : }
3954 :
3955 :
3956 : /* Resolve a subroutine call not known to be generic nor specific. */
3957 :
3958 : static bool
3959 15987 : resolve_unknown_s (gfc_code *c)
3960 : {
3961 15987 : gfc_symbol *sym;
3962 :
3963 15987 : sym = c->symtree->n.sym;
3964 :
3965 15987 : if (sym->attr.dummy)
3966 : {
3967 26 : sym->attr.proc = PROC_DUMMY;
3968 26 : goto found;
3969 : }
3970 :
3971 : /* See if we have an intrinsic function reference. */
3972 :
3973 15961 : if (gfc_is_intrinsic (sym, 1, c->loc))
3974 : {
3975 4351 : if (gfc_intrinsic_sub_interface (c, 1) == MATCH_YES)
3976 : return true;
3977 319 : return false;
3978 : }
3979 :
3980 : /* The reference is to an external name. */
3981 :
3982 11610 : found:
3983 11636 : gfc_procedure_use (sym, &c->ext.actual, &c->loc);
3984 :
3985 11636 : c->resolved_sym = sym;
3986 :
3987 11636 : return pure_subroutine (sym, sym->name, &c->loc);
3988 : }
3989 :
3990 :
3991 :
3992 : static bool
3993 805 : check_sym_import_status (gfc_symbol *sym, gfc_symtree *s, gfc_expr *e,
3994 : gfc_code *c, gfc_namespace *ns)
3995 : {
3996 805 : locus *here;
3997 :
3998 : /* If the type has been imported then its vtype functions are OK. */
3999 805 : if (e && e->expr_type == EXPR_FUNCTION && sym->attr.vtype)
4000 : return true;
4001 :
4002 : if (e)
4003 791 : here = &e->where;
4004 : else
4005 7 : here = &c->loc;
4006 :
4007 798 : if (s && !s->import_only)
4008 705 : s = gfc_find_symtree (ns->sym_root, sym->name);
4009 :
4010 798 : if (ns->import_state == IMPORT_ONLY
4011 75 : && sym->ns != ns
4012 58 : && (!s || !s->import_only))
4013 : {
4014 21 : gfc_error ("F2018: C8102 %qs at %L is host associated but does not "
4015 : "appear in an IMPORT or IMPORT, ONLY list", sym->name, here);
4016 21 : return false;
4017 : }
4018 777 : else if (ns->import_state == IMPORT_NONE
4019 27 : && sym->ns != ns)
4020 : {
4021 12 : gfc_error ("F2018: C8102 %qs at %L is host associated in a scope that "
4022 : "has IMPORT, NONE", sym->name, here);
4023 12 : return false;
4024 : }
4025 : return true;
4026 : }
4027 :
4028 :
4029 : static bool
4030 7726 : check_import_status (gfc_expr *e)
4031 : {
4032 7726 : gfc_symtree *st;
4033 7726 : gfc_ref *ref;
4034 7726 : gfc_symbol *sym, *der;
4035 7726 : gfc_namespace *ns = gfc_current_ns;
4036 :
4037 7726 : switch (e->expr_type)
4038 : {
4039 727 : case EXPR_VARIABLE:
4040 727 : case EXPR_FUNCTION:
4041 727 : case EXPR_SUBSTRING:
4042 727 : sym = e->symtree ? e->symtree->n.sym : NULL;
4043 :
4044 : /* Check the symbol itself. */
4045 727 : if (sym
4046 727 : && !(ns->proc_name
4047 : && (sym == ns->proc_name))
4048 1450 : && !check_sym_import_status (sym, e->symtree, e, NULL, ns))
4049 : return false;
4050 :
4051 : /* Check the declared derived type. */
4052 717 : if (sym->ts.type == BT_DERIVED)
4053 : {
4054 16 : der = sym->ts.u.derived;
4055 16 : st = gfc_find_symtree (ns->sym_root, der->name);
4056 :
4057 16 : if (!check_sym_import_status (der, st, e, NULL, ns))
4058 : return false;
4059 : }
4060 701 : else if (sym->ts.type == BT_CLASS && !UNLIMITED_POLY (sym))
4061 : {
4062 44 : der = CLASS_DATA (sym) ? CLASS_DATA (sym)->ts.u.derived
4063 : : sym->ts.u.derived;
4064 44 : st = gfc_find_symtree (ns->sym_root, der->name);
4065 :
4066 44 : if (!check_sym_import_status (der, st, e, NULL, ns))
4067 : return false;
4068 : }
4069 :
4070 : /* Check the declared derived types of component references. */
4071 724 : for (ref = e->ref; ref; ref = ref->next)
4072 20 : if (ref->type == REF_COMPONENT)
4073 : {
4074 19 : gfc_component *c = ref->u.c.component;
4075 19 : if (c->ts.type == BT_DERIVED)
4076 : {
4077 7 : der = c->ts.u.derived;
4078 7 : st = gfc_find_symtree (ns->sym_root, der->name);
4079 7 : if (!check_sym_import_status (der, st, e, NULL, ns))
4080 : return false;
4081 : }
4082 12 : else if (c->ts.type == BT_CLASS && !UNLIMITED_POLY (c))
4083 : {
4084 0 : der = CLASS_DATA (c) ? CLASS_DATA (c)->ts.u.derived
4085 : : c->ts.u.derived;
4086 0 : st = gfc_find_symtree (ns->sym_root, der->name);
4087 0 : if (!check_sym_import_status (der, st, e, NULL, ns))
4088 : return false;
4089 : }
4090 : }
4091 :
4092 : break;
4093 :
4094 8 : case EXPR_ARRAY:
4095 8 : case EXPR_STRUCTURE:
4096 : /* Check the declared derived type. */
4097 8 : if (e->ts.type == BT_DERIVED)
4098 : {
4099 8 : der = e->ts.u.derived;
4100 8 : st = gfc_find_symtree (ns->sym_root, der->name);
4101 :
4102 8 : if (!check_sym_import_status (der, st, e, NULL, ns))
4103 : return false;
4104 : }
4105 0 : else if (e->ts.type == BT_CLASS && !UNLIMITED_POLY (e))
4106 : {
4107 0 : der = CLASS_DATA (e) ? CLASS_DATA (e)->ts.u.derived
4108 : : e->ts.u.derived;
4109 0 : st = gfc_find_symtree (ns->sym_root, der->name);
4110 :
4111 0 : if (!check_sym_import_status (der, st, e, NULL, ns))
4112 : return false;
4113 : }
4114 :
4115 : break;
4116 :
4117 : /* Either not applicable or resolved away
4118 : case EXPR_OP:
4119 : case EXPR_UNKNOWN:
4120 : case EXPR_CONSTANT:
4121 : case EXPR_NULL:
4122 : case EXPR_COMPCALL:
4123 : case EXPR_PPC: */
4124 :
4125 : default:
4126 : break;
4127 : }
4128 :
4129 : return true;
4130 : }
4131 :
4132 :
4133 : /* If an elemental call has an INTENT_IN argument that has a dependency on an
4134 : argument which is not INTENT_IN and requires a temporary, build a temporary
4135 : for the INTENT_IN actual argument as well. */
4136 :
4137 : static void
4138 : add_temp_assign_before_call (gfc_code *, gfc_namespace *, gfc_expr **);
4139 :
4140 : static void
4141 5257 : resolve_elemental_dependencies (gfc_code *c)
4142 : {
4143 5257 : gfc_actual_arglist *arg1 = c->ext.actual;
4144 5257 : gfc_actual_arglist *arg2 = NULL;
4145 5257 : gfc_formal_arglist *formal1 = c->resolved_sym->formal;
4146 5257 : gfc_formal_arglist *formal2 = NULL;
4147 5257 : gfc_expr *expr1;
4148 5257 : gfc_expr **expr2;
4149 :
4150 16645 : for (; arg1 && formal1; arg1 = arg1->next, formal1 = formal1->next)
4151 : {
4152 11388 : if (formal1->sym
4153 11388 : && (formal1->sym->attr.intent == INTENT_IN
4154 3536 : || formal1->sym->attr.value))
4155 8110 : continue;
4156 :
4157 3278 : if (!arg1->expr || arg1->expr->expr_type != EXPR_VARIABLE)
4158 0 : continue;
4159 :
4160 3278 : arg2 = c->ext.actual;
4161 3278 : formal2 = c->resolved_sym->formal;
4162 10696 : for (; arg2 && formal2; arg2 = arg2->next, formal2 = formal2->next)
4163 : {
4164 7418 : if (arg2 == arg1 || !arg2->expr
4165 4128 : || !(formal2->sym && formal2->sym->attr.intent == INTENT_IN))
4166 3304 : continue;
4167 :
4168 4114 : expr1 = arg1->expr;
4169 4114 : expr2 = &arg2->expr;
4170 :
4171 : /* If the arg1 has something horrible like a vector index and
4172 : there is a dependency between arg1 and arg2, build a
4173 : temporary from arg2, assign the arg2 to it and use the
4174 : temporary in the call expression. */
4175 2009 : if (expr1->rank && gfc_ref_needs_temporary_p (expr1->ref)
4176 4234 : && gfc_check_dependency (expr1, *expr2, false))
4177 36 : add_temp_assign_before_call (c, gfc_current_ns, expr2);
4178 : }
4179 : }
4180 5257 : }
4181 :
4182 : /* Resolve a subroutine call. Although it was tempting to use the same code
4183 : for functions, subroutines and functions are stored differently and this
4184 : makes things awkward. */
4185 :
4186 :
4187 : static bool
4188 83793 : resolve_call (gfc_code *c)
4189 : {
4190 83793 : bool t;
4191 83793 : procedure_type ptype = PROC_INTRINSIC;
4192 83793 : gfc_symbol *csym, *sym;
4193 83793 : bool no_formal_args;
4194 :
4195 83793 : csym = c->symtree ? c->symtree->n.sym : NULL;
4196 :
4197 83793 : if (csym && csym->ts.type != BT_UNKNOWN)
4198 : {
4199 4 : gfc_error ("%qs at %L has a type, which is not consistent with "
4200 : "the CALL at %L", csym->name, &csym->declared_at, &c->loc);
4201 4 : return false;
4202 : }
4203 :
4204 83789 : if (csym && gfc_current_ns->parent && csym->ns != gfc_current_ns)
4205 : {
4206 17814 : gfc_symtree *st;
4207 17814 : gfc_find_sym_tree (c->symtree->name, gfc_current_ns, 1, &st);
4208 17814 : sym = st ? st->n.sym : NULL;
4209 17814 : if (sym && csym != sym
4210 3 : && sym->ns == gfc_current_ns
4211 3 : && sym->attr.flavor == FL_PROCEDURE
4212 3 : && sym->attr.contained)
4213 : {
4214 3 : sym->refs++;
4215 3 : if (csym->attr.generic)
4216 2 : c->symtree->n.sym = sym;
4217 : else
4218 1 : c->symtree = st;
4219 3 : csym = c->symtree->n.sym;
4220 : }
4221 : }
4222 :
4223 : /* If this ia a deferred TBP, c->expr1 will be set. */
4224 83789 : if (!c->expr1 && csym)
4225 : {
4226 82024 : if (csym->attr.abstract)
4227 : {
4228 1 : gfc_error ("ABSTRACT INTERFACE %qs must not be referenced at %L",
4229 : csym->name, &c->loc);
4230 1 : return false;
4231 : }
4232 :
4233 : /* Subroutines without the RECURSIVE attribution are not allowed to
4234 : call themselves. */
4235 82023 : if (is_illegal_recursion (csym, gfc_current_ns))
4236 : {
4237 4 : if (csym->attr.entry && csym->ns->entries)
4238 2 : gfc_error ("ENTRY %qs at %L cannot be called recursively, "
4239 : "as subroutine %qs is not RECURSIVE",
4240 2 : csym->name, &c->loc, csym->ns->entries->sym->name);
4241 : else
4242 2 : gfc_error ("SUBROUTINE %qs at %L cannot be called recursively, "
4243 : "as it is not RECURSIVE", csym->name, &c->loc);
4244 :
4245 83788 : t = false;
4246 : }
4247 : }
4248 :
4249 : /* Switch off assumed size checking and do this again for certain kinds
4250 : of procedure, once the procedure itself is resolved. */
4251 83788 : need_full_assumed_size++;
4252 :
4253 83788 : if (csym)
4254 83788 : ptype = csym->attr.proc;
4255 :
4256 83788 : no_formal_args = csym && is_external_proc (csym)
4257 15742 : && gfc_sym_get_dummy_args (csym) == NULL;
4258 83788 : if (!resolve_actual_arglist (c->ext.actual, ptype, no_formal_args))
4259 : return false;
4260 :
4261 : /* Resume assumed_size checking. */
4262 83754 : need_full_assumed_size--;
4263 :
4264 : /* If 'implicit none (external)' and the symbol is a dummy argument,
4265 : check for an 'external' attribute. */
4266 83754 : if (csym->ns->has_implicit_none_export
4267 4506 : && csym->attr.external == 0 && csym->attr.dummy == 1)
4268 : {
4269 1 : gfc_error ("Dummy procedure %qs at %L requires an EXTERNAL attribute",
4270 : csym->name, &c->loc);
4271 1 : return false;
4272 : }
4273 :
4274 : /* If external, check for usage. */
4275 83753 : if (csym && is_external_proc (csym))
4276 15736 : resolve_global_procedure (csym, &c->loc, 1);
4277 :
4278 : /* If we have an external dummy argument, we want to write out its arguments
4279 : with -fc-prototypes-external. Code like
4280 :
4281 : subroutine foo(a,n)
4282 : external a
4283 : if (n == 1) call a(1)
4284 : if (n == 2) call a(2,3)
4285 : end subroutine foo
4286 :
4287 : is actually legal Fortran, but it is not possible to generate a C23-
4288 : compliant prototype for this, so we just record the fact here and
4289 : handle that during -fc-prototypes-external processing. */
4290 :
4291 83753 : if (warn_external_argument_mismatch && csym && csym->attr.dummy
4292 14 : && csym->attr.external)
4293 : {
4294 14 : if (csym->formal)
4295 : {
4296 6 : bool conflict;
4297 6 : conflict = !gfc_compare_actual_formal (&c->ext.actual, csym->formal,
4298 : 0, 0, 0, NULL);
4299 6 : if (conflict)
4300 : {
4301 6 : csym->ext_dummy_arglist_mismatch = 1;
4302 6 : gfc_warning (OPT_Wexternal_argument_mismatch,
4303 : "Different argument lists in external dummy "
4304 : "subroutine %s at %L and %L", csym->name,
4305 : &c->loc, &csym->other_loc);
4306 : }
4307 : }
4308 8 : else if (!csym->formal_resolved)
4309 : {
4310 7 : gfc_get_formal_from_actual_arglist (csym, c->ext.actual);
4311 7 : csym->other_loc = c->loc;
4312 : }
4313 : }
4314 :
4315 83753 : t = true;
4316 83753 : if (c->resolved_sym == NULL)
4317 : {
4318 83645 : c->resolved_isym = NULL;
4319 83645 : switch (procedure_kind (csym))
4320 : {
4321 2890 : case PTYPE_GENERIC:
4322 2890 : t = resolve_generic_s (c);
4323 2890 : break;
4324 :
4325 64768 : case PTYPE_SPECIFIC:
4326 64768 : t = resolve_specific_s (c);
4327 64768 : break;
4328 :
4329 15987 : case PTYPE_UNKNOWN:
4330 15987 : t = resolve_unknown_s (c);
4331 15987 : break;
4332 :
4333 : default:
4334 : gfc_internal_error ("resolve_subroutine(): bad function type");
4335 : }
4336 : }
4337 :
4338 : /* Some checks of elemental subroutine actual arguments. */
4339 83752 : if (!resolve_elemental_actual (NULL, c))
4340 : return false;
4341 :
4342 : /* Deal with complicated dependencies that the scalarizer cannot handle. */
4343 83744 : if (c->resolved_sym && c->resolved_sym->attr.elemental && !no_formal_args
4344 6212 : && c->ext.actual && c->ext.actual->next)
4345 5257 : resolve_elemental_dependencies (c);
4346 :
4347 83744 : if (!c->expr1)
4348 81979 : update_current_proc_array_outer_dependency (csym);
4349 : else
4350 : /* Typebound procedure: Assume the worst. */
4351 1765 : gfc_current_ns->proc_name->attr.array_outer_dependency = 1;
4352 :
4353 83744 : if (c->resolved_sym
4354 83421 : && c->resolved_sym->attr.ext_attr & (1 << EXT_ATTR_DEPRECATED))
4355 34 : gfc_warning (OPT_Wdeprecated_declarations,
4356 : "Using subroutine %qs at %L is deprecated",
4357 : c->resolved_sym->name, &c->loc);
4358 :
4359 83744 : csym = c->resolved_sym ? c->resolved_sym : csym;
4360 83744 : if (t && gfc_current_ns->import_state != IMPORT_NOT_SET && !c->resolved_isym
4361 2 : && csym != gfc_current_ns->proc_name)
4362 1 : return check_sym_import_status (csym, c->symtree, NULL, c, gfc_current_ns);
4363 :
4364 : return t;
4365 : }
4366 :
4367 :
4368 : /* Compare the shapes of two arrays that have non-NULL shapes. If both
4369 : op1->shape and op2->shape are non-NULL return true if their shapes
4370 : match. If both op1->shape and op2->shape are non-NULL return false
4371 : if their shapes do not match. If either op1->shape or op2->shape is
4372 : NULL, return true. */
4373 :
4374 : static bool
4375 33638 : compare_shapes (gfc_expr *op1, gfc_expr *op2)
4376 : {
4377 33638 : bool t;
4378 33638 : int i;
4379 :
4380 33638 : t = true;
4381 :
4382 33638 : if (op1->shape != NULL && op2->shape != NULL)
4383 : {
4384 44112 : for (i = 0; i < op1->rank; i++)
4385 : {
4386 23505 : if (mpz_cmp (op1->shape[i], op2->shape[i]) != 0)
4387 : {
4388 3 : gfc_error ("Shapes for operands at %L and %L are not conformable",
4389 : &op1->where, &op2->where);
4390 3 : t = false;
4391 3 : break;
4392 : }
4393 : }
4394 : }
4395 :
4396 33638 : return t;
4397 : }
4398 :
4399 : /* Convert a logical operator to the corresponding bitwise intrinsic call.
4400 : For example A .AND. B becomes IAND(A, B). */
4401 : static gfc_expr *
4402 668 : logical_to_bitwise (gfc_expr *e)
4403 : {
4404 668 : gfc_expr *tmp, *op1, *op2;
4405 668 : gfc_isym_id isym;
4406 668 : gfc_actual_arglist *args = NULL;
4407 :
4408 668 : gcc_assert (e->expr_type == EXPR_OP);
4409 :
4410 668 : isym = GFC_ISYM_NONE;
4411 668 : op1 = e->value.op.op1;
4412 668 : op2 = e->value.op.op2;
4413 :
4414 668 : switch (e->value.op.op)
4415 : {
4416 : case INTRINSIC_NOT:
4417 : isym = GFC_ISYM_NOT;
4418 : break;
4419 126 : case INTRINSIC_AND:
4420 126 : isym = GFC_ISYM_IAND;
4421 126 : break;
4422 127 : case INTRINSIC_OR:
4423 127 : isym = GFC_ISYM_IOR;
4424 127 : break;
4425 270 : case INTRINSIC_NEQV:
4426 270 : isym = GFC_ISYM_IEOR;
4427 270 : break;
4428 126 : case INTRINSIC_EQV:
4429 : /* "Bitwise eqv" is just the complement of NEQV === IEOR.
4430 : Change the old expression to NEQV, which will get replaced by IEOR,
4431 : and wrap it in NOT. */
4432 126 : tmp = gfc_copy_expr (e);
4433 126 : tmp->value.op.op = INTRINSIC_NEQV;
4434 126 : tmp = logical_to_bitwise (tmp);
4435 126 : isym = GFC_ISYM_NOT;
4436 126 : op1 = tmp;
4437 126 : op2 = NULL;
4438 126 : break;
4439 0 : default:
4440 0 : gfc_internal_error ("logical_to_bitwise(): Bad intrinsic");
4441 : }
4442 :
4443 : /* Inherit the original operation's operands as arguments. */
4444 668 : args = gfc_get_actual_arglist ();
4445 668 : args->expr = op1;
4446 668 : if (op2)
4447 : {
4448 523 : args->next = gfc_get_actual_arglist ();
4449 523 : args->next->expr = op2;
4450 : }
4451 :
4452 : /* Convert the expression to a function call. */
4453 668 : e->expr_type = EXPR_FUNCTION;
4454 668 : e->value.function.actual = args;
4455 668 : e->value.function.isym = gfc_intrinsic_function_by_id (isym);
4456 668 : e->value.function.name = e->value.function.isym->name;
4457 668 : e->value.function.esym = NULL;
4458 :
4459 : /* Make up a pre-resolved function call symtree if we need to. */
4460 668 : if (!e->symtree || !e->symtree->n.sym)
4461 : {
4462 668 : gfc_symbol *sym;
4463 668 : gfc_get_ha_sym_tree (e->value.function.isym->name, &e->symtree);
4464 668 : sym = e->symtree->n.sym;
4465 668 : sym->result = sym;
4466 668 : sym->attr.flavor = FL_PROCEDURE;
4467 668 : sym->attr.function = 1;
4468 668 : sym->attr.elemental = 1;
4469 668 : sym->attr.pure = 1;
4470 668 : sym->attr.referenced = 1;
4471 668 : gfc_intrinsic_symbol (sym);
4472 668 : gfc_commit_symbol (sym);
4473 : }
4474 :
4475 668 : args->name = e->value.function.isym->formal->name;
4476 668 : if (e->value.function.isym->formal->next)
4477 523 : args->next->name = e->value.function.isym->formal->next->name;
4478 :
4479 668 : return e;
4480 : }
4481 :
4482 : /* Recursively append candidate UOP to CANDIDATES. Store the number of
4483 : candidates in CANDIDATES_LEN. */
4484 : static void
4485 114 : lookup_uop_fuzzy_find_candidates (gfc_symtree *uop,
4486 : char **&candidates,
4487 : size_t &candidates_len)
4488 : {
4489 116 : gfc_symtree *p;
4490 :
4491 116 : if (uop == NULL)
4492 : return;
4493 :
4494 : /* Not sure how to properly filter here. Use all for a start.
4495 : n.uop.op is NULL for empty interface operators (is that legal?) disregard
4496 : these as i suppose they don't make terribly sense. */
4497 :
4498 116 : if (uop->n.uop->op != NULL)
4499 2 : vec_push (candidates, candidates_len, uop->name);
4500 :
4501 116 : p = uop->left;
4502 116 : if (p)
4503 36 : lookup_uop_fuzzy_find_candidates (p, candidates, candidates_len);
4504 :
4505 116 : p = uop->right;
4506 116 : if (p)
4507 : lookup_uop_fuzzy_find_candidates (p, candidates, candidates_len);
4508 : }
4509 :
4510 : /* Lookup user-operator OP fuzzily, taking names in UOP into account. */
4511 :
4512 : static const char*
4513 78 : lookup_uop_fuzzy (const char *op, gfc_symtree *uop)
4514 : {
4515 78 : char **candidates = NULL;
4516 78 : size_t candidates_len = 0;
4517 78 : lookup_uop_fuzzy_find_candidates (uop, candidates, candidates_len);
4518 78 : return gfc_closest_fuzzy_match (op, candidates);
4519 : }
4520 :
4521 :
4522 : /* Callback finding an impure function as an operand to an .and. or
4523 : .or. expression. Remember the last function warned about to
4524 : avoid double warnings when recursing. */
4525 :
4526 : static int
4527 194805 : impure_function_callback (gfc_expr **e, int *walk_subtrees ATTRIBUTE_UNUSED,
4528 : void *data)
4529 : {
4530 194805 : gfc_expr *f = *e;
4531 194805 : const char *name;
4532 194805 : static gfc_expr *last = NULL;
4533 194805 : bool *found = (bool *) data;
4534 :
4535 194805 : if (f->expr_type == EXPR_FUNCTION)
4536 : {
4537 12082 : *found = 1;
4538 12082 : if (f != last && !gfc_pure_function (f, &name)
4539 13404 : && !gfc_implicit_pure_function (f))
4540 : {
4541 1183 : if (name)
4542 1183 : gfc_warning (OPT_Wfunction_elimination,
4543 : "Impure function %qs at %L might not be evaluated",
4544 : name, &f->where);
4545 : else
4546 0 : gfc_warning (OPT_Wfunction_elimination,
4547 : "Impure function at %L might not be evaluated",
4548 : &f->where);
4549 : }
4550 12082 : last = f;
4551 : }
4552 :
4553 194805 : return 0;
4554 : }
4555 :
4556 : /* Return true if TYPE is character based, false otherwise. */
4557 :
4558 : static int
4559 1373 : is_character_based (bt type)
4560 : {
4561 1373 : return type == BT_CHARACTER || type == BT_HOLLERITH;
4562 : }
4563 :
4564 :
4565 : /* If expression is a hollerith, convert it to character and issue a warning
4566 : for the conversion. */
4567 :
4568 : static void
4569 408 : convert_hollerith_to_character (gfc_expr *e)
4570 : {
4571 408 : if (e->ts.type == BT_HOLLERITH)
4572 : {
4573 108 : gfc_typespec t;
4574 108 : gfc_clear_ts (&t);
4575 108 : t.type = BT_CHARACTER;
4576 108 : t.kind = e->ts.kind;
4577 108 : gfc_convert_type_warn (e, &t, 2, 1);
4578 : }
4579 408 : }
4580 :
4581 : /* Convert to numeric and issue a warning for the conversion. */
4582 :
4583 : static void
4584 240 : convert_to_numeric (gfc_expr *a, gfc_expr *b)
4585 : {
4586 240 : gfc_typespec t;
4587 240 : gfc_clear_ts (&t);
4588 240 : t.type = b->ts.type;
4589 240 : t.kind = b->ts.kind;
4590 240 : gfc_convert_type_warn (a, &t, 2, 1);
4591 240 : }
4592 :
4593 : /* Resolve an operator expression node. This can involve replacing the
4594 : operation with a user defined function call. CHECK_INTERFACES is a
4595 : helper macro. */
4596 :
4597 : #define CHECK_INTERFACES \
4598 : { \
4599 : match m = gfc_extend_expr (e); \
4600 : if (m == MATCH_YES) \
4601 : return true; \
4602 : if (m == MATCH_ERROR) \
4603 : return false; \
4604 : }
4605 :
4606 : static bool
4607 544072 : resolve_operator (gfc_expr *e)
4608 : {
4609 544072 : gfc_expr *op1, *op2;
4610 : /* One error uses 3 names; additional space for wording (also via gettext). */
4611 544072 : bool t = true;
4612 :
4613 : /* Reduce stacked parentheses to single pair */
4614 544072 : while (e->expr_type == EXPR_OP
4615 544230 : && e->value.op.op == INTRINSIC_PARENTHESES
4616 23772 : && e->value.op.op1->expr_type == EXPR_OP
4617 561132 : && e->value.op.op1->value.op.op == INTRINSIC_PARENTHESES)
4618 : {
4619 158 : gfc_expr *tmp = gfc_copy_expr (e->value.op.op1);
4620 158 : gfc_replace_expr (e, tmp);
4621 : }
4622 :
4623 : /* Resolve all subnodes-- give them types. */
4624 :
4625 544072 : switch (e->value.op.op)
4626 : {
4627 491466 : default:
4628 491466 : if (!gfc_resolve_expr (e->value.op.op2))
4629 544072 : t = false;
4630 :
4631 : /* Fall through. */
4632 :
4633 544072 : case INTRINSIC_NOT:
4634 544072 : case INTRINSIC_UPLUS:
4635 544072 : case INTRINSIC_UMINUS:
4636 544072 : case INTRINSIC_PARENTHESES:
4637 544072 : if (!gfc_resolve_expr (e->value.op.op1))
4638 : return false;
4639 543911 : if (e->value.op.op1
4640 543902 : && e->value.op.op1->ts.type == BT_BOZ && !e->value.op.op2)
4641 : {
4642 0 : gfc_error ("BOZ literal constant at %L cannot be an operand of "
4643 0 : "unary operator %qs", &e->value.op.op1->where,
4644 : gfc_op2string (e->value.op.op));
4645 0 : return false;
4646 : }
4647 543911 : if (flag_unsigned && pedantic && e->ts.type == BT_UNSIGNED
4648 6 : && e->value.op.op == INTRINSIC_UMINUS)
4649 : {
4650 2 : gfc_error ("Negation of unsigned expression at %L not permitted ",
4651 : &e->value.op.op1->where);
4652 2 : return false;
4653 : }
4654 543909 : break;
4655 : }
4656 :
4657 : /* Typecheck the new node. */
4658 :
4659 543909 : op1 = e->value.op.op1;
4660 543909 : op2 = e->value.op.op2;
4661 543909 : if (op1 == NULL && op2 == NULL)
4662 : return false;
4663 : /* Error out if op2 did not resolve. We already diagnosed op1. */
4664 543900 : if (t == false)
4665 : return false;
4666 :
4667 : /* op1 and op2 cannot both be BOZ. */
4668 543834 : if (op1 && op1->ts.type == BT_BOZ
4669 0 : && op2 && op2->ts.type == BT_BOZ)
4670 : {
4671 0 : gfc_error ("Operands at %L and %L cannot appear as operands of "
4672 0 : "binary operator %qs", &op1->where, &op2->where,
4673 : gfc_op2string (e->value.op.op));
4674 0 : return false;
4675 : }
4676 :
4677 543834 : if ((op1 && op1->expr_type == EXPR_NULL)
4678 543832 : || (op2 && op2->expr_type == EXPR_NULL))
4679 : {
4680 3 : CHECK_INTERFACES
4681 3 : gfc_error ("Invalid context for NULL() pointer at %L", &e->where);
4682 3 : return false;
4683 : }
4684 :
4685 543831 : switch (e->value.op.op)
4686 : {
4687 8295 : case INTRINSIC_UPLUS:
4688 8295 : case INTRINSIC_UMINUS:
4689 8295 : if (op1->ts.type == BT_INTEGER
4690 : || op1->ts.type == BT_REAL
4691 : || op1->ts.type == BT_COMPLEX
4692 : || op1->ts.type == BT_UNSIGNED)
4693 : {
4694 8226 : e->ts = op1->ts;
4695 8226 : break;
4696 : }
4697 :
4698 69 : CHECK_INTERFACES
4699 43 : gfc_error ("Operand of unary numeric operator %qs at %L is %s",
4700 : gfc_op2string (e->value.op.op), &e->where, gfc_typename (e));
4701 43 : return false;
4702 :
4703 159077 : case INTRINSIC_POWER:
4704 159077 : case INTRINSIC_PLUS:
4705 159077 : case INTRINSIC_MINUS:
4706 159077 : case INTRINSIC_TIMES:
4707 159077 : case INTRINSIC_DIVIDE:
4708 :
4709 : /* UNSIGNED cannot appear in a mixed expression without explicit
4710 : conversion. */
4711 159077 : if (flag_unsigned && gfc_invalid_unsigned_ops (op1, op2))
4712 : {
4713 3 : CHECK_INTERFACES
4714 3 : gfc_error ("Operands of binary numeric operator %qs at %L are "
4715 : "%s/%s", gfc_op2string (e->value.op.op), &e->where,
4716 : gfc_typename (op1), gfc_typename (op2));
4717 3 : return false;
4718 : }
4719 :
4720 159074 : if (gfc_numeric_ts (&op1->ts) && gfc_numeric_ts (&op2->ts))
4721 : {
4722 : /* Do not perform conversions if operands are not conformable as
4723 : required for the binary intrinsic operators (F2018:10.1.5).
4724 : Defer to a possibly overloading user-defined operator. */
4725 158620 : if (!gfc_op_rank_conformable (op1, op2))
4726 : {
4727 36 : CHECK_INTERFACES
4728 0 : gfc_error ("Inconsistent ranks for operator at %L and %L",
4729 0 : &op1->where, &op2->where);
4730 0 : return false;
4731 : }
4732 :
4733 158584 : gfc_type_convert_binary (e, 1);
4734 158584 : break;
4735 : }
4736 :
4737 454 : if (op1->ts.type == BT_DERIVED || op2->ts.type == BT_DERIVED)
4738 : {
4739 225 : CHECK_INTERFACES
4740 2 : gfc_error ("Unexpected derived-type entities in binary intrinsic "
4741 : "numeric operator %qs at %L",
4742 : gfc_op2string (e->value.op.op), &e->where);
4743 2 : return false;
4744 : }
4745 : else
4746 : {
4747 229 : CHECK_INTERFACES
4748 3 : gfc_error ("Operands of binary numeric operator %qs at %L are %s/%s",
4749 : gfc_op2string (e->value.op.op), &e->where, gfc_typename (op1),
4750 : gfc_typename (op2));
4751 3 : return false;
4752 : }
4753 :
4754 2387 : case INTRINSIC_CONCAT:
4755 2387 : if (op1->ts.type == BT_CHARACTER && op2->ts.type == BT_CHARACTER
4756 2362 : && op1->ts.kind == op2->ts.kind)
4757 : {
4758 2353 : e->ts.type = BT_CHARACTER;
4759 2353 : e->ts.kind = op1->ts.kind;
4760 2353 : break;
4761 : }
4762 :
4763 34 : CHECK_INTERFACES
4764 10 : gfc_error ("Operands of string concatenation operator at %L are %s/%s",
4765 : &e->where, gfc_typename (op1), gfc_typename (op2));
4766 10 : return false;
4767 :
4768 70188 : case INTRINSIC_AND:
4769 70188 : case INTRINSIC_OR:
4770 70188 : case INTRINSIC_EQV:
4771 70188 : case INTRINSIC_NEQV:
4772 70188 : if (op1->ts.type == BT_LOGICAL && op2->ts.type == BT_LOGICAL)
4773 : {
4774 69637 : e->ts.type = BT_LOGICAL;
4775 69637 : e->ts.kind = gfc_kind_max (op1, op2);
4776 69637 : if (op1->ts.kind < e->ts.kind)
4777 140 : gfc_convert_type (op1, &e->ts, 2);
4778 69497 : else if (op2->ts.kind < e->ts.kind)
4779 117 : gfc_convert_type (op2, &e->ts, 2);
4780 :
4781 69637 : if (flag_frontend_optimize &&
4782 58521 : (e->value.op.op == INTRINSIC_AND || e->value.op.op == INTRINSIC_OR))
4783 : {
4784 : /* Warn about short-circuiting
4785 : with impure function as second operand. */
4786 52486 : bool op2_f = false;
4787 52486 : gfc_expr_walker (&op2, impure_function_callback, &op2_f);
4788 : }
4789 : break;
4790 : }
4791 :
4792 : /* Logical ops on integers become bitwise ops with -fdec. */
4793 551 : else if (flag_dec
4794 523 : && (op1->ts.type == BT_INTEGER || op2->ts.type == BT_INTEGER))
4795 : {
4796 523 : e->ts.type = BT_INTEGER;
4797 523 : e->ts.kind = gfc_kind_max (op1, op2);
4798 523 : if (op1->ts.type != e->ts.type || op1->ts.kind != e->ts.kind)
4799 289 : gfc_convert_type (op1, &e->ts, 1);
4800 523 : if (op2->ts.type != e->ts.type || op2->ts.kind != e->ts.kind)
4801 144 : gfc_convert_type (op2, &e->ts, 1);
4802 523 : e = logical_to_bitwise (e);
4803 523 : goto simplify_op;
4804 : }
4805 :
4806 28 : CHECK_INTERFACES
4807 16 : gfc_error ("Operands of logical operator %qs at %L are %s/%s",
4808 : gfc_op2string (e->value.op.op), &e->where, gfc_typename (op1),
4809 : gfc_typename (op2));
4810 16 : return false;
4811 :
4812 20681 : case INTRINSIC_NOT:
4813 : /* Logical ops on integers become bitwise ops with -fdec. */
4814 20681 : if (flag_dec && op1->ts.type == BT_INTEGER)
4815 : {
4816 19 : e->ts.type = BT_INTEGER;
4817 19 : e->ts.kind = op1->ts.kind;
4818 19 : e = logical_to_bitwise (e);
4819 19 : goto simplify_op;
4820 : }
4821 :
4822 20662 : if (op1->ts.type == BT_LOGICAL)
4823 : {
4824 20656 : e->ts.type = BT_LOGICAL;
4825 20656 : e->ts.kind = op1->ts.kind;
4826 20656 : break;
4827 : }
4828 :
4829 6 : CHECK_INTERFACES
4830 3 : gfc_error ("Operand of .not. operator at %L is %s", &e->where,
4831 : gfc_typename (op1));
4832 3 : return false;
4833 :
4834 21816 : case INTRINSIC_GT:
4835 21816 : case INTRINSIC_GT_OS:
4836 21816 : case INTRINSIC_GE:
4837 21816 : case INTRINSIC_GE_OS:
4838 21816 : case INTRINSIC_LT:
4839 21816 : case INTRINSIC_LT_OS:
4840 21816 : case INTRINSIC_LE:
4841 21816 : case INTRINSIC_LE_OS:
4842 21816 : if (op1->ts.type == BT_COMPLEX || op2->ts.type == BT_COMPLEX)
4843 : {
4844 18 : CHECK_INTERFACES
4845 0 : gfc_error ("COMPLEX quantities cannot be compared at %L", &e->where);
4846 0 : return false;
4847 : }
4848 :
4849 : /* Fall through. */
4850 :
4851 259307 : case INTRINSIC_EQ:
4852 259307 : case INTRINSIC_EQ_OS:
4853 259307 : case INTRINSIC_NE:
4854 259307 : case INTRINSIC_NE_OS:
4855 :
4856 259307 : if (flag_dec
4857 1038 : && is_character_based (op1->ts.type)
4858 259642 : && is_character_based (op2->ts.type))
4859 : {
4860 204 : convert_hollerith_to_character (op1);
4861 204 : convert_hollerith_to_character (op2);
4862 : }
4863 :
4864 259307 : if (op1->ts.type == BT_CHARACTER && op2->ts.type == BT_CHARACTER
4865 39165 : && op1->ts.kind == op2->ts.kind)
4866 : {
4867 39128 : e->ts.type = BT_LOGICAL;
4868 39128 : e->ts.kind = gfc_default_logical_kind;
4869 39128 : break;
4870 : }
4871 :
4872 : /* If op1 is BOZ, then op2 is not!. Try to convert to type of op2. */
4873 220179 : if (op1->ts.type == BT_BOZ)
4874 : {
4875 0 : if (gfc_invalid_boz (G_("BOZ literal constant near %L cannot appear "
4876 : "as an operand of a relational operator"),
4877 : &op1->where))
4878 : return false;
4879 :
4880 0 : if (op2->ts.type == BT_INTEGER && !gfc_boz2int (op1, op2->ts.kind))
4881 : return false;
4882 :
4883 0 : if (op2->ts.type == BT_REAL && !gfc_boz2real (op1, op2->ts.kind))
4884 : return false;
4885 : }
4886 :
4887 : /* If op2 is BOZ, then op1 is not!. Try to convert to type of op2. */
4888 220179 : if (op2->ts.type == BT_BOZ)
4889 : {
4890 0 : if (gfc_invalid_boz (G_("BOZ literal constant near %L cannot appear"
4891 : " as an operand of a relational operator"),
4892 : &op2->where))
4893 : return false;
4894 :
4895 0 : if (op1->ts.type == BT_INTEGER && !gfc_boz2int (op2, op1->ts.kind))
4896 : return false;
4897 :
4898 0 : if (op1->ts.type == BT_REAL && !gfc_boz2real (op2, op1->ts.kind))
4899 : return false;
4900 : }
4901 220179 : if (flag_dec
4902 220179 : && op1->ts.type == BT_HOLLERITH && gfc_numeric_ts (&op2->ts))
4903 120 : convert_to_numeric (op1, op2);
4904 :
4905 220179 : if (flag_dec
4906 220179 : && gfc_numeric_ts (&op1->ts) && op2->ts.type == BT_HOLLERITH)
4907 120 : convert_to_numeric (op2, op1);
4908 :
4909 220179 : if (gfc_numeric_ts (&op1->ts) && gfc_numeric_ts (&op2->ts))
4910 : {
4911 : /* Do not perform conversions if operands are not conformable as
4912 : required for the binary intrinsic operators (F2018:10.1.5).
4913 : Defer to a possibly overloading user-defined operator. */
4914 219050 : if (!gfc_op_rank_conformable (op1, op2))
4915 : {
4916 70 : CHECK_INTERFACES
4917 0 : gfc_error ("Inconsistent ranks for operator at %L and %L",
4918 0 : &op1->where, &op2->where);
4919 0 : return false;
4920 : }
4921 :
4922 218980 : if (flag_unsigned && gfc_invalid_unsigned_ops (op1, op2))
4923 : {
4924 1 : CHECK_INTERFACES
4925 1 : gfc_error ("Inconsistent types for operator at %L and %L: "
4926 1 : "%s and %s", &op1->where, &op2->where,
4927 : gfc_typename (op1), gfc_typename (op2));
4928 1 : return false;
4929 : }
4930 :
4931 218979 : gfc_type_convert_binary (e, 1);
4932 :
4933 218979 : e->ts.type = BT_LOGICAL;
4934 218979 : e->ts.kind = gfc_default_logical_kind;
4935 :
4936 218979 : if (warn_compare_reals)
4937 : {
4938 70 : gfc_intrinsic_op op = e->value.op.op;
4939 :
4940 : /* Type conversion has made sure that the types of op1 and op2
4941 : agree, so it is only necessary to check the first one. */
4942 70 : if ((op1->ts.type == BT_REAL || op1->ts.type == BT_COMPLEX)
4943 13 : && (op == INTRINSIC_EQ || op == INTRINSIC_EQ_OS
4944 6 : || op == INTRINSIC_NE || op == INTRINSIC_NE_OS))
4945 : {
4946 13 : const char *msg;
4947 :
4948 13 : if (op == INTRINSIC_EQ || op == INTRINSIC_EQ_OS)
4949 : msg = G_("Equality comparison for %s at %L");
4950 : else
4951 6 : msg = G_("Inequality comparison for %s at %L");
4952 :
4953 13 : gfc_warning (OPT_Wcompare_reals, msg,
4954 : gfc_typename (op1), &op1->where);
4955 : }
4956 : }
4957 :
4958 : break;
4959 : }
4960 :
4961 1129 : if (op1->ts.type == BT_LOGICAL && op2->ts.type == BT_LOGICAL)
4962 : {
4963 2 : CHECK_INTERFACES
4964 4 : gfc_error ("Logicals at %L must be compared with %s instead of %s",
4965 : &e->where,
4966 2 : (e->value.op.op == INTRINSIC_EQ || e->value.op.op == INTRINSIC_EQ_OS)
4967 : ? ".eqv." : ".neqv.", gfc_op2string (e->value.op.op));
4968 2 : }
4969 : else
4970 : {
4971 1127 : CHECK_INTERFACES
4972 113 : gfc_error ("Operands of comparison operator %qs at %L are %s/%s",
4973 : gfc_op2string (e->value.op.op), &e->where, gfc_typename (op1),
4974 : gfc_typename (op2));
4975 : }
4976 :
4977 : return false;
4978 :
4979 303 : case INTRINSIC_USER:
4980 303 : if (e->value.op.uop->op == NULL)
4981 : {
4982 78 : const char *name = e->value.op.uop->name;
4983 78 : const char *guessed;
4984 78 : guessed = lookup_uop_fuzzy (name, e->value.op.uop->ns->uop_root);
4985 78 : CHECK_INTERFACES
4986 5 : if (guessed)
4987 1 : gfc_error ("Unknown operator %qs at %L; did you mean "
4988 : "%qs?", name, &e->where, guessed);
4989 : else
4990 4 : gfc_error ("Unknown operator %qs at %L", name, &e->where);
4991 : }
4992 225 : else if (op2 == NULL)
4993 : {
4994 48 : CHECK_INTERFACES
4995 0 : gfc_error ("Operand of user operator %qs at %L is %s",
4996 0 : e->value.op.uop->name, &e->where, gfc_typename (op1));
4997 : }
4998 : else
4999 : {
5000 177 : e->value.op.uop->op->sym->attr.referenced = 1;
5001 177 : CHECK_INTERFACES
5002 5 : gfc_error ("Operands of user operator %qs at %L are %s/%s",
5003 5 : e->value.op.uop->name, &e->where, gfc_typename (op1),
5004 : gfc_typename (op2));
5005 : }
5006 :
5007 : return false;
5008 :
5009 23575 : case INTRINSIC_PARENTHESES:
5010 23575 : e->ts = op1->ts;
5011 23575 : if (e->ts.type == BT_CHARACTER)
5012 335 : e->ts.u.cl = op1->ts.u.cl;
5013 : break;
5014 :
5015 0 : default:
5016 0 : gfc_internal_error ("resolve_operator(): Bad intrinsic");
5017 : }
5018 :
5019 : /* Deal with arrayness of an operand through an operator. */
5020 :
5021 541138 : switch (e->value.op.op)
5022 : {
5023 488681 : case INTRINSIC_PLUS:
5024 488681 : case INTRINSIC_MINUS:
5025 488681 : case INTRINSIC_TIMES:
5026 488681 : case INTRINSIC_DIVIDE:
5027 488681 : case INTRINSIC_POWER:
5028 488681 : case INTRINSIC_CONCAT:
5029 488681 : case INTRINSIC_AND:
5030 488681 : case INTRINSIC_OR:
5031 488681 : case INTRINSIC_EQV:
5032 488681 : case INTRINSIC_NEQV:
5033 488681 : case INTRINSIC_EQ:
5034 488681 : case INTRINSIC_EQ_OS:
5035 488681 : case INTRINSIC_NE:
5036 488681 : case INTRINSIC_NE_OS:
5037 488681 : case INTRINSIC_GT:
5038 488681 : case INTRINSIC_GT_OS:
5039 488681 : case INTRINSIC_GE:
5040 488681 : case INTRINSIC_GE_OS:
5041 488681 : case INTRINSIC_LT:
5042 488681 : case INTRINSIC_LT_OS:
5043 488681 : case INTRINSIC_LE:
5044 488681 : case INTRINSIC_LE_OS:
5045 :
5046 488681 : if (op1->rank == 0 && op2->rank == 0)
5047 434849 : e->rank = 0;
5048 :
5049 488681 : if (op1->rank == 0 && op2->rank != 0)
5050 : {
5051 2646 : e->rank = op2->rank;
5052 :
5053 2646 : if (e->shape == NULL)
5054 2615 : e->shape = gfc_copy_shape (op2->shape, op2->rank);
5055 : }
5056 :
5057 488681 : if (op1->rank != 0 && op2->rank == 0)
5058 : {
5059 17487 : e->rank = op1->rank;
5060 :
5061 17487 : if (e->shape == NULL)
5062 17463 : e->shape = gfc_copy_shape (op1->shape, op1->rank);
5063 : }
5064 :
5065 488681 : if (op1->rank != 0 && op2->rank != 0)
5066 : {
5067 33699 : if (op1->rank == op2->rank)
5068 : {
5069 33699 : e->rank = op1->rank;
5070 33699 : if (e->shape == NULL)
5071 : {
5072 33638 : t = compare_shapes (op1, op2);
5073 33638 : if (!t)
5074 3 : e->shape = NULL;
5075 : else
5076 33635 : e->shape = gfc_copy_shape (op1->shape, op1->rank);
5077 : }
5078 : }
5079 : else
5080 : {
5081 : /* Allow higher level expressions to work. */
5082 0 : e->rank = 0;
5083 :
5084 : /* Try user-defined operators, and otherwise throw an error. */
5085 0 : CHECK_INTERFACES
5086 0 : gfc_error ("Inconsistent ranks for operator at %L and %L",
5087 0 : &op1->where, &op2->where);
5088 0 : return false;
5089 : }
5090 : }
5091 : break;
5092 :
5093 52457 : case INTRINSIC_PARENTHESES:
5094 52457 : case INTRINSIC_NOT:
5095 52457 : case INTRINSIC_UPLUS:
5096 52457 : case INTRINSIC_UMINUS:
5097 : /* Simply copy arrayness attribute */
5098 52457 : e->rank = op1->rank;
5099 52457 : e->corank = op1->corank;
5100 :
5101 52457 : if (e->shape == NULL)
5102 52447 : e->shape = gfc_copy_shape (op1->shape, op1->rank);
5103 :
5104 : break;
5105 :
5106 : default:
5107 : break;
5108 : }
5109 :
5110 541680 : simplify_op:
5111 :
5112 : /* Attempt to simplify the expression. */
5113 3 : if (t)
5114 : {
5115 541677 : t = gfc_simplify_expr (e, 0);
5116 : /* Some calls do not succeed in simplification and return false
5117 : even though there is no error; e.g. variable references to
5118 : PARAMETER arrays. */
5119 541677 : if (!gfc_is_constant_expr (e))
5120 494739 : t = true;
5121 : }
5122 : return t;
5123 : }
5124 :
5125 : static bool
5126 170 : resolve_conditional (gfc_expr *expr)
5127 : {
5128 170 : gfc_expr *condition, *true_expr, *false_expr;
5129 :
5130 170 : condition = expr->value.conditional.condition;
5131 170 : true_expr = expr->value.conditional.true_expr;
5132 170 : false_expr = expr->value.conditional.false_expr;
5133 :
5134 340 : if (!gfc_resolve_expr (condition) || !gfc_resolve_expr (true_expr)
5135 340 : || !gfc_resolve_expr (false_expr))
5136 : return false;
5137 :
5138 170 : if (condition->ts.type != BT_LOGICAL || condition->rank != 0)
5139 : {
5140 2 : gfc_error (
5141 : "Condition in conditional expression must be a scalar logical at %L",
5142 : &condition->where);
5143 2 : return false;
5144 : }
5145 :
5146 168 : if (true_expr->ts.type != false_expr->ts.type)
5147 : {
5148 1 : gfc_error ("expr at %L and expr at %L in conditional expression "
5149 : "must have the same declared type",
5150 : &true_expr->where, &false_expr->where);
5151 1 : return false;
5152 : }
5153 :
5154 167 : if (true_expr->ts.kind != false_expr->ts.kind)
5155 : {
5156 1 : gfc_error ("expr at %L and expr at %L in conditional expression "
5157 : "must have the same kind parameter",
5158 : &true_expr->where, &false_expr->where);
5159 1 : return false;
5160 : }
5161 :
5162 166 : if (true_expr->rank != false_expr->rank)
5163 : {
5164 1 : gfc_error ("expr at %L and expr at %L in conditional expression "
5165 : "must have the same rank",
5166 : &true_expr->where, &false_expr->where);
5167 1 : return false;
5168 : }
5169 :
5170 : /* TODO: support more data types for conditional expressions */
5171 165 : if (true_expr->ts.type != BT_INTEGER && true_expr->ts.type != BT_LOGICAL
5172 165 : && true_expr->ts.type != BT_REAL && true_expr->ts.type != BT_COMPLEX
5173 67 : && true_expr->ts.type != BT_CHARACTER)
5174 : {
5175 1 : gfc_error (
5176 : "Sorry, only integer, logical, real, complex and character types are "
5177 : "currently supported for conditional expressions at %L",
5178 : &expr->where);
5179 1 : return false;
5180 : }
5181 :
5182 : /* TODO: support arrays in conditional expressions */
5183 164 : if (true_expr->rank > 0)
5184 : {
5185 1 : gfc_error ("Sorry, array is currently unsupported for conditional "
5186 : "expressions at %L",
5187 : &expr->where);
5188 1 : return false;
5189 : }
5190 :
5191 163 : expr->ts = true_expr->ts;
5192 163 : expr->rank = true_expr->rank;
5193 163 : return true;
5194 : }
5195 :
5196 : /************** Array resolution subroutines **************/
5197 :
5198 : enum compare_result
5199 : { CMP_LT, CMP_EQ, CMP_GT, CMP_UNKNOWN };
5200 :
5201 : /* Compare two integer expressions. */
5202 :
5203 : static compare_result
5204 478599 : compare_bound (gfc_expr *a, gfc_expr *b)
5205 : {
5206 478599 : int i;
5207 :
5208 478599 : if (a == NULL || a->expr_type != EXPR_CONSTANT
5209 315364 : || b == NULL || b->expr_type != EXPR_CONSTANT)
5210 : return CMP_UNKNOWN;
5211 :
5212 : /* If either of the types isn't INTEGER, we must have
5213 : raised an error earlier. */
5214 :
5215 216684 : if (a->ts.type != BT_INTEGER || b->ts.type != BT_INTEGER)
5216 : return CMP_UNKNOWN;
5217 :
5218 216680 : i = mpz_cmp (a->value.integer, b->value.integer);
5219 :
5220 216680 : if (i < 0)
5221 : return CMP_LT;
5222 101962 : if (i > 0)
5223 40539 : return CMP_GT;
5224 : return CMP_EQ;
5225 : }
5226 :
5227 :
5228 : /* Compare an integer expression with an integer. */
5229 :
5230 : static compare_result
5231 76362 : compare_bound_int (gfc_expr *a, int b)
5232 : {
5233 76362 : int i;
5234 :
5235 76362 : if (a == NULL
5236 33092 : || a->expr_type != EXPR_CONSTANT
5237 30139 : || a->ts.type != BT_INTEGER)
5238 : return CMP_UNKNOWN;
5239 :
5240 30139 : i = mpz_cmp_si (a->value.integer, b);
5241 :
5242 30139 : if (i < 0)
5243 : return CMP_LT;
5244 25647 : if (i > 0)
5245 22069 : return CMP_GT;
5246 : return CMP_EQ;
5247 : }
5248 :
5249 :
5250 : /* Compare an integer expression with a mpz_t. */
5251 :
5252 : static compare_result
5253 71022 : compare_bound_mpz_t (gfc_expr *a, mpz_t b)
5254 : {
5255 71022 : int i;
5256 :
5257 71022 : if (a == NULL
5258 57921 : || a->expr_type != EXPR_CONSTANT
5259 55793 : || a->ts.type != BT_INTEGER)
5260 : return CMP_UNKNOWN;
5261 :
5262 55790 : i = mpz_cmp (a->value.integer, b);
5263 :
5264 55790 : if (i < 0)
5265 : return CMP_LT;
5266 25358 : if (i > 0)
5267 10790 : return CMP_GT;
5268 : return CMP_EQ;
5269 : }
5270 :
5271 :
5272 : /* Compute the last value of a sequence given by a triplet.
5273 : Return 0 if it wasn't able to compute the last value, or if the
5274 : sequence if empty, and 1 otherwise. */
5275 :
5276 : static int
5277 52893 : compute_last_value_for_triplet (gfc_expr *start, gfc_expr *end,
5278 : gfc_expr *stride, mpz_t last)
5279 : {
5280 52893 : mpz_t rem;
5281 :
5282 52893 : if (start == NULL || start->expr_type != EXPR_CONSTANT
5283 37606 : || end == NULL || end->expr_type != EXPR_CONSTANT
5284 32848 : || (stride != NULL && stride->expr_type != EXPR_CONSTANT))
5285 : return 0;
5286 :
5287 32529 : if (start->ts.type != BT_INTEGER || end->ts.type != BT_INTEGER
5288 32528 : || (stride != NULL && stride->ts.type != BT_INTEGER))
5289 : return 0;
5290 :
5291 6811 : if (stride == NULL || compare_bound_int (stride, 1) == CMP_EQ)
5292 : {
5293 25843 : if (compare_bound (start, end) == CMP_GT)
5294 : return 0;
5295 24454 : mpz_set (last, end->value.integer);
5296 24454 : return 1;
5297 : }
5298 :
5299 6685 : if (compare_bound_int (stride, 0) == CMP_GT)
5300 : {
5301 : /* Stride is positive */
5302 5314 : if (mpz_cmp (start->value.integer, end->value.integer) > 0)
5303 : return 0;
5304 : }
5305 : else
5306 : {
5307 : /* Stride is negative */
5308 1371 : if (mpz_cmp (start->value.integer, end->value.integer) < 0)
5309 : return 0;
5310 : }
5311 :
5312 6665 : mpz_init (rem);
5313 6665 : mpz_sub (rem, end->value.integer, start->value.integer);
5314 6665 : mpz_tdiv_r (rem, rem, stride->value.integer);
5315 6665 : mpz_sub (last, end->value.integer, rem);
5316 6665 : mpz_clear (rem);
5317 :
5318 6665 : return 1;
5319 : }
5320 :
5321 :
5322 : /* Compare a single dimension of an array reference to the array
5323 : specification. */
5324 :
5325 : static bool
5326 222089 : check_dimension (int i, gfc_array_ref *ar, gfc_array_spec *as)
5327 : {
5328 222089 : mpz_t last_value;
5329 :
5330 222089 : if (ar->dimen_type[i] == DIMEN_STAR)
5331 : {
5332 598 : gcc_assert (ar->stride[i] == NULL);
5333 : /* This implies [*] as [*:] and [*:3] are not possible. */
5334 598 : if (ar->start[i] == NULL)
5335 : {
5336 497 : gcc_assert (ar->end[i] == NULL);
5337 : return true;
5338 : }
5339 : }
5340 :
5341 : /* Given start, end and stride values, calculate the minimum and
5342 : maximum referenced indexes. */
5343 :
5344 221592 : switch (ar->dimen_type[i])
5345 : {
5346 : case DIMEN_VECTOR:
5347 : case DIMEN_THIS_IMAGE:
5348 : break;
5349 :
5350 160110 : case DIMEN_STAR:
5351 160110 : case DIMEN_ELEMENT:
5352 160110 : if (compare_bound (ar->start[i], as->lower[i]) == CMP_LT)
5353 : {
5354 2 : if (i < as->rank)
5355 2 : gfc_warning (0, "Array reference at %L is out of bounds "
5356 : "(%ld < %ld) in dimension %d", &ar->c_where[i],
5357 2 : mpz_get_si (ar->start[i]->value.integer),
5358 2 : mpz_get_si (as->lower[i]->value.integer), i+1);
5359 : else
5360 0 : gfc_warning (0, "Array reference at %L is out of bounds "
5361 : "(%ld < %ld) in codimension %d", &ar->c_where[i],
5362 0 : mpz_get_si (ar->start[i]->value.integer),
5363 0 : mpz_get_si (as->lower[i]->value.integer),
5364 0 : i + 1 - as->rank);
5365 : return true;
5366 : }
5367 160108 : if (compare_bound (ar->start[i], as->upper[i]) == CMP_GT)
5368 : {
5369 39 : if (i < as->rank)
5370 39 : gfc_warning (0, "Array reference at %L is out of bounds "
5371 : "(%ld > %ld) in dimension %d", &ar->c_where[i],
5372 39 : mpz_get_si (ar->start[i]->value.integer),
5373 39 : mpz_get_si (as->upper[i]->value.integer), i+1);
5374 : else
5375 0 : gfc_warning (0, "Array reference at %L is out of bounds "
5376 : "(%ld > %ld) in codimension %d", &ar->c_where[i],
5377 0 : mpz_get_si (ar->start[i]->value.integer),
5378 0 : mpz_get_si (as->upper[i]->value.integer),
5379 0 : i + 1 - as->rank);
5380 : return true;
5381 : }
5382 :
5383 : break;
5384 :
5385 52938 : case DIMEN_RANGE:
5386 52938 : {
5387 : #define AR_START (ar->start[i] ? ar->start[i] : as->lower[i])
5388 : #define AR_END (ar->end[i] ? ar->end[i] : as->upper[i])
5389 :
5390 52938 : compare_result comp_start_end = compare_bound (AR_START, AR_END);
5391 52938 : compare_result comp_stride_zero = compare_bound_int (ar->stride[i], 0);
5392 :
5393 : /* Check for zero stride, which is not allowed. */
5394 52938 : if (comp_stride_zero == CMP_EQ)
5395 : {
5396 1 : gfc_error ("Illegal stride of zero at %L", &ar->c_where[i]);
5397 1 : return false;
5398 : }
5399 :
5400 : /* if start == end || (stride > 0 && start < end)
5401 : || (stride < 0 && start > end),
5402 : then the array section contains at least one element. In this
5403 : case, there is an out-of-bounds access if
5404 : (start < lower || start > upper). */
5405 52937 : if (comp_start_end == CMP_EQ
5406 52175 : || ((comp_stride_zero == CMP_GT || ar->stride[i] == NULL)
5407 49380 : && comp_start_end == CMP_LT)
5408 23123 : || (comp_stride_zero == CMP_LT
5409 23123 : && comp_start_end == CMP_GT))
5410 : {
5411 31165 : if (compare_bound (AR_START, as->lower[i]) == CMP_LT)
5412 : {
5413 27 : gfc_warning (0, "Lower array reference at %L is out of bounds "
5414 : "(%ld < %ld) in dimension %d", &ar->c_where[i],
5415 27 : mpz_get_si (AR_START->value.integer),
5416 27 : mpz_get_si (as->lower[i]->value.integer), i+1);
5417 27 : return true;
5418 : }
5419 31138 : if (compare_bound (AR_START, as->upper[i]) == CMP_GT)
5420 : {
5421 17 : gfc_warning (0, "Lower array reference at %L is out of bounds "
5422 : "(%ld > %ld) in dimension %d", &ar->c_where[i],
5423 17 : mpz_get_si (AR_START->value.integer),
5424 17 : mpz_get_si (as->upper[i]->value.integer), i+1);
5425 17 : return true;
5426 : }
5427 : }
5428 :
5429 : /* If we can compute the highest index of the array section,
5430 : then it also has to be between lower and upper. */
5431 52893 : mpz_init (last_value);
5432 52893 : if (compute_last_value_for_triplet (AR_START, AR_END, ar->stride[i],
5433 : last_value))
5434 : {
5435 31119 : if (compare_bound_mpz_t (as->lower[i], last_value) == CMP_GT)
5436 : {
5437 3 : gfc_warning (0, "Upper array reference at %L is out of bounds "
5438 : "(%ld < %ld) in dimension %d", &ar->c_where[i],
5439 : mpz_get_si (last_value),
5440 3 : mpz_get_si (as->lower[i]->value.integer), i+1);
5441 3 : mpz_clear (last_value);
5442 3 : return true;
5443 : }
5444 31116 : if (compare_bound_mpz_t (as->upper[i], last_value) == CMP_LT)
5445 : {
5446 7 : gfc_warning (0, "Upper array reference at %L is out of bounds "
5447 : "(%ld > %ld) in dimension %d", &ar->c_where[i],
5448 : mpz_get_si (last_value),
5449 7 : mpz_get_si (as->upper[i]->value.integer), i+1);
5450 7 : mpz_clear (last_value);
5451 7 : return true;
5452 : }
5453 : }
5454 52883 : mpz_clear (last_value);
5455 :
5456 : #undef AR_START
5457 : #undef AR_END
5458 : }
5459 52883 : break;
5460 :
5461 0 : default:
5462 0 : gfc_internal_error ("check_dimension(): Bad array reference");
5463 : }
5464 :
5465 : return true;
5466 : }
5467 :
5468 :
5469 : /* Compare an array reference with an array specification. */
5470 :
5471 : static bool
5472 438579 : compare_spec_to_ref (gfc_array_ref *ar)
5473 : {
5474 438579 : gfc_array_spec *as;
5475 438579 : int i;
5476 :
5477 438579 : as = ar->as;
5478 438579 : i = as->rank - 1;
5479 : /* TODO: Full array sections are only allowed as actual parameters. */
5480 438579 : if (as->type == AS_ASSUMED_SIZE
5481 5830 : && (/*ar->type == AR_FULL
5482 5830 : ||*/ (ar->type == AR_SECTION
5483 529 : && ar->dimen_type[i] == DIMEN_RANGE && ar->end[i] == NULL)))
5484 : {
5485 5 : gfc_error ("Rightmost upper bound of assumed size array section "
5486 : "not specified at %L", &ar->where);
5487 5 : return false;
5488 : }
5489 :
5490 438574 : if (ar->type == AR_FULL)
5491 : return true;
5492 :
5493 169095 : if (as->rank != ar->dimen)
5494 : {
5495 28 : gfc_error ("Rank mismatch in array reference at %L (%d/%d)",
5496 : &ar->where, ar->dimen, as->rank);
5497 28 : return false;
5498 : }
5499 :
5500 : /* ar->codimen == 0 is a local array. */
5501 169067 : if (as->corank != ar->codimen && ar->codimen != 0)
5502 : {
5503 0 : gfc_error ("Coindex rank mismatch in array reference at %L (%d/%d)",
5504 : &ar->where, ar->codimen, as->corank);
5505 0 : return false;
5506 : }
5507 :
5508 380925 : for (i = 0; i < as->rank; i++)
5509 211859 : if (!check_dimension (i, ar, as))
5510 : return false;
5511 :
5512 : /* Local access has no coarray spec. */
5513 169066 : if (ar->codimen != 0)
5514 19630 : for (i = as->rank; i < as->rank + as->corank; i++)
5515 : {
5516 10232 : if (ar->dimen_type[i] != DIMEN_ELEMENT && !ar->in_allocate
5517 7120 : && ar->dimen_type[i] != DIMEN_THIS_IMAGE)
5518 : {
5519 2 : gfc_error ("Coindex of codimension %d must be a scalar at %L",
5520 2 : i + 1 - as->rank, &ar->where);
5521 2 : return false;
5522 : }
5523 10230 : if (!check_dimension (i, ar, as))
5524 : return false;
5525 : }
5526 :
5527 : return true;
5528 : }
5529 :
5530 :
5531 : /* Resolve one part of an array index. */
5532 :
5533 : static bool
5534 753214 : gfc_resolve_index_1 (gfc_expr *index, int check_scalar,
5535 : int force_index_integer_kind)
5536 : {
5537 753214 : gfc_typespec ts;
5538 :
5539 753214 : if (index == NULL)
5540 : return true;
5541 :
5542 223353 : if (!gfc_resolve_expr (index))
5543 : return false;
5544 :
5545 223342 : if (check_scalar && index->rank != 0)
5546 : {
5547 2 : gfc_error ("Array index at %L must be scalar", &index->where);
5548 2 : return false;
5549 : }
5550 :
5551 223340 : if (index->ts.type != BT_INTEGER && index->ts.type != BT_REAL)
5552 : {
5553 4 : gfc_error ("Array index at %L must be of INTEGER type, found %s",
5554 : &index->where, gfc_basic_typename (index->ts.type));
5555 4 : return false;
5556 : }
5557 :
5558 223336 : if (index->ts.type == BT_REAL)
5559 657 : if (!gfc_notify_std (GFC_STD_LEGACY, "REAL array index at %L",
5560 : &index->where))
5561 : return false;
5562 :
5563 223336 : if ((index->ts.kind != gfc_index_integer_kind
5564 218240 : && force_index_integer_kind)
5565 191488 : || (index->ts.type != BT_INTEGER
5566 : && index->ts.type != BT_UNKNOWN))
5567 : {
5568 32504 : gfc_clear_ts (&ts);
5569 32504 : ts.type = BT_INTEGER;
5570 32504 : ts.kind = gfc_index_integer_kind;
5571 :
5572 32504 : gfc_convert_type_warn (index, &ts, 2, 0);
5573 : }
5574 :
5575 : return true;
5576 : }
5577 :
5578 : /* Resolve one part of an array index. */
5579 :
5580 : bool
5581 502405 : gfc_resolve_index (gfc_expr *index, int check_scalar)
5582 : {
5583 502405 : return gfc_resolve_index_1 (index, check_scalar, 1);
5584 : }
5585 :
5586 : /* Resolve a dim argument to an intrinsic function. */
5587 :
5588 : bool
5589 23933 : gfc_resolve_dim_arg (gfc_expr *dim)
5590 : {
5591 23933 : if (dim == NULL)
5592 : return true;
5593 :
5594 23933 : if (!gfc_resolve_expr (dim))
5595 : return false;
5596 :
5597 23933 : if (dim->rank != 0)
5598 : {
5599 0 : gfc_error ("Argument dim at %L must be scalar", &dim->where);
5600 0 : return false;
5601 :
5602 : }
5603 :
5604 23933 : if (dim->ts.type != BT_INTEGER)
5605 : {
5606 0 : gfc_error ("Argument dim at %L must be of INTEGER type", &dim->where);
5607 0 : return false;
5608 : }
5609 :
5610 23933 : if (dim->ts.kind != gfc_index_integer_kind)
5611 : {
5612 15318 : gfc_typespec ts;
5613 :
5614 15318 : gfc_clear_ts (&ts);
5615 15318 : ts.type = BT_INTEGER;
5616 15318 : ts.kind = gfc_index_integer_kind;
5617 :
5618 15318 : gfc_convert_type_warn (dim, &ts, 2, 0);
5619 : }
5620 :
5621 : return true;
5622 : }
5623 :
5624 : /* Given an expression that contains array references, update those array
5625 : references to point to the right array specifications. While this is
5626 : filled in during matching, this information is difficult to save and load
5627 : in a module, so we take care of it here.
5628 :
5629 : The idea here is that the original array reference comes from the
5630 : base symbol. We traverse the list of reference structures, setting
5631 : the stored reference to references. Component references can
5632 : provide an additional array specification. */
5633 : static void
5634 : resolve_assoc_var (gfc_symbol* sym, bool resolve_target);
5635 :
5636 : static bool
5637 967 : find_array_spec (gfc_expr *e)
5638 : {
5639 967 : gfc_array_spec *as;
5640 967 : gfc_component *c;
5641 967 : gfc_ref *ref;
5642 967 : bool class_as = false;
5643 :
5644 967 : if (e->symtree->n.sym->assoc)
5645 : {
5646 270 : if (e->symtree->n.sym->assoc->target)
5647 270 : gfc_resolve_expr (e->symtree->n.sym->assoc->target);
5648 270 : resolve_assoc_var (e->symtree->n.sym, false);
5649 : }
5650 :
5651 967 : if (e->symtree->n.sym->ts.type == BT_CLASS)
5652 : {
5653 130 : as = CLASS_DATA (e->symtree->n.sym)->as;
5654 130 : class_as = true;
5655 : }
5656 : else
5657 837 : as = e->symtree->n.sym->as;
5658 :
5659 2305 : for (ref = e->ref; ref; ref = ref->next)
5660 1346 : switch (ref->type)
5661 : {
5662 1005 : case REF_ARRAY:
5663 1005 : if (as == NULL)
5664 : {
5665 8 : locus loc = (GFC_LOCUS_IS_SET (ref->u.ar.where)
5666 16 : ? ref->u.ar.where : e->where);
5667 8 : gfc_error ("Invalid array reference of a non-array entity at %L",
5668 : &loc);
5669 8 : return false;
5670 : }
5671 :
5672 997 : ref->u.ar.as = as;
5673 997 : if (ref->u.ar.dimen == -1) ref->u.ar.dimen = as->rank;
5674 : as = NULL;
5675 : break;
5676 :
5677 317 : case REF_COMPONENT:
5678 317 : c = ref->u.c.component;
5679 317 : if (c->attr.dimension)
5680 : {
5681 107 : if (as != NULL && !(class_as && as == c->as))
5682 0 : gfc_internal_error ("find_array_spec(): unused as(1)");
5683 107 : as = c->as;
5684 : }
5685 210 : else if (c->ts.type == BT_CLASS && CLASS_DATA (c)
5686 54 : && CLASS_DATA (c)->attr.dimension
5687 36 : && ref->next && ref->next->type == REF_ARRAY)
5688 : {
5689 : /* CLASS array component with an implicit '_data' reference. */
5690 36 : if (as != NULL)
5691 0 : gfc_internal_error ("find_array_spec(): unused as(1)");
5692 36 : as = CLASS_DATA (c)->as;
5693 : }
5694 :
5695 : break;
5696 :
5697 : case REF_SUBSTRING:
5698 : case REF_INQUIRY:
5699 : break;
5700 : }
5701 :
5702 959 : if (as != NULL)
5703 0 : gfc_internal_error ("find_array_spec(): unused as(2)");
5704 :
5705 : return true;
5706 : }
5707 :
5708 :
5709 : /* Resolve an array reference. */
5710 :
5711 : static bool
5712 439293 : resolve_array_ref (gfc_array_ref *ar)
5713 : {
5714 439293 : int i, check_scalar;
5715 439293 : gfc_expr *e;
5716 :
5717 690085 : for (i = 0; i < ar->dimen + ar->codimen; i++)
5718 : {
5719 250809 : check_scalar = ar->dimen_type[i] == DIMEN_RANGE;
5720 :
5721 : /* Do not force gfc_index_integer_kind for the start. We can
5722 : do fine with any integer kind. This avoids temporary arrays
5723 : created for indexing with a vector. */
5724 250809 : if (!gfc_resolve_index_1 (ar->start[i], check_scalar, 0))
5725 : return false;
5726 250794 : if (!gfc_resolve_index (ar->end[i], check_scalar))
5727 : return false;
5728 250792 : if (!gfc_resolve_index (ar->stride[i], check_scalar))
5729 : return false;
5730 :
5731 250792 : e = ar->start[i];
5732 :
5733 250792 : if (ar->dimen_type[i] == DIMEN_UNKNOWN)
5734 149976 : switch (e->rank)
5735 : {
5736 148878 : case 0:
5737 148878 : ar->dimen_type[i] = DIMEN_ELEMENT;
5738 148878 : break;
5739 :
5740 1098 : case 1:
5741 1098 : ar->dimen_type[i] = DIMEN_VECTOR;
5742 1098 : if (e->expr_type == EXPR_VARIABLE
5743 470 : && e->symtree->n.sym->ts.type == BT_DERIVED)
5744 13 : ar->start[i] = gfc_get_parentheses (e);
5745 : break;
5746 :
5747 0 : default:
5748 0 : gfc_error ("Array index at %L is an array of rank %d",
5749 : &ar->c_where[i], e->rank);
5750 0 : return false;
5751 : }
5752 :
5753 : /* Fill in the upper bound, which may be lower than the
5754 : specified one for something like a(2:10:5), which is
5755 : identical to a(2:7:5). Only relevant for strides not equal
5756 : to one. Don't try a division by zero. */
5757 250792 : if (ar->dimen_type[i] == DIMEN_RANGE
5758 72961 : && ar->stride[i] != NULL && ar->stride[i]->expr_type == EXPR_CONSTANT
5759 8574 : && mpz_cmp_si (ar->stride[i]->value.integer, 1L) != 0
5760 8427 : && mpz_cmp_si (ar->stride[i]->value.integer, 0L) != 0)
5761 : {
5762 8426 : mpz_t size, end;
5763 :
5764 8426 : if (gfc_ref_dimen_size (ar, i, &size, &end))
5765 : {
5766 6695 : if (ar->end[i] == NULL)
5767 : {
5768 8062 : ar->end[i] =
5769 4031 : gfc_get_constant_expr (BT_INTEGER, gfc_index_integer_kind,
5770 : &ar->where);
5771 4031 : mpz_set (ar->end[i]->value.integer, end);
5772 : }
5773 2664 : else if (ar->end[i]->ts.type == BT_INTEGER
5774 2664 : && ar->end[i]->expr_type == EXPR_CONSTANT)
5775 : {
5776 2664 : mpz_set (ar->end[i]->value.integer, end);
5777 : }
5778 : else
5779 0 : gcc_unreachable ();
5780 :
5781 6695 : mpz_clear (size);
5782 6695 : mpz_clear (end);
5783 : }
5784 : }
5785 : }
5786 :
5787 439276 : if (ar->type == AR_FULL)
5788 : {
5789 273433 : if (ar->as->rank == 0)
5790 3920 : ar->type = AR_ELEMENT;
5791 :
5792 : /* Make sure array is the same as array(:,:), this way
5793 : we don't need to special case all the time. */
5794 273433 : ar->dimen = ar->as->rank;
5795 649247 : for (i = 0; i < ar->dimen; i++)
5796 : {
5797 375814 : ar->dimen_type[i] = DIMEN_RANGE;
5798 :
5799 375814 : gcc_assert (ar->start[i] == NULL);
5800 375814 : gcc_assert (ar->end[i] == NULL);
5801 375814 : gcc_assert (ar->stride[i] == NULL);
5802 : }
5803 : }
5804 :
5805 : /* If the reference type is unknown, figure out what kind it is. */
5806 :
5807 439276 : if (ar->type == AR_UNKNOWN)
5808 : {
5809 152425 : ar->type = AR_ELEMENT;
5810 295506 : for (i = 0; i < ar->dimen; i++)
5811 181771 : if (ar->dimen_type[i] == DIMEN_RANGE
5812 181771 : || ar->dimen_type[i] == DIMEN_VECTOR)
5813 : {
5814 38690 : ar->type = AR_SECTION;
5815 38690 : break;
5816 : }
5817 : }
5818 :
5819 439276 : if (!ar->as->cray_pointee && !compare_spec_to_ref (ar))
5820 : return false;
5821 :
5822 439240 : if (ar->as->corank && ar->codimen == 0)
5823 : {
5824 2394 : int n;
5825 2394 : ar->codimen = ar->as->corank;
5826 6554 : for (n = ar->dimen; n < ar->dimen + ar->codimen; n++)
5827 4160 : ar->dimen_type[n] = DIMEN_THIS_IMAGE;
5828 : }
5829 :
5830 439240 : if (ar->codimen)
5831 : {
5832 14395 : if (ar->team_type == TEAM_NUMBER)
5833 : {
5834 60 : if (!gfc_resolve_expr (ar->team))
5835 : return false;
5836 :
5837 60 : if (ar->team->rank != 0)
5838 : {
5839 0 : gfc_error ("TEAM_NUMBER argument at %L must be scalar",
5840 : &ar->team->where);
5841 0 : return false;
5842 : }
5843 :
5844 60 : if (ar->team->ts.type != BT_INTEGER)
5845 : {
5846 6 : gfc_error ("TEAM_NUMBER argument at %L must be of INTEGER "
5847 : "type, found %s",
5848 6 : &ar->team->where,
5849 : gfc_basic_typename (ar->team->ts.type));
5850 6 : return false;
5851 : }
5852 : }
5853 14335 : else if (ar->team_type == TEAM_TEAM)
5854 : {
5855 42 : if (!gfc_resolve_expr (ar->team))
5856 : return false;
5857 :
5858 42 : if (ar->team->rank != 0)
5859 : {
5860 3 : gfc_error ("TEAM argument at %L must be scalar",
5861 : &ar->team->where);
5862 3 : return false;
5863 : }
5864 :
5865 39 : if (ar->team->ts.type != BT_DERIVED
5866 36 : || ar->team->ts.u.derived->from_intmod != INTMOD_ISO_FORTRAN_ENV
5867 36 : || ar->team->ts.u.derived->intmod_sym_id != ISOFORTRAN_TEAM_TYPE)
5868 : {
5869 3 : gfc_error ("TEAM argument at %L must be of TEAM_TYPE from "
5870 : "the intrinsic module ISO_FORTRAN_ENV, found %s",
5871 3 : &ar->team->where,
5872 : gfc_basic_typename (ar->team->ts.type));
5873 3 : return false;
5874 : }
5875 : }
5876 14383 : if (ar->stat)
5877 : {
5878 62 : if (!gfc_resolve_expr (ar->stat))
5879 : return false;
5880 :
5881 62 : if (ar->stat->rank != 0)
5882 : {
5883 3 : gfc_error ("STAT argument at %L must be scalar",
5884 : &ar->stat->where);
5885 3 : return false;
5886 : }
5887 :
5888 59 : if (ar->stat->ts.type != BT_INTEGER)
5889 : {
5890 3 : gfc_error ("STAT argument at %L must be of INTEGER "
5891 : "type, found %s",
5892 3 : &ar->stat->where,
5893 : gfc_basic_typename (ar->stat->ts.type));
5894 3 : return false;
5895 : }
5896 :
5897 56 : if (ar->stat->expr_type != EXPR_VARIABLE)
5898 : {
5899 0 : gfc_error ("STAT's expression at %L must be a variable",
5900 : &ar->stat->where);
5901 0 : return false;
5902 : }
5903 : }
5904 : }
5905 : return true;
5906 : }
5907 :
5908 :
5909 : bool
5910 8988 : gfc_resolve_substring (gfc_ref *ref, bool *equal_length)
5911 : {
5912 8988 : int k = gfc_validate_kind (BT_INTEGER, gfc_charlen_int_kind, false);
5913 :
5914 8988 : if (ref->u.ss.start != NULL)
5915 : {
5916 8988 : if (!gfc_resolve_expr (ref->u.ss.start))
5917 : return false;
5918 :
5919 8988 : if (ref->u.ss.start->ts.type != BT_INTEGER)
5920 : {
5921 1 : gfc_error ("Substring start index at %L must be of type INTEGER",
5922 : &ref->u.ss.start->where);
5923 1 : return false;
5924 : }
5925 :
5926 8987 : if (ref->u.ss.start->rank != 0)
5927 : {
5928 0 : gfc_error ("Substring start index at %L must be scalar",
5929 : &ref->u.ss.start->where);
5930 0 : return false;
5931 : }
5932 :
5933 8987 : if (compare_bound_int (ref->u.ss.start, 1) == CMP_LT
5934 8987 : && (compare_bound (ref->u.ss.end, ref->u.ss.start) == CMP_EQ
5935 37 : || compare_bound (ref->u.ss.end, ref->u.ss.start) == CMP_GT))
5936 : {
5937 1 : gfc_error ("Substring start index at %L is less than one",
5938 : &ref->u.ss.start->where);
5939 1 : return false;
5940 : }
5941 : }
5942 :
5943 8986 : if (ref->u.ss.end != NULL)
5944 : {
5945 8792 : if (!gfc_resolve_expr (ref->u.ss.end))
5946 : return false;
5947 :
5948 8792 : if (ref->u.ss.end->ts.type != BT_INTEGER)
5949 : {
5950 1 : gfc_error ("Substring end index at %L must be of type INTEGER",
5951 : &ref->u.ss.end->where);
5952 1 : return false;
5953 : }
5954 :
5955 8791 : if (ref->u.ss.end->rank != 0)
5956 : {
5957 0 : gfc_error ("Substring end index at %L must be scalar",
5958 : &ref->u.ss.end->where);
5959 0 : return false;
5960 : }
5961 :
5962 8791 : if (ref->u.ss.length != NULL
5963 8454 : && compare_bound (ref->u.ss.end, ref->u.ss.length->length) == CMP_GT
5964 8803 : && (compare_bound (ref->u.ss.end, ref->u.ss.start) == CMP_EQ
5965 12 : || compare_bound (ref->u.ss.end, ref->u.ss.start) == CMP_GT))
5966 : {
5967 4 : gfc_error ("Substring end index at %L exceeds the string length",
5968 : &ref->u.ss.start->where);
5969 4 : return false;
5970 : }
5971 :
5972 8787 : if (compare_bound_mpz_t (ref->u.ss.end,
5973 8787 : gfc_integer_kinds[k].huge) == CMP_GT
5974 8787 : && (compare_bound (ref->u.ss.end, ref->u.ss.start) == CMP_EQ
5975 7 : || compare_bound (ref->u.ss.end, ref->u.ss.start) == CMP_GT))
5976 : {
5977 4 : gfc_error ("Substring end index at %L is too large",
5978 : &ref->u.ss.end->where);
5979 4 : return false;
5980 : }
5981 : /* If the substring has the same length as the original
5982 : variable, the reference itself can be deleted. */
5983 :
5984 8783 : if (ref->u.ss.length != NULL
5985 8446 : && compare_bound (ref->u.ss.end, ref->u.ss.length->length) == CMP_EQ
5986 9724 : && compare_bound_int (ref->u.ss.start, 1) == CMP_EQ)
5987 236 : *equal_length = true;
5988 : }
5989 :
5990 : return true;
5991 : }
5992 :
5993 :
5994 : /* This function supplies missing substring charlens. */
5995 :
5996 : void
5997 9862 : gfc_resolve_substring_charlen (gfc_expr *e)
5998 : {
5999 9862 : gfc_ref *char_ref;
6000 9862 : gfc_expr *start, *end;
6001 9862 : gfc_typespec *ts = NULL;
6002 9862 : mpz_t diff;
6003 :
6004 14253 : for (char_ref = e->ref; char_ref; char_ref = char_ref->next)
6005 : {
6006 12406 : if (char_ref->type == REF_SUBSTRING || char_ref->type == REF_INQUIRY)
6007 : break;
6008 4391 : if (char_ref->type == REF_COMPONENT)
6009 358 : ts = &char_ref->u.c.component->ts;
6010 : }
6011 :
6012 9862 : if (!char_ref || char_ref->type == REF_INQUIRY)
6013 2019 : return;
6014 :
6015 8015 : gcc_assert (char_ref->next == NULL);
6016 :
6017 8015 : if (e->ts.u.cl)
6018 : {
6019 120 : if (e->ts.u.cl->length)
6020 120 : gfc_free_expr (e->ts.u.cl->length);
6021 0 : else if (e->expr_type == EXPR_VARIABLE && e->symtree->n.sym->attr.dummy)
6022 : return;
6023 : }
6024 :
6025 8015 : if (!e->ts.u.cl)
6026 7895 : e->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
6027 :
6028 8015 : if (char_ref->u.ss.start)
6029 8015 : start = gfc_copy_expr (char_ref->u.ss.start);
6030 : else
6031 0 : start = gfc_get_int_expr (gfc_charlen_int_kind, NULL, 1);
6032 :
6033 8015 : if (char_ref->u.ss.end)
6034 7843 : end = gfc_copy_expr (char_ref->u.ss.end);
6035 172 : else if (e->expr_type == EXPR_VARIABLE)
6036 : {
6037 172 : if (!ts)
6038 154 : ts = &e->symtree->n.sym->ts;
6039 172 : end = gfc_copy_expr (ts->u.cl->length);
6040 : }
6041 : else
6042 : end = NULL;
6043 :
6044 8015 : if (!start || !end)
6045 : {
6046 172 : gfc_free_expr (start);
6047 172 : gfc_free_expr (end);
6048 172 : return;
6049 : }
6050 :
6051 : /* Length = (end - start + 1).
6052 : Check first whether it has a constant length. */
6053 7843 : if (gfc_dep_difference (end, start, &diff))
6054 : {
6055 7229 : gfc_expr *len = gfc_get_constant_expr (BT_INTEGER, gfc_charlen_int_kind,
6056 : &e->where);
6057 :
6058 7229 : mpz_add_ui (len->value.integer, diff, 1);
6059 7229 : mpz_clear (diff);
6060 7229 : e->ts.u.cl->length = len;
6061 : /* The check for length < 0 is handled below */
6062 : }
6063 : else
6064 : {
6065 614 : e->ts.u.cl->length = gfc_subtract (end, start);
6066 614 : e->ts.u.cl->length = gfc_add (e->ts.u.cl->length,
6067 : gfc_get_int_expr (gfc_charlen_int_kind,
6068 : NULL, 1));
6069 : }
6070 :
6071 : /* F2008, 6.4.1: Both the starting point and the ending point shall
6072 : be within the range 1, 2, ..., n unless the starting point exceeds
6073 : the ending point, in which case the substring has length zero. */
6074 :
6075 7843 : if (mpz_cmp_si (e->ts.u.cl->length->value.integer, 0) < 0)
6076 52 : mpz_set_si (e->ts.u.cl->length->value.integer, 0);
6077 :
6078 7843 : e->ts.u.cl->length->ts.type = BT_INTEGER;
6079 7843 : e->ts.u.cl->length->ts.kind = gfc_charlen_int_kind;
6080 :
6081 : /* Make sure that the length is simplified. */
6082 7843 : gfc_simplify_expr (e->ts.u.cl->length, 1);
6083 7843 : gfc_resolve_expr (e->ts.u.cl->length);
6084 : }
6085 :
6086 :
6087 : /* Convert an array reference to an array element so that PDT KIND and LEN
6088 : or inquiry references are always scalar. */
6089 :
6090 : static void
6091 51 : reset_array_ref_to_scalar (gfc_expr *expr, gfc_ref *array_ref)
6092 : {
6093 51 : gfc_expr *unity = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
6094 51 : int dim;
6095 :
6096 51 : array_ref->u.ar.type = AR_ELEMENT;
6097 51 : expr->rank = 0;
6098 : /* Suppress the runtime bounds check. */
6099 51 : expr->no_bounds_check = 1;
6100 102 : for (dim = 0; dim < array_ref->u.ar.dimen; dim++)
6101 : {
6102 51 : array_ref->u.ar.dimen_type[dim] = DIMEN_ELEMENT;
6103 51 : if (array_ref->u.ar.start[dim])
6104 0 : gfc_free_expr (array_ref->u.ar.start[dim]);
6105 :
6106 51 : if (array_ref->u.ar.as && array_ref->u.ar.as->lower[dim])
6107 15 : array_ref->u.ar.start[dim]
6108 15 : = gfc_copy_expr (array_ref->u.ar.as->lower[dim]);
6109 : else
6110 36 : array_ref->u.ar.start[dim] = gfc_copy_expr (unity);
6111 :
6112 51 : if (array_ref->u.ar.end[dim])
6113 0 : gfc_free_expr (array_ref->u.ar.end[dim]);
6114 51 : if (array_ref->u.ar.stride[dim])
6115 0 : gfc_free_expr (array_ref->u.ar.stride[dim]);
6116 : }
6117 51 : gfc_free_expr (unity);
6118 51 : }
6119 :
6120 :
6121 : /* Resolve subtype references. */
6122 :
6123 : bool
6124 561111 : gfc_resolve_ref (gfc_expr *expr)
6125 : {
6126 561111 : int current_part_dimension, n_components, seen_part_dimension;
6127 561111 : gfc_ref *ref, **prev, *array_ref;
6128 561111 : bool equal_length;
6129 561111 : gfc_symbol *last_pdt = NULL;
6130 :
6131 1104566 : for (ref = expr->ref; ref; ref = ref->next)
6132 544422 : if (ref->type == REF_ARRAY && ref->u.ar.as == NULL)
6133 : {
6134 967 : if (!find_array_spec (expr))
6135 : return false;
6136 : break;
6137 : }
6138 :
6139 1650092 : for (prev = &expr->ref; *prev != NULL;
6140 544600 : prev = *prev == NULL ? prev : &(*prev)->next)
6141 544679 : switch ((*prev)->type)
6142 : {
6143 439293 : case REF_ARRAY:
6144 439293 : if (!resolve_array_ref (&(*prev)->u.ar))
6145 : return false;
6146 : break;
6147 :
6148 : case REF_COMPONENT:
6149 : case REF_INQUIRY:
6150 : break;
6151 :
6152 8707 : case REF_SUBSTRING:
6153 8707 : equal_length = false;
6154 8707 : if (!gfc_resolve_substring (*prev, &equal_length))
6155 : return false;
6156 :
6157 8699 : if (expr->expr_type != EXPR_SUBSTRING && equal_length)
6158 : {
6159 : /* Remove the reference and move the charlen, if any. */
6160 211 : ref = *prev;
6161 211 : *prev = ref->next;
6162 211 : ref->next = NULL;
6163 211 : expr->ts.u.cl = ref->u.ss.length;
6164 211 : ref->u.ss.length = NULL;
6165 211 : gfc_free_ref_list (ref);
6166 : }
6167 : break;
6168 : }
6169 :
6170 : /* Check constraints on part references. */
6171 :
6172 561024 : current_part_dimension = 0;
6173 561024 : seen_part_dimension = 0;
6174 561024 : n_components = 0;
6175 561024 : array_ref = NULL;
6176 :
6177 : /* Use the declared type of the base symbol to initialize last_pdt when the
6178 : expression is not itself a PDT. This matters for ASSOCIATE variables whose
6179 : component reference may still point to a PDT template. */
6180 561024 : if (expr->expr_type == EXPR_VARIABLE
6181 464405 : && (IS_PDT (expr)
6182 463625 : || (expr->ref && expr->symtree && IS_PDT (expr->symtree->n.sym))))
6183 4499 : last_pdt = expr->symtree->n.sym->ts.u.derived;
6184 :
6185 1105388 : for (ref = expr->ref; ref; ref = ref->next)
6186 : {
6187 544375 : switch (ref->type)
6188 : {
6189 439215 : case REF_ARRAY:
6190 439215 : array_ref = ref;
6191 439215 : switch (ref->u.ar.type)
6192 : {
6193 269511 : case AR_FULL:
6194 : /* Coarray scalar. */
6195 269511 : if (ref->u.ar.as->rank == 0)
6196 : {
6197 : current_part_dimension = 0;
6198 : break;
6199 : }
6200 : /* Fall through. */
6201 311344 : case AR_SECTION:
6202 311344 : current_part_dimension = 1;
6203 311344 : break;
6204 :
6205 127871 : case AR_ELEMENT:
6206 127871 : array_ref = NULL;
6207 127871 : current_part_dimension = 0;
6208 127871 : break;
6209 :
6210 0 : case AR_UNKNOWN:
6211 0 : gfc_internal_error ("resolve_ref(): Bad array reference");
6212 : }
6213 :
6214 : break;
6215 :
6216 95713 : case REF_COMPONENT:
6217 95713 : if (current_part_dimension || seen_part_dimension)
6218 : {
6219 : /* F03:C614. */
6220 7715 : if (ref->u.c.component->attr.pointer
6221 7712 : || ref->u.c.component->attr.proc_pointer
6222 7711 : || (ref->u.c.component->ts.type == BT_CLASS
6223 1 : && CLASS_DATA (ref->u.c.component)->attr.pointer))
6224 : {
6225 4 : gfc_error ("Component to the right of a part reference "
6226 : "with nonzero rank must not have the POINTER "
6227 : "attribute at %L", &expr->where);
6228 4 : return false;
6229 : }
6230 7711 : else if (ref->u.c.component->attr.allocatable
6231 7705 : || (ref->u.c.component->ts.type == BT_CLASS
6232 1 : && CLASS_DATA (ref->u.c.component)->attr.allocatable))
6233 :
6234 : {
6235 7 : gfc_error ("Component to the right of a part reference "
6236 : "with nonzero rank must not have the ALLOCATABLE "
6237 : "attribute at %L", &expr->where);
6238 7 : return false;
6239 : }
6240 : }
6241 :
6242 : /* Sometimes the component in a component reference is that of the
6243 : pdt_template. Point to the component of pdt_type instead. This
6244 : ensures that the component gets a backend_decl in translation. */
6245 95702 : if (last_pdt)
6246 : {
6247 4358 : gfc_component *cmp = last_pdt->components;
6248 12609 : for (; cmp; cmp = cmp->next)
6249 12256 : if (!strcmp (cmp->name, ref->u.c.component->name))
6250 : {
6251 4005 : ref->u.c.component = cmp;
6252 4005 : break;
6253 : }
6254 4358 : ref->u.c.sym = last_pdt;
6255 : }
6256 :
6257 : /* Convert pdt_templates, if necessary, and update 'last_pdt'. */
6258 95702 : if (ref->u.c.component->ts.type == BT_DERIVED)
6259 : {
6260 21964 : if (ref->u.c.component->ts.u.derived->attr.pdt_template)
6261 : {
6262 0 : if (gfc_get_pdt_instance (ref->u.c.component->param_list,
6263 : &ref->u.c.component->ts.u.derived,
6264 : NULL) != MATCH_YES)
6265 : return false;
6266 0 : last_pdt = ref->u.c.component->ts.u.derived;
6267 : }
6268 21964 : else if (ref->u.c.component->ts.u.derived->attr.pdt_type)
6269 659 : last_pdt = ref->u.c.component->ts.u.derived;
6270 : else
6271 : last_pdt = NULL;
6272 : }
6273 :
6274 : /* The F08 standard requires(See R425, R431, R435, and in particular
6275 : Note 6.7) that a PDT parameter reference be a scalar even if
6276 : the designator is an array." */
6277 95702 : if (array_ref && last_pdt && last_pdt->attr.pdt_type
6278 203 : && (ref->u.c.component->attr.pdt_kind
6279 203 : || ref->u.c.component->attr.pdt_len))
6280 25 : reset_array_ref_to_scalar (expr, array_ref);
6281 :
6282 95702 : n_components++;
6283 95702 : break;
6284 :
6285 : case REF_SUBSTRING:
6286 : break;
6287 :
6288 959 : case REF_INQUIRY:
6289 : /* Implement requirement in note 9.7 of F2018 that the result of the
6290 : LEN inquiry be a scalar. */
6291 959 : if (ref->u.i == INQUIRY_LEN && array_ref
6292 52 : && ((expr->ts.type == BT_CHARACTER && !expr->ts.u.cl->length)
6293 52 : || expr->ts.type == BT_INTEGER))
6294 26 : reset_array_ref_to_scalar (expr, array_ref);
6295 : break;
6296 : }
6297 :
6298 544364 : if (((ref->type == REF_COMPONENT && n_components > 1)
6299 530015 : || ref->next == NULL)
6300 : && current_part_dimension
6301 474322 : && seen_part_dimension)
6302 : {
6303 0 : gfc_error ("Two or more part references with nonzero rank must "
6304 : "not be specified at %L", &expr->where);
6305 0 : return false;
6306 : }
6307 :
6308 544364 : if (ref->type == REF_COMPONENT)
6309 : {
6310 95702 : if (current_part_dimension)
6311 7493 : seen_part_dimension = 1;
6312 :
6313 : /* reset to make sure */
6314 : current_part_dimension = 0;
6315 : }
6316 : }
6317 :
6318 : return true;
6319 : }
6320 :
6321 :
6322 : /* Given an expression, determine its shape. This is easier than it sounds.
6323 : Leaves the shape array NULL if it is not possible to determine the shape. */
6324 :
6325 : static void
6326 2657288 : expression_shape (gfc_expr *e)
6327 : {
6328 2657288 : mpz_t array[GFC_MAX_DIMENSIONS];
6329 2657288 : int i;
6330 :
6331 2657288 : if (e->rank <= 0 || e->shape != NULL)
6332 2474516 : return;
6333 :
6334 726313 : for (i = 0; i < e->rank; i++)
6335 490464 : if (!gfc_array_dimen_size (e, i, &array[i]))
6336 182772 : goto fail;
6337 :
6338 235849 : e->shape = gfc_get_shape (e->rank);
6339 :
6340 235849 : memcpy (e->shape, array, e->rank * sizeof (mpz_t));
6341 :
6342 235849 : return;
6343 :
6344 182772 : fail:
6345 184467 : for (i--; i >= 0; i--)
6346 1695 : mpz_clear (array[i]);
6347 : }
6348 :
6349 :
6350 : /* Given a variable expression node, compute the rank of the expression by
6351 : examining the base symbol and any reference structures it may have. */
6352 :
6353 : void
6354 2657288 : gfc_expression_rank (gfc_expr *e)
6355 : {
6356 2657288 : gfc_ref *ref, *coarray_ref = nullptr;
6357 2657288 : int i, rank, corank;
6358 :
6359 : /* Just to make sure, because EXPR_COMPCALL's also have an e->ref and that
6360 : could lead to serious confusion... */
6361 2657288 : gcc_assert (e->expr_type != EXPR_COMPCALL);
6362 :
6363 2657288 : if (e->ref == NULL)
6364 : {
6365 1952331 : if (e->expr_type == EXPR_ARRAY)
6366 75196 : goto done;
6367 : /* Constructors can have a rank different from one via RESHAPE(). */
6368 :
6369 1877135 : if (e->symtree != NULL)
6370 : {
6371 : /* After errors the ts.u.derived of a CLASS might not be set. */
6372 1877123 : gfc_array_spec *as = (e->symtree->n.sym->ts.type == BT_CLASS
6373 14480 : && e->symtree->n.sym->ts.u.derived
6374 14475 : && CLASS_DATA (e->symtree->n.sym))
6375 1877123 : ? CLASS_DATA (e->symtree->n.sym)->as
6376 : : e->symtree->n.sym->as;
6377 1877123 : if (as)
6378 : {
6379 674 : e->rank = as->rank;
6380 674 : e->corank = as->corank;
6381 674 : goto done;
6382 : }
6383 : }
6384 1876461 : e->rank = 0;
6385 1876461 : e->corank = 0;
6386 1876461 : goto done;
6387 : }
6388 :
6389 : rank = 0;
6390 : corank = 0;
6391 :
6392 1120246 : for (ref = e->ref; ref; ref = ref->next)
6393 : {
6394 820535 : if (ref->type == REF_COMPONENT && ref->u.c.component->attr.proc_pointer
6395 619 : && ref->u.c.component->attr.function && !ref->next)
6396 : {
6397 423 : rank = ref->u.c.component->as ? ref->u.c.component->as->rank : 0;
6398 423 : corank = ref->u.c.component->as ? ref->u.c.component->as->corank : 0;
6399 : }
6400 :
6401 : /* F2018:5.4.7(5): an allocatable or pointer component selector ends the
6402 : codimensions inherited from an enclosing coarray. */
6403 820535 : if (ref->type == REF_COMPONENT)
6404 : {
6405 161802 : gfc_component *comp = ref->u.c.component;
6406 :
6407 161802 : if (comp->ts.type == BT_CLASS && comp->attr.class_ok)
6408 : {
6409 8137 : if (CLASS_DATA (comp)->attr.class_pointer
6410 6466 : || CLASS_DATA (comp)->attr.allocatable)
6411 820535 : coarray_ref = nullptr;
6412 : }
6413 153665 : else if (comp->attr.pointer || comp->attr.allocatable)
6414 820535 : coarray_ref = nullptr;
6415 : }
6416 :
6417 820535 : if (ref->type != REF_ARRAY)
6418 169557 : continue;
6419 :
6420 650978 : if (!coarray_ref && ref->u.ar.as && ref->u.ar.as->corank > 0)
6421 650978 : coarray_ref = ref;
6422 650978 : if (ref->u.ar.type == AR_FULL && ref->u.ar.as)
6423 : {
6424 358693 : rank = ref->u.ar.as->rank;
6425 358693 : break;
6426 : }
6427 :
6428 292285 : if (ref->u.ar.type == AR_SECTION)
6429 : {
6430 : /* Figure out the rank of the section. */
6431 46553 : if (rank != 0)
6432 0 : gfc_internal_error ("gfc_expression_rank(): Two array specs");
6433 :
6434 115979 : for (i = 0; i < ref->u.ar.dimen; i++)
6435 69426 : if (ref->u.ar.dimen_type[i] == DIMEN_RANGE
6436 69426 : || ref->u.ar.dimen_type[i] == DIMEN_VECTOR)
6437 60440 : rank++;
6438 :
6439 : break;
6440 : }
6441 : }
6442 : /* The codimensions come from the reference carrying them, which need not be
6443 : the last array reference: a subobject of a coarray is itself a coarray. */
6444 704957 : if (coarray_ref && coarray_ref->u.ar.as->rank != -1)
6445 : {
6446 19779 : for (i = coarray_ref->u.ar.as->rank;
6447 36727 : i < coarray_ref->u.ar.as->rank + coarray_ref->u.ar.as->corank; ++i)
6448 : {
6449 : /* For unknown dimen in non-resolved as assume full corank. */
6450 20916 : if (coarray_ref->u.ar.dimen_type[i] == DIMEN_STAR
6451 20246 : || (coarray_ref->u.ar.dimen_type[i] == DIMEN_UNKNOWN
6452 467 : && !coarray_ref->u.ar.as->resolved))
6453 : {
6454 : corank = coarray_ref->u.ar.as->corank;
6455 : break;
6456 : }
6457 19779 : else if (coarray_ref->u.ar.dimen_type[i] == DIMEN_RANGE
6458 19779 : || coarray_ref->u.ar.dimen_type[i] == DIMEN_VECTOR
6459 19681 : || coarray_ref->u.ar.dimen_type[i] == DIMEN_THIS_IMAGE)
6460 17223 : corank++;
6461 2556 : else if (coarray_ref->u.ar.dimen_type[i] != DIMEN_ELEMENT)
6462 0 : gfc_internal_error ("Illegal coarray index");
6463 : }
6464 : }
6465 :
6466 704957 : e->rank = rank;
6467 704957 : e->corank = corank;
6468 :
6469 2657288 : done:
6470 2657288 : expression_shape (e);
6471 2657288 : }
6472 :
6473 :
6474 : /* Given two expressions, check that their rank is conformable, i.e. either
6475 : both have the same rank or at least one is a scalar. */
6476 :
6477 : bool
6478 12268774 : gfc_op_rank_conformable (gfc_expr *op1, gfc_expr *op2)
6479 : {
6480 12268774 : if (op1->expr_type == EXPR_VARIABLE)
6481 749957 : gfc_expression_rank (op1);
6482 12268774 : if (op2->expr_type == EXPR_VARIABLE)
6483 450983 : gfc_expression_rank (op2);
6484 :
6485 79969 : return (op1->rank == 0 || op2->rank == 0 || op1->rank == op2->rank)
6486 12348417 : && (op1->corank == 0 || op2->corank == 0 || op1->corank == op2->corank
6487 30 : || (!gfc_is_coindexed (op1) && !gfc_is_coindexed (op2)));
6488 : }
6489 :
6490 :
6491 : /* Given an expression EXPR that is a variable, figure out what the ultimate
6492 : variable's type is and store it in TS, traversing the reference structures
6493 : if necessary.
6494 :
6495 : We start at the base symbol and store the type. Component references
6496 : overwrite a completely new type. */
6497 :
6498 : static void
6499 1346478 : get_data_ref_type (gfc_expr *expr, gfc_typespec *ts)
6500 : {
6501 1346478 : gfc_ref *ref;
6502 1346478 : gfc_symbol *sym;
6503 1346478 : gfc_component *comp;
6504 1346478 : bool has_inquiry_part;
6505 1346478 : bool has_substring_ref = false;
6506 :
6507 1346478 : if (expr->expr_type != EXPR_VARIABLE
6508 14 : && expr->expr_type != EXPR_FUNCTION
6509 0 : && !(expr->expr_type == EXPR_NULL && expr->ts.type != BT_UNKNOWN))
6510 0 : gfc_internal_error ("get_data_ref_type(): Expression isn't a variable");
6511 :
6512 1346478 : sym = expr->symtree->n.sym;
6513 :
6514 1346478 : if (ts != NULL && expr->ts.type == BT_UNKNOWN)
6515 53409 : *ts = sym->ts;
6516 :
6517 : /* Catch left-overs from match_actual_arg, where an actual argument of a
6518 : procedure is given a temporary ts.type == BT_PROCEDURE. The fixup is
6519 : needed for structure constructors in DATA statements, where a pointer
6520 : is associated with a data target, and the argument has not been fully
6521 : resolved yet. Components references are dealt with further below. */
6522 53409 : if (ts != NULL
6523 1346478 : && expr->ts.type == BT_PROCEDURE
6524 3114 : && expr->ref == NULL
6525 3114 : && sym->attr.flavor != FL_PROCEDURE
6526 161 : && sym->attr.target)
6527 1 : *ts = sym->ts;
6528 :
6529 1346478 : has_inquiry_part = false;
6530 1870685 : for (ref = expr->ref; ref; ref = ref->next)
6531 525007 : if (ref->type == REF_SUBSTRING)
6532 : has_substring_ref = true;
6533 517315 : else if (ref->type == REF_INQUIRY)
6534 : {
6535 : has_inquiry_part = true;
6536 : break;
6537 : }
6538 :
6539 1871492 : for (ref = expr->ref; ref; ref = ref->next)
6540 525014 : switch (ref->type)
6541 : {
6542 93665 : case REF_COMPONENT:
6543 93665 : comp = ref->u.c.component;
6544 93665 : if (ts != NULL && !has_inquiry_part)
6545 : {
6546 93526 : *ts = comp->ts;
6547 : /* Don't set the string length if a substring reference
6548 : follows. */
6549 93526 : if (ts->type == BT_CHARACTER && has_substring_ref)
6550 312 : ts->u.cl = NULL;
6551 : }
6552 : break;
6553 :
6554 : case REF_ARRAY:
6555 : case REF_INQUIRY:
6556 : case REF_SUBSTRING:
6557 : break;
6558 : }
6559 1346478 : }
6560 :
6561 :
6562 : /* Resolve a variable expression. */
6563 :
6564 : static bool
6565 1362091 : resolve_variable (gfc_expr *e)
6566 : {
6567 1362091 : gfc_symbol *sym;
6568 1362091 : bool t;
6569 :
6570 1362091 : t = true;
6571 :
6572 1362091 : if (e->symtree == NULL)
6573 : return false;
6574 1361616 : sym = e->symtree->n.sym;
6575 :
6576 : /* Use same check as for TYPE(*) below; this check has to be before TYPE(*)
6577 : as ts.type is set to BT_ASSUMED in resolve_symbol. */
6578 1361616 : if (sym->attr.ext_attr & (1 << EXT_ATTR_NO_ARG_CHECK))
6579 : {
6580 183 : if (!actual_arg || inquiry_argument)
6581 : {
6582 2 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute may only "
6583 : "be used as actual argument", sym->name, &e->where);
6584 2 : return false;
6585 : }
6586 : }
6587 : /* TS 29113, 407b. */
6588 1361433 : else if (e->ts.type == BT_ASSUMED)
6589 : {
6590 571 : if (!actual_arg)
6591 : {
6592 20 : gfc_error ("Assumed-type variable %s at %L may only be used "
6593 : "as actual argument", sym->name, &e->where);
6594 20 : return false;
6595 : }
6596 551 : else if (inquiry_argument && !first_actual_arg)
6597 : {
6598 : /* FIXME: It doesn't work reliably as inquiry_argument is not set
6599 : for all inquiry functions in resolve_function; the reason is
6600 : that the function-name resolution happens too late in that
6601 : function. */
6602 0 : gfc_error ("Assumed-type variable %s at %L as actual argument to "
6603 : "an inquiry function shall be the first argument",
6604 : sym->name, &e->where);
6605 0 : return false;
6606 : }
6607 : }
6608 : /* TS 29113, C535b. */
6609 1360862 : else if (((sym->ts.type == BT_CLASS && sym->attr.class_ok
6610 39451 : && sym->ts.u.derived && CLASS_DATA (sym)
6611 39446 : && CLASS_DATA (sym)->as
6612 15566 : && CLASS_DATA (sym)->as->type == AS_ASSUMED_RANK)
6613 1359892 : || (sym->ts.type != BT_CLASS && sym->as
6614 371851 : && sym->as->type == AS_ASSUMED_RANK))
6615 8064 : && !sym->attr.select_rank_temporary
6616 8064 : && !(sym->assoc && sym->assoc->ar))
6617 : {
6618 8064 : if (!actual_arg
6619 1277 : && !(cs_base && cs_base->current
6620 1276 : && (cs_base->current->op == EXEC_SELECT_RANK
6621 188 : || sym->attr.target)))
6622 : {
6623 144 : gfc_error ("Assumed-rank variable %s at %L may only be used as "
6624 : "actual argument", sym->name, &e->where);
6625 144 : return false;
6626 : }
6627 7920 : else if (inquiry_argument && !first_actual_arg)
6628 : {
6629 : /* FIXME: It doesn't work reliably as inquiry_argument is not set
6630 : for all inquiry functions in resolve_function; the reason is
6631 : that the function-name resolution happens too late in that
6632 : function. */
6633 0 : gfc_error ("Assumed-rank variable %s at %L as actual argument "
6634 : "to an inquiry function shall be the first argument",
6635 : sym->name, &e->where);
6636 0 : return false;
6637 : }
6638 : }
6639 :
6640 1361450 : if ((sym->attr.ext_attr & (1 << EXT_ATTR_NO_ARG_CHECK)) && e->ref
6641 181 : && !(e->ref->type == REF_ARRAY && e->ref->u.ar.type == AR_FULL
6642 180 : && e->ref->next == NULL))
6643 : {
6644 1 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute shall not have "
6645 : "a subobject reference", sym->name, &e->ref->u.ar.where);
6646 1 : return false;
6647 : }
6648 : /* TS 29113, 407b. */
6649 1361449 : else if (e->ts.type == BT_ASSUMED && e->ref
6650 687 : && !(e->ref->type == REF_ARRAY && e->ref->u.ar.type == AR_FULL
6651 680 : && e->ref->next == NULL))
6652 : {
6653 7 : gfc_error ("Assumed-type variable %s at %L shall not have a subobject "
6654 : "reference", sym->name, &e->ref->u.ar.where);
6655 7 : return false;
6656 : }
6657 :
6658 : /* TS 29113, C535b. */
6659 1361442 : if (((sym->ts.type == BT_CLASS && sym->attr.class_ok
6660 39451 : && sym->ts.u.derived && CLASS_DATA (sym)
6661 39446 : && CLASS_DATA (sym)->as
6662 15566 : && CLASS_DATA (sym)->as->type == AS_ASSUMED_RANK)
6663 1360472 : || (sym->ts.type != BT_CLASS && sym->as
6664 372387 : && sym->as->type == AS_ASSUMED_RANK))
6665 8204 : && !(sym->assoc && sym->assoc->ar)
6666 8204 : && e->ref
6667 8204 : && !(e->ref->type == REF_ARRAY && e->ref->u.ar.type == AR_FULL
6668 8200 : && e->ref->next == NULL))
6669 : {
6670 4 : gfc_error ("Assumed-rank variable %s at %L shall not have a subobject "
6671 : "reference", sym->name, &e->ref->u.ar.where);
6672 4 : return false;
6673 : }
6674 :
6675 : /* Guessed type variables are associate_names whose selector had not been
6676 : parsed at the time that the construct was parsed. Now the namespace is
6677 : being resolved, the TKR of the selector will be available for fixup of
6678 : the associate_name. */
6679 1361438 : if (IS_INFERRED_TYPE (e) && e->ref)
6680 : {
6681 739 : gfc_fixup_inferred_type_refs (e);
6682 : /* KIND inquiry ref returns the kind of the target. */
6683 739 : if (e->expr_type == EXPR_CONSTANT)
6684 : return true;
6685 : }
6686 1360699 : else if (IS_INFERRED_TYPE (e)
6687 525 : && sym->ts.type != BT_UNKNOWN
6688 525 : && (sym->ts.type != e->ts.type || sym->ts.kind != e->ts.kind))
6689 : /* No subobject ref, but the expression's typespec was set at parse
6690 : time before the target's actual type/kind was known. Refresh from
6691 : the now-resolved associate-name symbol. */
6692 216 : e->ts = sym->ts;
6693 1360483 : else if (sym->attr.select_type_temporary
6694 9398 : && sym->ns->assoc_name_inferred)
6695 98 : gfc_fixup_inferred_type_refs (e);
6696 :
6697 : /* For variables that are used in an associate (target => object) where
6698 : the object's basetype is array valued while the target is scalar,
6699 : the ts' type of the component refs is still array valued, which
6700 : can't be translated that way. */
6701 1361426 : if (sym->assoc && e->rank == 0 && e->ref && sym->ts.type == BT_CLASS
6702 698 : && sym->assoc->target && sym->assoc->target->ts.type == BT_CLASS
6703 698 : && sym->assoc->target->ts.u.derived
6704 698 : && CLASS_DATA (sym->assoc->target)
6705 698 : && CLASS_DATA (sym->assoc->target)->as)
6706 : {
6707 : gfc_ref *ref = e->ref;
6708 711 : while (ref)
6709 : {
6710 550 : switch (ref->type)
6711 : {
6712 243 : case REF_COMPONENT:
6713 243 : ref->u.c.sym = sym->ts.u.derived;
6714 : /* Stop the loop. */
6715 243 : ref = NULL;
6716 243 : break;
6717 307 : default:
6718 307 : ref = ref->next;
6719 307 : break;
6720 : }
6721 : }
6722 : }
6723 :
6724 : /* If this is an associate-name, it may be parsed with an array reference
6725 : in error even though the target is scalar. Fail directly in this case.
6726 : TODO Understand why class scalar expressions must be excluded. */
6727 1361426 : if (sym->assoc && !(sym->ts.type == BT_CLASS && e->rank == 0))
6728 : {
6729 : /* Inferred-type references are already fixed up above. */
6730 13021 : if (sym->ts.type == BT_CLASS && !IS_INFERRED_TYPE (e))
6731 239 : gfc_fix_class_refs (e);
6732 13021 : if (!sym->attr.dimension && !sym->attr.codimension && e->ref
6733 2634 : && e->ref->type == REF_ARRAY)
6734 : {
6735 : /* Unambiguously scalar! */
6736 3 : if (sym->assoc->target
6737 3 : && (sym->assoc->target->expr_type == EXPR_CONSTANT
6738 1 : || sym->assoc->target->expr_type == EXPR_STRUCTURE))
6739 2 : gfc_error ("Scalar variable %qs has an array reference at %L",
6740 : sym->name, &e->where);
6741 : return false;
6742 : }
6743 13018 : else if ((sym->attr.dimension || sym->attr.codimension)
6744 7411 : && (!e->ref || e->ref->type != REF_ARRAY))
6745 : {
6746 : /* This can happen because the parser did not detect that the
6747 : associate name is an array and the expression had no array
6748 : part_ref. */
6749 237 : gfc_ref *ref = gfc_get_ref ();
6750 237 : ref->type = REF_ARRAY;
6751 237 : ref->u.ar.type = AR_FULL;
6752 237 : if (sym->as)
6753 : {
6754 236 : ref->u.ar.as = sym->as;
6755 236 : ref->u.ar.dimen = sym->as->rank;
6756 : }
6757 237 : ref->next = e->ref;
6758 237 : e->ref = ref;
6759 : }
6760 : }
6761 :
6762 1361423 : if (sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.generic)
6763 0 : sym->ts.u.derived = gfc_find_dt_in_generic (sym->ts.u.derived);
6764 :
6765 : /* On the other hand, the parser may not have known this is an array;
6766 : in this case, we have to add a FULL reference. */
6767 1361423 : if (sym->assoc && (sym->attr.dimension || sym->attr.codimension) && !e->ref)
6768 : {
6769 0 : e->ref = gfc_get_ref ();
6770 0 : e->ref->type = REF_ARRAY;
6771 0 : e->ref->u.ar.type = AR_FULL;
6772 0 : e->ref->u.ar.dimen = 0;
6773 : }
6774 :
6775 : /* Like above, but for class types, where the checking whether an array
6776 : ref is present is more complicated. Furthermore make sure not to add
6777 : the full array ref to _vptr or _len refs. */
6778 1361423 : if (sym->assoc && sym->ts.type == BT_CLASS && sym->ts.u.derived
6779 1172 : && CLASS_DATA (sym)
6780 1172 : && (CLASS_DATA (sym)->attr.dimension
6781 590 : || CLASS_DATA (sym)->attr.codimension)
6782 588 : && (e->ts.type != BT_DERIVED || !e->ts.u.derived->attr.vtype))
6783 : {
6784 563 : gfc_ref *ref, *newref;
6785 :
6786 563 : newref = gfc_get_ref ();
6787 563 : newref->type = REF_ARRAY;
6788 563 : newref->u.ar.type = AR_FULL;
6789 563 : newref->u.ar.dimen = 0;
6790 :
6791 : /* Because this is an associate var and the first ref either is a ref to
6792 : the _data component or not, no traversal of the ref chain is
6793 : needed. The array ref needs to be inserted after the _data ref,
6794 : or when that is not present, which may happened for polymorphic
6795 : types, then at the first position. */
6796 563 : ref = e->ref;
6797 563 : if (!ref)
6798 18 : e->ref = newref;
6799 545 : else if (ref->type == REF_COMPONENT
6800 238 : && strcmp ("_data", ref->u.c.component->name) == 0)
6801 : {
6802 232 : if (!ref->next || ref->next->type != REF_ARRAY)
6803 : {
6804 12 : newref->next = ref->next;
6805 12 : ref->next = newref;
6806 : }
6807 : else
6808 : /* Array ref present already. */
6809 220 : gfc_free_ref_list (newref);
6810 : }
6811 313 : else if (ref->type == REF_ARRAY)
6812 : /* Array ref present already. */
6813 307 : gfc_free_ref_list (newref);
6814 : else
6815 : {
6816 6 : newref->next = ref;
6817 6 : e->ref = newref;
6818 : }
6819 : }
6820 1360860 : else if (sym->assoc && sym->ts.type == BT_CHARACTER && sym->ts.deferred)
6821 : {
6822 810 : gfc_ref *ref;
6823 1282 : for (ref = e->ref; ref; ref = ref->next)
6824 562 : if (ref->type == REF_SUBSTRING || ref->type == REF_INQUIRY)
6825 : break;
6826 810 : if (ref == NULL)
6827 720 : e->ts = sym->ts;
6828 : }
6829 :
6830 1361423 : if (e->ref && !gfc_resolve_ref (e))
6831 : return false;
6832 :
6833 1361329 : if (sym->attr.flavor == FL_PROCEDURE
6834 33402 : && (!sym->attr.function
6835 19386 : || (sym->attr.function && sym->result
6836 18928 : && sym->result->attr.proc_pointer
6837 729 : && !sym->result->attr.function)))
6838 : {
6839 14016 : e->ts.type = BT_PROCEDURE;
6840 14016 : goto resolve_procedure;
6841 : }
6842 :
6843 1347313 : if (sym->ts.type != BT_UNKNOWN)
6844 1346478 : get_data_ref_type (e, &e->ts);
6845 835 : else if (sym->attr.flavor == FL_PROCEDURE
6846 12 : && sym->attr.function && sym->result
6847 12 : && sym->result->ts.type != BT_UNKNOWN
6848 10 : && sym->result->attr.proc_pointer)
6849 10 : e->ts = sym->result->ts;
6850 : else
6851 : {
6852 : /* Must be a simple variable reference. */
6853 825 : if (!gfc_set_default_type (sym, 1, sym->ns))
6854 : return false;
6855 690 : e->ts = sym->ts;
6856 : }
6857 :
6858 1347178 : if (check_assumed_size_reference (sym, e))
6859 : return false;
6860 :
6861 : /* Deal with forward references to entries during gfc_resolve_code, to
6862 : satisfy, at least partially, 12.5.2.5. */
6863 1347159 : if (gfc_current_ns->entries
6864 3301 : && current_entry_id == sym->entry_id
6865 1050 : && cs_base
6866 964 : && cs_base->current
6867 964 : && cs_base->current->op != EXEC_ENTRY)
6868 : {
6869 964 : int n;
6870 964 : bool saved_specification_expr;
6871 964 : gfc_symbol *saved_specification_expr_symbol;
6872 :
6873 : /* If the symbol is a dummy... */
6874 964 : if (sym->attr.dummy && sym->ns == gfc_current_ns)
6875 : {
6876 : /* If it has not been seen as a dummy, this is an error. */
6877 462 : if (!entry_dummy_seen_p (sym))
6878 : {
6879 5 : if (specification_expr
6880 4 : && specification_expr_symbol
6881 4 : && specification_expr_symbol->attr.dummy
6882 2 : && specification_expr_symbol->ns == gfc_current_ns
6883 7 : && !entry_dummy_seen_p (specification_expr_symbol))
6884 : ;
6885 3 : else if (specification_expr)
6886 2 : gfc_error ("Variable %qs, used in a specification expression"
6887 : ", is referenced at %L before the ENTRY statement "
6888 : "in which it is a parameter",
6889 : sym->name, &cs_base->current->loc);
6890 : else
6891 1 : gfc_error ("Variable %qs is used at %L before the ENTRY "
6892 : "statement in which it is a parameter",
6893 : sym->name, &cs_base->current->loc);
6894 : t = false;
6895 : }
6896 : }
6897 :
6898 : /* Now do the same check on the specification expressions. */
6899 964 : saved_specification_expr = specification_expr;
6900 964 : saved_specification_expr_symbol = specification_expr_symbol;
6901 964 : specification_expr = true;
6902 964 : specification_expr_symbol = sym;
6903 964 : if (sym->ts.type == BT_CHARACTER
6904 964 : && !gfc_resolve_expr (sym->ts.u.cl->length))
6905 : t = false;
6906 :
6907 964 : if (sym->as)
6908 : {
6909 279 : for (n = 0; n < sym->as->rank; n++)
6910 : {
6911 164 : if (!gfc_resolve_expr (sym->as->lower[n]))
6912 0 : t = false;
6913 164 : if (!gfc_resolve_expr (sym->as->upper[n]))
6914 1 : t = false;
6915 : }
6916 : }
6917 964 : specification_expr = saved_specification_expr;
6918 964 : specification_expr_symbol = saved_specification_expr_symbol;
6919 :
6920 964 : if (t)
6921 : /* Update the symbol's entry level. */
6922 957 : sym->entry_id = current_entry_id + 1;
6923 : }
6924 :
6925 : /* If a symbol has been host_associated mark it. This is used latter,
6926 : to identify if aliasing is possible via host association. */
6927 1347159 : if (sym->attr.flavor == FL_VARIABLE
6928 1309442 : && (!sym->ns->code || sym->ns->code->op != EXEC_BLOCK
6929 6615 : || !sym->ns->code->ext.block.assoc)
6930 1306977 : && gfc_current_ns->parent
6931 622611 : && (gfc_current_ns->parent == sym->ns
6932 582243 : || (gfc_current_ns->parent->parent
6933 12683 : && gfc_current_ns->parent->parent == sym->ns)))
6934 47190 : sym->attr.host_assoc = 1;
6935 :
6936 1347159 : if (gfc_current_ns->proc_name
6937 1342700 : && sym->attr.dimension
6938 365213 : && (sym->ns != gfc_current_ns
6939 340488 : || sym->attr.use_assoc
6940 336297 : || sym->attr.in_common))
6941 33705 : gfc_current_ns->proc_name->attr.array_outer_dependency = 1;
6942 :
6943 1361175 : resolve_procedure:
6944 1361175 : if (t && !resolve_procedure_expression (e))
6945 : t = false;
6946 :
6947 : /* F2008, C617 and C1229. */
6948 1360018 : if (!inquiry_argument && (e->ts.type == BT_CLASS || e->ts.type == BT_DERIVED)
6949 1465143 : && gfc_is_coindexed (e))
6950 : {
6951 380 : gfc_ref *ref, *ref2 = NULL;
6952 :
6953 463 : for (ref = e->ref; ref; ref = ref->next)
6954 : {
6955 463 : if (ref->type == REF_COMPONENT)
6956 83 : ref2 = ref;
6957 463 : if (ref->type == REF_ARRAY && ref->u.ar.codimen > 0)
6958 : break;
6959 : }
6960 :
6961 760 : for ( ; ref; ref = ref->next)
6962 392 : if (ref->type == REF_COMPONENT)
6963 : break;
6964 :
6965 : /* Expression itself is not coindexed object. */
6966 380 : if (ref && e->ts.type == BT_CLASS)
6967 : {
6968 3 : gfc_error ("Polymorphic subobject of coindexed object at %L",
6969 : &e->where);
6970 3 : t = false;
6971 : }
6972 :
6973 : /* Expression itself is coindexed object. */
6974 : if (ref == NULL)
6975 : {
6976 368 : gfc_component *c;
6977 368 : c = ref2 ? ref2->u.c.component : e->symtree->n.sym->components;
6978 488 : for ( ; c; c = c->next)
6979 120 : if (c->attr.allocatable && c->ts.type == BT_CLASS)
6980 : {
6981 0 : gfc_error ("Coindexed object with polymorphic allocatable "
6982 : "subcomponent at %L", &e->where);
6983 0 : t = false;
6984 0 : break;
6985 : }
6986 : }
6987 : }
6988 :
6989 1361175 : if (t)
6990 1361165 : gfc_expression_rank (e);
6991 :
6992 1361175 : if (sym->attr.ext_attr & (1 << EXT_ATTR_DEPRECATED) && sym != sym->result)
6993 3 : gfc_warning (OPT_Wdeprecated_declarations,
6994 : "Using variable %qs at %L is deprecated",
6995 : sym->name, &e->where);
6996 : /* Simplify cases where access to a parameter array results in a
6997 : single constant. Suppress errors since those will have been
6998 : issued before, as warnings. */
6999 1361175 : if (e->rank == 0 && sym->as && sym->attr.flavor == FL_PARAMETER)
7000 : {
7001 2668 : gfc_push_suppress_errors ();
7002 2668 : gfc_simplify_expr (e, 1);
7003 2668 : gfc_pop_suppress_errors ();
7004 : }
7005 :
7006 : return t;
7007 : }
7008 :
7009 :
7010 : /* The reference at *LINK follows a reference to component C in the
7011 : inferred type expression E. Make it agree with the array spec of C. */
7012 :
7013 : static void
7014 968 : fixup_inferred_component_array_ref (gfc_expr *e, gfc_component *c,
7015 : gfc_ref **link)
7016 : {
7017 968 : gfc_ref *ref = *link;
7018 968 : gfc_array_spec *as;
7019 :
7020 968 : if (c->ts.type == BT_CLASS)
7021 351 : as = CLASS_DATA (c) ? CLASS_DATA (c)->as : NULL;
7022 : else
7023 617 : as = c->as;
7024 :
7025 968 : if (ref && ref->type == REF_ARRAY)
7026 : {
7027 373 : if (as)
7028 360 : ref->u.ar.as = as;
7029 13 : else if (ref->u.ar.type == AR_FULL)
7030 : {
7031 : /* Drop the full array ref of a component guessed to be an array. */
7032 6 : *link = ref->next;
7033 6 : free (ref);
7034 : }
7035 7 : else if (c->ts.type == BT_CHARACTER && ref->u.ar.dimen == 1
7036 6 : && ref->u.ar.dimen_type[0] == DIMEN_RANGE
7037 6 : && !ref->u.ar.stride[0])
7038 : {
7039 : /* A substring misidentified as an array section. */
7040 6 : gfc_expr *start = ref->u.ar.start[0];
7041 6 : gfc_expr *end = ref->u.ar.end[0];
7042 6 : ref->type = REF_SUBSTRING;
7043 6 : ref->u.ss.start = start;
7044 6 : ref->u.ss.end = end;
7045 6 : ref->u.ss.length = c->ts.u.cl;
7046 6 : }
7047 : else
7048 : /* Leave the array ref of a scalar to find_array_spec to diagnose. */
7049 1 : ref->u.ar.as = NULL;
7050 : }
7051 595 : else if (as && as->rank == 1 && ref && ref->type == REF_SUBSTRING)
7052 : {
7053 : /* An array section misidentified as a substring. */
7054 6 : gfc_expr *start = ref->u.ss.start;
7055 6 : gfc_expr *end = ref->u.ss.end;
7056 6 : memset (&ref->u, 0, sizeof (ref->u));
7057 6 : ref->type = REF_ARRAY;
7058 6 : ref->u.ar.type = AR_SECTION;
7059 6 : ref->u.ar.dimen = 1;
7060 6 : ref->u.ar.dimen_type[0] = DIMEN_RANGE;
7061 6 : ref->u.ar.start[0] = start;
7062 6 : ref->u.ar.end[0] = end;
7063 6 : ref->u.ar.as = as;
7064 6 : ref->u.ar.where = e->where;
7065 6 : }
7066 : else if (as)
7067 : {
7068 : /* Supply the full array ref of a component guessed to be scalar. */
7069 24 : ref = gfc_get_ref ();
7070 24 : ref->type = REF_ARRAY;
7071 24 : ref->u.ar.type = AR_FULL;
7072 24 : ref->u.ar.as = as;
7073 24 : ref->u.ar.where = e->where;
7074 24 : ref->next = *link;
7075 24 : *link = ref;
7076 : }
7077 968 : }
7078 :
7079 :
7080 : /* 'sym' was initially guessed to be derived type but has been corrected
7081 : in resolve_assoc_var to be a class entity or the derived type correcting.
7082 : If a class entity it will certainly need the _data reference or the
7083 : reference derived type symbol correcting in the first component ref if
7084 : a derived type. */
7085 :
7086 : void
7087 879 : gfc_fixup_inferred_type_refs (gfc_expr *e)
7088 : {
7089 879 : gfc_ref *ref, *new_ref;
7090 879 : gfc_symbol *sym, *derived, *dt, *container;
7091 879 : gfc_expr *target;
7092 879 : sym = e->symtree->n.sym;
7093 :
7094 : /* An associate_name whose selector is (i) a component ref of a selector
7095 : that is a inferred type associate_name; or (ii) an intrinsic type that
7096 : has been inferred from an inquiry ref. */
7097 879 : if (sym->ts.type != BT_DERIVED && sym->ts.type != BT_CLASS)
7098 : {
7099 198 : sym->attr.dimension = sym->assoc->target->rank ? 1 : 0;
7100 198 : sym->attr.codimension = sym->assoc->target->corank ? 1 : 0;
7101 198 : if (!sym->attr.dimension && e->ref->type == REF_ARRAY)
7102 : {
7103 60 : ref = e->ref;
7104 : /* A substring misidentified as an array section. */
7105 60 : if (sym->ts.type == BT_CHARACTER
7106 30 : && ref->u.ar.start[0] && ref->u.ar.end[0]
7107 6 : && !ref->u.ar.stride[0])
7108 : {
7109 6 : new_ref = gfc_get_ref ();
7110 6 : new_ref->type = REF_SUBSTRING;
7111 6 : new_ref->u.ss.start = ref->u.ar.start[0];
7112 6 : new_ref->u.ss.end = ref->u.ar.end[0];
7113 6 : new_ref->u.ss.length = sym->ts.u.cl;
7114 6 : *ref = *new_ref;
7115 6 : free (new_ref);
7116 : }
7117 : else
7118 : {
7119 54 : if (e->ref->u.ar.type == AR_UNKNOWN)
7120 24 : gfc_error ("Invalid array reference at %L", &e->where);
7121 54 : e->ref = ref->next;
7122 54 : free (ref);
7123 : }
7124 : }
7125 :
7126 : /* It is possible for an inquiry reference to be mistaken for a
7127 : component reference. Correct this now. */
7128 198 : ref = e->ref;
7129 198 : if (ref && ref->type == REF_ARRAY)
7130 66 : ref = ref->next;
7131 102 : if (ref && ref->type == REF_COMPONENT
7132 78 : && is_inquiry_ref (ref->u.c.component->name, &new_ref))
7133 : {
7134 12 : e->symtree->n.sym = sym;
7135 12 : *ref = *new_ref;
7136 12 : gfc_free_ref_list (new_ref);
7137 : }
7138 :
7139 : /* The kind of the associate name is best evaluated directly from the
7140 : selector because of the guesses made in primary.cc, when the type
7141 : is still unknown. */
7142 198 : if (ref && ref->type == REF_INQUIRY && ref->u.i == INQUIRY_KIND)
7143 : {
7144 24 : gfc_expr *ne = gfc_get_int_expr (gfc_default_integer_kind, &e->where,
7145 12 : sym->assoc->target->ts.kind);
7146 12 : gfc_replace_expr (e, ne);
7147 12 : }
7148 90 : else if (ref && ref->type == REF_INQUIRY
7149 78 : && (ref->u.i == INQUIRY_RE || ref->u.i == INQUIRY_IM)
7150 60 : && sym->ts.type == BT_COMPLEX
7151 60 : && e->ts.type == BT_REAL
7152 60 : && e->ts.kind != sym->ts.kind)
7153 : /* primary.cc set the inquiry-result kind to the default real kind
7154 : when the associate-name's type was inferred from %re/%im before
7155 : the target was resolved. Now use the (resolved) selector kind. */
7156 24 : e->ts.kind = sym->ts.kind;
7157 :
7158 : /* Now that the references are all sorted out, set the expression rank
7159 : and return. */
7160 198 : gfc_expression_rank (e);
7161 397 : return;
7162 : }
7163 :
7164 681 : derived = sym->ts.type == BT_CLASS ? CLASS_DATA (sym)->ts.u.derived
7165 : : sym->ts.u.derived;
7166 :
7167 : /* Ensure that class symbols have an array spec and ensure that there
7168 : is a _data field reference following class type references. */
7169 681 : if (sym->ts.type == BT_CLASS
7170 193 : && sym->assoc->target->ts.type == BT_CLASS)
7171 : {
7172 193 : e->rank = CLASS_DATA (sym)->as ? CLASS_DATA (sym)->as->rank : 0;
7173 193 : e->corank = CLASS_DATA (sym)->as ? CLASS_DATA (sym)->as->corank : 0;
7174 193 : sym->attr.dimension = 0;
7175 193 : sym->attr.codimension = 0;
7176 193 : CLASS_DATA (sym)->attr.dimension = e->rank ? 1 : 0;
7177 193 : CLASS_DATA (sym)->attr.codimension = e->corank ? 1 : 0;
7178 193 : if (e->ref && (e->ref->type != REF_COMPONENT
7179 157 : || e->ref->u.c.component->name[0] != '_'))
7180 : {
7181 127 : ref = gfc_get_ref ();
7182 127 : ref->type = REF_COMPONENT;
7183 127 : ref->next = e->ref;
7184 127 : e->ref = ref;
7185 127 : ref->u.c.component = gfc_find_component (sym->ts.u.derived, "_data",
7186 : true, true, NULL);
7187 127 : ref->u.c.sym = sym->ts.u.derived;
7188 : }
7189 : }
7190 :
7191 : /* The type used to build the component references at parse time was only
7192 : a guess, so they can point into a different derived type that happens
7193 : to have a component of the same name. Bind each one by name to the
7194 : corrected type and fix up the array ref that follows it. */
7195 681 : dt = derived;
7196 681 : container = sym->ts.type == BT_CLASS ? sym->ts.u.derived : NULL;
7197 681 : gfc_component *comp = NULL;
7198 681 : gfc_ref **link;
7199 681 : for (link = &e->ref; ; link = &(*link)->next)
7200 : {
7201 2512 : gfc_component *c;
7202 :
7203 2512 : ref = *link;
7204 2512 : if (comp && !(ref && ref->type == REF_COMPONENT
7205 117 : && ref->u.c.component->name[0] == '_'))
7206 : {
7207 968 : fixup_inferred_component_array_ref (e, comp, link);
7208 968 : comp = NULL;
7209 968 : ref = *link;
7210 : }
7211 :
7212 2512 : if (!ref)
7213 : break;
7214 :
7215 1832 : if (ref->type != REF_COMPONENT)
7216 670 : continue;
7217 :
7218 : /* '_data', '_vptr' and '_len' are fields of the preceding class
7219 : container; 'dt' already is the declared type that follows '_data'. */
7220 1162 : if (ref->u.c.component->name[0] == '_')
7221 : {
7222 193 : if (!container)
7223 : break;
7224 193 : c = gfc_find_component (container, ref->u.c.component->name,
7225 : true, true, NULL);
7226 193 : if (!c)
7227 : break;
7228 193 : ref->u.c.sym = container;
7229 193 : ref->u.c.component = c;
7230 193 : container = NULL;
7231 193 : if (strcmp (c->name, "_data") != 0)
7232 : break;
7233 193 : continue;
7234 : }
7235 :
7236 969 : if (!dt)
7237 : break;
7238 :
7239 969 : c = gfc_find_component (dt, ref->u.c.component->name, false, true, NULL);
7240 969 : if (!c)
7241 : {
7242 1 : if (gfc_find_component (dt, ref->u.c.component->name,
7243 : true, true, NULL))
7244 1 : gfc_error ("Component %qs at %L is a PRIVATE component of %qs",
7245 1 : ref->u.c.component->name, &e->where, dt->name);
7246 : else
7247 0 : gfc_error ("%qs at %L is not a member of the %qs structure",
7248 0 : ref->u.c.component->name, &e->where, dt->name);
7249 : return;
7250 : }
7251 :
7252 968 : ref->u.c.sym = dt;
7253 968 : ref->u.c.component = c;
7254 968 : comp = c;
7255 :
7256 968 : container = NULL;
7257 968 : if (c->ts.type == BT_DERIVED)
7258 168 : dt = c->ts.u.derived;
7259 800 : else if (c->ts.type == BT_CLASS && CLASS_DATA (c))
7260 : {
7261 351 : container = c->ts.u.derived;
7262 351 : dt = CLASS_DATA (c)->ts.u.derived;
7263 : }
7264 : else
7265 : dt = NULL;
7266 1831 : }
7267 :
7268 : /* Verify that the type inference mechanism has not introduced a spurious
7269 : array reference. This can happen with an associate name, whose selector
7270 : is an element of another inferred type. */
7271 680 : target = e->symtree->n.sym->assoc->target;
7272 680 : if (!(sym->ts.type == BT_CLASS ? CLASS_DATA (sym)->as : sym->as)
7273 402 : && e != target && !target->rank)
7274 : {
7275 : /* First case: array ref after the scalar class or derived
7276 : associate_name. */
7277 402 : if (e->ref && e->ref->type == REF_ARRAY
7278 7 : && e->ref->u.ar.type != AR_ELEMENT)
7279 : {
7280 7 : ref = e->ref;
7281 7 : if (ref->u.ar.type == AR_UNKNOWN)
7282 1 : gfc_error ("Invalid array reference at %L", &e->where);
7283 7 : e->ref = ref->next;
7284 7 : free (ref);
7285 :
7286 : /* If it hasn't a ref to the '_data' field supply one. */
7287 7 : if (sym->ts.type == BT_CLASS
7288 0 : && !(e->ref->type == REF_COMPONENT
7289 0 : && strcmp (e->ref->u.c.component->name, "_data")))
7290 : {
7291 0 : gfc_ref *new_ref;
7292 0 : gfc_find_component (e->symtree->n.sym->ts.u.derived,
7293 : "_data", true, true, &new_ref);
7294 0 : new_ref->next = e->ref;
7295 0 : e->ref = new_ref;
7296 : }
7297 : }
7298 : /* 2nd case: a ref to the '_data' field followed by an array ref. */
7299 395 : else if (e->ref && e->ref->type == REF_COMPONENT
7300 395 : && strcmp (e->ref->u.c.component->name, "_data") == 0
7301 133 : && e->ref->next && e->ref->next->type == REF_ARRAY
7302 0 : && e->ref->next->u.ar.type != AR_ELEMENT)
7303 : {
7304 0 : ref = e->ref->next;
7305 0 : if (ref->u.ar.type == AR_UNKNOWN)
7306 0 : gfc_error ("Invalid array reference at %L", &e->where);
7307 0 : e->ref->next = e->ref->next->next;
7308 0 : free (ref);
7309 : }
7310 : }
7311 :
7312 : /* Now that all the references are OK, get the expression rank. */
7313 680 : gfc_expression_rank (e);
7314 : }
7315 :
7316 :
7317 : /* Checks to see that the correct symbol has been host associated.
7318 : The only situations where this arises are:
7319 : (i) That in which a twice contained function is parsed after
7320 : the host association is made. On detecting this, change
7321 : the symbol in the expression and convert the array reference
7322 : into an actual arglist if the old symbol is a variable; or
7323 : (ii) That in which an external function is typed but not declared
7324 : explicitly to be external. Here, the old symbol is changed
7325 : from a variable to an external function. */
7326 : static bool
7327 1717226 : check_host_association (gfc_expr *e)
7328 : {
7329 1717226 : gfc_symbol *sym, *old_sym;
7330 1717226 : gfc_symtree *st;
7331 1717226 : int n;
7332 1717226 : gfc_ref *ref;
7333 1717226 : gfc_actual_arglist *arg, *tail = NULL;
7334 1717226 : bool retval = e->expr_type == EXPR_FUNCTION;
7335 :
7336 : /* If the expression is the result of substitution in
7337 : interface.cc(gfc_extend_expr) because there is no way in
7338 : which the host association can be wrong. */
7339 1717226 : if (e->symtree == NULL
7340 1716377 : || e->symtree->n.sym == NULL
7341 1716377 : || e->user_operator)
7342 : return retval;
7343 :
7344 1714597 : old_sym = e->symtree->n.sym;
7345 :
7346 1714597 : if (gfc_current_ns->parent
7347 752925 : && old_sym->ns != gfc_current_ns)
7348 : {
7349 : /* Use the 'USE' name so that renamed module symbols are
7350 : correctly handled. */
7351 95884 : gfc_find_symbol (e->symtree->name, gfc_current_ns, 1, &sym);
7352 :
7353 95884 : if (sym && old_sym != sym
7354 716 : && sym->attr.flavor == FL_PROCEDURE
7355 111 : && sym->attr.contained)
7356 : {
7357 : /* Clear the shape, since it might not be valid. */
7358 83 : gfc_free_shape (&e->shape, e->rank);
7359 :
7360 : /* Give the expression the right symtree! */
7361 83 : gfc_find_sym_tree (e->symtree->name, NULL, 1, &st);
7362 83 : gcc_assert (st != NULL);
7363 :
7364 83 : if (old_sym->attr.flavor == FL_PROCEDURE
7365 59 : || e->expr_type == EXPR_FUNCTION)
7366 : {
7367 : /* Original was function so point to the new symbol, since
7368 : the actual argument list is already attached to the
7369 : expression. */
7370 30 : e->value.function.esym = NULL;
7371 30 : e->symtree = st;
7372 : }
7373 : else
7374 : {
7375 : /* Original was variable so convert array references into
7376 : an actual arglist. This does not need any checking now
7377 : since resolve_function will take care of it. */
7378 53 : e->value.function.actual = NULL;
7379 53 : e->expr_type = EXPR_FUNCTION;
7380 53 : e->symtree = st;
7381 :
7382 : /* Ambiguity will not arise if the array reference is not
7383 : the last reference. */
7384 55 : for (ref = e->ref; ref; ref = ref->next)
7385 38 : if (ref->type == REF_ARRAY && ref->next == NULL)
7386 : break;
7387 :
7388 53 : if ((ref == NULL || ref->type != REF_ARRAY)
7389 17 : && sym->attr.proc == PROC_INTERNAL)
7390 : {
7391 4 : gfc_error ("%qs at %L is host associated at %L into "
7392 : "a contained procedure with an internal "
7393 : "procedure of the same name", sym->name,
7394 : &old_sym->declared_at, &e->where);
7395 4 : return false;
7396 : }
7397 :
7398 13 : if (ref == NULL)
7399 : return false;
7400 :
7401 36 : gcc_assert (ref->type == REF_ARRAY);
7402 :
7403 : /* Grab the start expressions from the array ref and
7404 : copy them into actual arguments. */
7405 84 : for (n = 0; n < ref->u.ar.dimen; n++)
7406 : {
7407 48 : arg = gfc_get_actual_arglist ();
7408 48 : arg->expr = gfc_copy_expr (ref->u.ar.start[n]);
7409 48 : if (e->value.function.actual == NULL)
7410 36 : tail = e->value.function.actual = arg;
7411 : else
7412 : {
7413 12 : tail->next = arg;
7414 12 : tail = arg;
7415 : }
7416 : }
7417 :
7418 : /* Dump the reference list and set the rank. */
7419 36 : gfc_free_ref_list (e->ref);
7420 36 : e->ref = NULL;
7421 36 : e->rank = sym->as ? sym->as->rank : 0;
7422 36 : e->corank = sym->as ? sym->as->corank : 0;
7423 : }
7424 :
7425 66 : gfc_resolve_expr (e);
7426 66 : sym->refs++;
7427 : }
7428 : /* This case corresponds to a call, from a block or a contained
7429 : procedure, to an external function, which has not been declared
7430 : as being external in the main program but has been typed. */
7431 95801 : else if (sym && old_sym != sym
7432 633 : && !e->ref
7433 361 : && sym->ts.type == BT_UNKNOWN
7434 27 : && old_sym->ts.type != BT_UNKNOWN
7435 19 : && sym->attr.flavor == FL_PROCEDURE
7436 19 : && old_sym->attr.flavor == FL_VARIABLE
7437 7 : && sym->ns->parent == old_sym->ns
7438 7 : && sym->ns->proc_name
7439 7 : && sym->ns->proc_name->attr.proc != PROC_MODULE
7440 6 : && (sym->ns->proc_name->attr.flavor == FL_LABEL
7441 6 : || sym->ns->proc_name->attr.flavor == FL_PROCEDURE))
7442 : {
7443 6 : old_sym->attr.flavor = FL_PROCEDURE;
7444 6 : old_sym->attr.external = 1;
7445 6 : old_sym->attr.function = 1;
7446 6 : old_sym->result = old_sym;
7447 6 : gfc_resolve_expr (e);
7448 : }
7449 : }
7450 : /* This might have changed! */
7451 1714580 : return e->expr_type == EXPR_FUNCTION;
7452 : }
7453 :
7454 :
7455 : static void
7456 1508 : gfc_resolve_character_operator (gfc_expr *e)
7457 : {
7458 1508 : gfc_expr *op1 = e->value.op.op1;
7459 1508 : gfc_expr *op2 = e->value.op.op2;
7460 1508 : gfc_expr *e1 = NULL;
7461 1508 : gfc_expr *e2 = NULL;
7462 :
7463 1508 : gcc_assert (e->value.op.op == INTRINSIC_CONCAT);
7464 :
7465 1508 : if (op1->ts.u.cl && op1->ts.u.cl->length)
7466 844 : e1 = gfc_copy_expr (op1->ts.u.cl->length);
7467 664 : else if (op1->expr_type == EXPR_CONSTANT)
7468 268 : e1 = gfc_get_int_expr (gfc_charlen_int_kind, NULL,
7469 268 : op1->value.character.length);
7470 :
7471 1508 : if (op2->ts.u.cl && op2->ts.u.cl->length)
7472 801 : e2 = gfc_copy_expr (op2->ts.u.cl->length);
7473 707 : else if (op2->expr_type == EXPR_CONSTANT)
7474 474 : e2 = gfc_get_int_expr (gfc_charlen_int_kind, NULL,
7475 474 : op2->value.character.length);
7476 :
7477 1508 : e->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
7478 :
7479 1508 : if (!e1 || !e2)
7480 : {
7481 521 : gfc_free_expr (e1);
7482 521 : gfc_free_expr (e2);
7483 :
7484 521 : return;
7485 : }
7486 :
7487 987 : e->ts.u.cl->length = gfc_add (e1, e2);
7488 987 : e->ts.u.cl->length->ts.type = BT_INTEGER;
7489 987 : e->ts.u.cl->length->ts.kind = gfc_charlen_int_kind;
7490 987 : gfc_simplify_expr (e->ts.u.cl->length, 0);
7491 987 : gfc_resolve_expr (e->ts.u.cl->length);
7492 :
7493 987 : return;
7494 : }
7495 :
7496 :
7497 : /* Ensure that an character expression has a charlen and, if possible, a
7498 : length expression. */
7499 :
7500 : static void
7501 182557 : fixup_charlen (gfc_expr *e)
7502 : {
7503 : /* The cases fall through so that changes in expression type and the need
7504 : for multiple fixes are picked up. In all circumstances, a charlen should
7505 : be available for the middle end to hang a backend_decl on. */
7506 182557 : switch (e->expr_type)
7507 : {
7508 1508 : case EXPR_OP:
7509 1508 : gfc_resolve_character_operator (e);
7510 : /* FALLTHRU */
7511 :
7512 1575 : case EXPR_ARRAY:
7513 1575 : if (e->expr_type == EXPR_ARRAY)
7514 67 : gfc_resolve_character_array_constructor (e);
7515 : /* FALLTHRU */
7516 :
7517 2035 : case EXPR_SUBSTRING:
7518 2035 : if (!e->ts.u.cl && e->ref)
7519 456 : gfc_resolve_substring_charlen (e);
7520 : /* FALLTHRU */
7521 :
7522 182557 : default:
7523 182557 : if (!e->ts.u.cl)
7524 180526 : e->ts.u.cl = gfc_new_charlen (gfc_current_ns, NULL);
7525 :
7526 182557 : break;
7527 : }
7528 182557 : }
7529 :
7530 :
7531 : /* Update an actual argument to include the passed-object for type-bound
7532 : procedures at the right position. */
7533 :
7534 : static gfc_actual_arglist*
7535 3086 : update_arglist_pass (gfc_actual_arglist* lst, gfc_expr* po, unsigned argpos,
7536 : const char *name)
7537 : {
7538 3110 : gcc_assert (argpos > 0);
7539 :
7540 3110 : if (argpos == 1)
7541 : {
7542 2961 : gfc_actual_arglist* result;
7543 :
7544 2961 : result = gfc_get_actual_arglist ();
7545 2961 : result->expr = po;
7546 2961 : result->next = lst;
7547 2961 : if (name)
7548 514 : result->name = name;
7549 :
7550 : return result;
7551 : }
7552 :
7553 149 : if (lst)
7554 125 : lst->next = update_arglist_pass (lst->next, po, argpos - 1, name);
7555 : else
7556 24 : lst = update_arglist_pass (NULL, po, argpos - 1, name);
7557 : return lst;
7558 : }
7559 :
7560 :
7561 : /* Extract the passed-object from an EXPR_COMPCALL (a copy of it). */
7562 :
7563 : static gfc_expr*
7564 7527 : extract_compcall_passed_object (gfc_expr* e)
7565 : {
7566 7527 : gfc_expr* po;
7567 :
7568 7527 : if (e->expr_type == EXPR_UNKNOWN)
7569 : {
7570 0 : gfc_error ("Error in typebound call at %L",
7571 : &e->where);
7572 0 : return NULL;
7573 : }
7574 :
7575 7527 : gcc_assert (e->expr_type == EXPR_COMPCALL);
7576 :
7577 7527 : if (e->value.compcall.base_object)
7578 1668 : po = gfc_copy_expr (e->value.compcall.base_object);
7579 : else
7580 : {
7581 5859 : po = gfc_get_expr ();
7582 5859 : po->expr_type = EXPR_VARIABLE;
7583 5859 : po->symtree = e->symtree;
7584 5859 : po->ref = gfc_copy_ref (e->ref);
7585 5859 : po->where = e->where;
7586 : }
7587 :
7588 7527 : if (!gfc_resolve_expr (po))
7589 3 : return NULL;
7590 :
7591 : return po;
7592 : }
7593 :
7594 :
7595 : /* Update the arglist of an EXPR_COMPCALL expression to include the
7596 : passed-object. */
7597 :
7598 : static bool
7599 3468 : update_compcall_arglist (gfc_expr* e)
7600 : {
7601 3468 : gfc_expr* po;
7602 3468 : gfc_typebound_proc* tbp;
7603 :
7604 3468 : tbp = e->value.compcall.tbp;
7605 :
7606 3468 : if (tbp->error)
7607 : return false;
7608 :
7609 3467 : po = extract_compcall_passed_object (e);
7610 3467 : if (!po)
7611 : return false;
7612 :
7613 3467 : if (tbp->nopass || e->value.compcall.ignore_pass)
7614 : {
7615 1170 : gfc_free_expr (po);
7616 1170 : return true;
7617 : }
7618 :
7619 2297 : if (tbp->pass_arg_num <= 0)
7620 : return false;
7621 :
7622 2296 : e->value.compcall.actual = update_arglist_pass (e->value.compcall.actual, po,
7623 : tbp->pass_arg_num,
7624 : tbp->pass_arg);
7625 :
7626 2296 : return true;
7627 : }
7628 :
7629 :
7630 : /* Extract the passed object from a PPC call (a copy of it). */
7631 :
7632 : static gfc_expr*
7633 85 : extract_ppc_passed_object (gfc_expr *e)
7634 : {
7635 85 : gfc_expr *po;
7636 85 : gfc_ref **ref;
7637 :
7638 85 : po = gfc_get_expr ();
7639 85 : po->expr_type = EXPR_VARIABLE;
7640 85 : po->symtree = e->symtree;
7641 85 : po->ref = gfc_copy_ref (e->ref);
7642 85 : po->where = e->where;
7643 :
7644 : /* Remove PPC reference. */
7645 85 : ref = &po->ref;
7646 91 : while ((*ref)->next)
7647 6 : ref = &(*ref)->next;
7648 85 : gfc_free_ref_list (*ref);
7649 85 : *ref = NULL;
7650 :
7651 85 : if (!gfc_resolve_expr (po))
7652 0 : return NULL;
7653 :
7654 : return po;
7655 : }
7656 :
7657 :
7658 : /* Update the actual arglist of a procedure pointer component to include the
7659 : passed-object. */
7660 :
7661 : static bool
7662 607 : update_ppc_arglist (gfc_expr* e)
7663 : {
7664 607 : gfc_expr* po;
7665 607 : gfc_component *ppc;
7666 607 : gfc_typebound_proc* tb;
7667 :
7668 607 : ppc = gfc_get_proc_ptr_comp (e);
7669 607 : if (!ppc)
7670 : return false;
7671 :
7672 607 : tb = ppc->tb;
7673 :
7674 607 : if (tb->error)
7675 : return false;
7676 605 : else if (tb->nopass)
7677 : return true;
7678 :
7679 85 : po = extract_ppc_passed_object (e);
7680 85 : if (!po)
7681 : return false;
7682 :
7683 : /* F08:R739. */
7684 85 : if (po->rank != 0)
7685 : {
7686 0 : gfc_error ("Passed-object at %L must be scalar", &e->where);
7687 0 : return false;
7688 : }
7689 :
7690 : /* F08:C611. */
7691 85 : if (po->ts.type == BT_DERIVED && po->ts.u.derived->attr.abstract)
7692 : {
7693 1 : gfc_error ("Base object for procedure-pointer component call at %L is of"
7694 : " ABSTRACT type %qs", &e->where, po->ts.u.derived->name);
7695 1 : return false;
7696 : }
7697 :
7698 84 : gcc_assert (tb->pass_arg_num > 0);
7699 84 : e->value.compcall.actual = update_arglist_pass (e->value.compcall.actual, po,
7700 : tb->pass_arg_num,
7701 : tb->pass_arg);
7702 :
7703 84 : return true;
7704 : }
7705 :
7706 :
7707 : /* Check that the object a TBP is called on is valid, i.e. it must not be
7708 : of ABSTRACT type (as in subobject%abstract_parent%tbp()). */
7709 :
7710 : static bool
7711 3479 : check_typebound_baseobject (gfc_expr* e)
7712 : {
7713 3479 : gfc_expr* base;
7714 3479 : bool return_value = false;
7715 :
7716 3479 : base = extract_compcall_passed_object (e);
7717 3479 : if (!base)
7718 : return false;
7719 :
7720 3476 : if (base->ts.type != BT_DERIVED && base->ts.type != BT_CLASS)
7721 : {
7722 1 : gfc_error ("Error in typebound call at %L", &e->where);
7723 1 : goto cleanup;
7724 : }
7725 :
7726 3475 : if (base->ts.type == BT_CLASS && !gfc_expr_attr (base).class_ok)
7727 1 : return false;
7728 :
7729 : /* F08:C611. */
7730 3474 : if (base->ts.type == BT_DERIVED && base->ts.u.derived->attr.abstract)
7731 : {
7732 3 : gfc_error ("Base object for type-bound procedure call at %L is of"
7733 : " ABSTRACT type %qs", &e->where, base->ts.u.derived->name);
7734 3 : goto cleanup;
7735 : }
7736 :
7737 : /* F08:C1230. If the procedure called is NOPASS,
7738 : the base object must be scalar. */
7739 3471 : if (e->value.compcall.tbp->nopass && base->rank != 0)
7740 : {
7741 1 : gfc_error ("Base object for NOPASS type-bound procedure call at %L must"
7742 : " be scalar", &e->where);
7743 1 : goto cleanup;
7744 : }
7745 :
7746 : return_value = true;
7747 :
7748 3475 : cleanup:
7749 3475 : gfc_free_expr (base);
7750 3475 : return return_value;
7751 : }
7752 :
7753 :
7754 : /* Resolve a call to a type-bound procedure, either function or subroutine,
7755 : statically from the data in an EXPR_COMPCALL expression. The adapted
7756 : arglist and the target-procedure symtree are returned. */
7757 :
7758 : static bool
7759 3468 : resolve_typebound_static (gfc_expr* e, gfc_symtree** target,
7760 : gfc_actual_arglist** actual)
7761 : {
7762 3468 : gcc_assert (e->expr_type == EXPR_COMPCALL);
7763 3468 : gcc_assert (!e->value.compcall.tbp->is_generic);
7764 :
7765 : /* Update the actual arglist for PASS. */
7766 3468 : if (!update_compcall_arglist (e))
7767 : return false;
7768 :
7769 3466 : *actual = e->value.compcall.actual;
7770 3466 : *target = e->value.compcall.tbp->u.specific;
7771 :
7772 3466 : gfc_free_ref_list (e->ref);
7773 3466 : e->ref = NULL;
7774 3466 : e->value.compcall.actual = NULL;
7775 :
7776 : /* If we find a deferred typebound procedure, check for derived types
7777 : that an overriding typebound procedure has not been missed. */
7778 3466 : if (e->value.compcall.name
7779 3466 : && !e->value.compcall.tbp->non_overridable
7780 3448 : && e->value.compcall.base_object
7781 834 : && e->value.compcall.base_object->ts.type == BT_DERIVED)
7782 : {
7783 541 : gfc_symtree *st;
7784 541 : gfc_symbol *derived;
7785 :
7786 : /* Use the derived type of the base_object. */
7787 541 : derived = e->value.compcall.base_object->ts.u.derived;
7788 541 : st = NULL;
7789 :
7790 : /* If necessary, go through the inheritance chain. */
7791 1631 : while (!st && derived)
7792 : {
7793 : /* Look for the typebound procedure 'name'. */
7794 549 : if (derived->f2k_derived && derived->f2k_derived->tb_sym_root)
7795 541 : st = gfc_find_symtree (derived->f2k_derived->tb_sym_root,
7796 : e->value.compcall.name);
7797 549 : if (!st)
7798 8 : derived = gfc_get_derived_super_type (derived);
7799 : }
7800 :
7801 : /* Now find the specific name in the derived type namespace. */
7802 541 : if (st && st->n.tb && st->n.tb->u.specific)
7803 541 : gfc_find_sym_tree (st->n.tb->u.specific->name,
7804 541 : derived->ns, 1, &st);
7805 541 : if (st)
7806 541 : *target = st;
7807 : }
7808 :
7809 3466 : if (is_illegal_recursion ((*target)->n.sym, gfc_current_ns)
7810 3466 : && !e->value.compcall.tbp->deferred)
7811 1 : gfc_warning (0, "Non-RECURSIVE procedure %qs at %L is possibly calling"
7812 : " itself recursively. Declare it RECURSIVE or use"
7813 : " %<-frecursive%>", (*target)->n.sym->name, &e->where);
7814 :
7815 : return true;
7816 : }
7817 :
7818 :
7819 : /* Get the ultimate declared type from an expression. In addition,
7820 : return the last class/derived type reference and the copy of the
7821 : reference list. If check_types is set true, derived types are
7822 : identified as well as class references. */
7823 : static gfc_symbol*
7824 3449 : get_declared_from_expr (gfc_ref **class_ref, gfc_ref **new_ref,
7825 : gfc_expr *e, bool check_types)
7826 : {
7827 3449 : gfc_symbol *declared;
7828 3449 : gfc_ref *ref;
7829 :
7830 3449 : declared = NULL;
7831 3449 : if (class_ref)
7832 2948 : *class_ref = NULL;
7833 3449 : if (new_ref)
7834 2655 : *new_ref = gfc_copy_ref (e->ref);
7835 :
7836 4460 : for (ref = e->ref; ref; ref = ref->next)
7837 : {
7838 1011 : if (ref->type != REF_COMPONENT)
7839 376 : continue;
7840 :
7841 635 : if ((ref->u.c.component->ts.type == BT_CLASS
7842 304 : || (check_types && gfc_bt_struct (ref->u.c.component->ts.type)))
7843 560 : && ref->u.c.component->attr.flavor != FL_PROCEDURE)
7844 : {
7845 486 : declared = ref->u.c.component->ts.u.derived;
7846 486 : if (class_ref)
7847 398 : *class_ref = ref;
7848 : }
7849 : }
7850 :
7851 3449 : if (declared == NULL)
7852 3049 : declared = e->symtree->n.sym->ts.u.derived;
7853 :
7854 3449 : return declared;
7855 : }
7856 :
7857 :
7858 : /* Given an EXPR_COMPCALL calling a GENERIC typebound procedure, figure out
7859 : which of the specific bindings (if any) matches the arglist and transform
7860 : the expression into a call of that binding. */
7861 :
7862 : static bool
7863 3470 : resolve_typebound_generic_call (gfc_expr* e, const char **name)
7864 : {
7865 3470 : gfc_typebound_proc* genproc;
7866 3470 : const char* genname;
7867 3470 : gfc_symtree *st;
7868 3470 : gfc_symbol *derived;
7869 :
7870 3470 : gcc_assert (e->expr_type == EXPR_COMPCALL);
7871 3470 : genname = e->value.compcall.name;
7872 3470 : genproc = e->value.compcall.tbp;
7873 :
7874 3470 : if (!genproc->is_generic)
7875 : return true;
7876 :
7877 : /* Try the bindings on this type and in the inheritance hierarchy. */
7878 445 : for (; genproc; genproc = genproc->overridden)
7879 : {
7880 443 : gfc_tbp_generic* g;
7881 :
7882 443 : gcc_assert (genproc->is_generic);
7883 677 : for (g = genproc->u.generic; g; g = g->next)
7884 : {
7885 667 : gfc_symbol* target;
7886 667 : gfc_actual_arglist* args;
7887 667 : bool matches;
7888 :
7889 667 : gcc_assert (g->specific);
7890 :
7891 667 : if (g->specific->error)
7892 0 : continue;
7893 :
7894 667 : target = g->specific->u.specific->n.sym;
7895 :
7896 : /* Get the right arglist by handling PASS/NOPASS. */
7897 667 : args = gfc_copy_actual_arglist (e->value.compcall.actual);
7898 667 : if (!g->specific->nopass)
7899 : {
7900 581 : gfc_expr* po;
7901 581 : po = extract_compcall_passed_object (e);
7902 581 : if (!po)
7903 : {
7904 0 : gfc_free_actual_arglist (args);
7905 0 : return false;
7906 : }
7907 :
7908 581 : gcc_assert (g->specific->pass_arg_num > 0);
7909 581 : gcc_assert (!g->specific->error);
7910 581 : args = update_arglist_pass (args, po, g->specific->pass_arg_num,
7911 : g->specific->pass_arg);
7912 : }
7913 1339 : resolve_actual_arglist (args, target->attr.proc,
7914 667 : is_external_proc (target)
7915 5 : && gfc_sym_get_dummy_args (target) == NULL);
7916 :
7917 : /* Check if this arglist matches the formal. */
7918 667 : matches = gfc_arglist_matches_symbol (&args, target);
7919 :
7920 : /* Clean up and break out of the loop if we've found it. */
7921 667 : gfc_free_actual_arglist (args);
7922 667 : if (matches)
7923 : {
7924 433 : e->value.compcall.tbp = g->specific;
7925 433 : genname = g->specific_st->name;
7926 : /* Pass along the name for CLASS methods, where the vtab
7927 : procedure pointer component has to be referenced. */
7928 433 : if (name)
7929 161 : *name = genname;
7930 433 : goto success;
7931 : }
7932 : }
7933 : }
7934 :
7935 : /* Nothing matching found! */
7936 2 : gfc_error ("Found no matching specific binding for the call to the GENERIC"
7937 : " %qs at %L", genname, &e->where);
7938 2 : return false;
7939 :
7940 433 : success:
7941 : /* Make sure that we have the right specific instance for the name. */
7942 433 : derived = get_declared_from_expr (NULL, NULL, e, true);
7943 :
7944 433 : st = gfc_find_typebound_proc (derived, NULL, genname, true, &e->where);
7945 433 : if (st)
7946 433 : e->value.compcall.tbp = st->n.tb;
7947 :
7948 : return true;
7949 : }
7950 :
7951 :
7952 : /* Resolve a call to a type-bound subroutine. */
7953 :
7954 : static bool
7955 1780 : resolve_typebound_call (gfc_code* c, const char **name, bool *overridable)
7956 : {
7957 1780 : gfc_actual_arglist* newactual;
7958 1780 : gfc_symtree* target;
7959 :
7960 : /* Check that's really a SUBROUTINE. */
7961 1780 : if (!c->expr1->value.compcall.tbp->subroutine)
7962 : {
7963 17 : if (!c->expr1->value.compcall.tbp->is_generic
7964 15 : && c->expr1->value.compcall.tbp->u.specific
7965 15 : && c->expr1->value.compcall.tbp->u.specific->n.sym
7966 15 : && c->expr1->value.compcall.tbp->u.specific->n.sym->attr.subroutine)
7967 12 : c->expr1->value.compcall.tbp->subroutine = 1;
7968 : else
7969 : {
7970 5 : gfc_error ("%qs at %L should be a SUBROUTINE",
7971 : c->expr1->value.compcall.name, &c->loc);
7972 5 : return false;
7973 : }
7974 : }
7975 :
7976 1775 : if (!check_typebound_baseobject (c->expr1))
7977 : return false;
7978 :
7979 : /* Pass along the name for CLASS methods, where the vtab
7980 : procedure pointer component has to be referenced. */
7981 1768 : if (name)
7982 492 : *name = c->expr1->value.compcall.name;
7983 :
7984 1768 : if (!resolve_typebound_generic_call (c->expr1, name))
7985 : return false;
7986 :
7987 : /* Pass along the NON_OVERRIDABLE attribute of the specific TBP. */
7988 1767 : if (overridable)
7989 383 : *overridable = !c->expr1->value.compcall.tbp->non_overridable;
7990 :
7991 : /* Transform into an ordinary EXEC_CALL for now. */
7992 :
7993 1767 : if (!resolve_typebound_static (c->expr1, &target, &newactual))
7994 : return false;
7995 :
7996 1765 : c->ext.actual = newactual;
7997 1765 : c->symtree = target;
7998 1765 : c->op = (c->expr1->value.compcall.assign ? EXEC_ASSIGN_CALL : EXEC_CALL);
7999 :
8000 1765 : gcc_assert (!c->expr1->ref && !c->expr1->value.compcall.actual);
8001 :
8002 1765 : gfc_free_expr (c->expr1);
8003 1765 : c->expr1 = gfc_get_expr ();
8004 1765 : c->expr1->expr_type = EXPR_FUNCTION;
8005 1765 : c->expr1->symtree = target;
8006 1765 : c->expr1->where = c->loc;
8007 :
8008 1765 : return resolve_call (c);
8009 : }
8010 :
8011 :
8012 : /* Resolve a component-call expression. */
8013 : static bool
8014 1711 : resolve_compcall (gfc_expr* e, const char **name)
8015 : {
8016 1711 : gfc_actual_arglist* newactual;
8017 1711 : gfc_symtree* target;
8018 :
8019 : /* Check that's really a FUNCTION. */
8020 1711 : if (!e->value.compcall.tbp->function)
8021 : {
8022 7 : if (e->symtree && e->symtree->n.sym->resolve_symbol_called)
8023 5 : gfc_error ("%qs at %L should be a FUNCTION", e->value.compcall.name,
8024 : &e->where);
8025 : return false;
8026 : }
8027 :
8028 :
8029 : /* These must not be assign-calls! */
8030 1704 : gcc_assert (!e->value.compcall.assign);
8031 :
8032 1704 : if (!check_typebound_baseobject (e))
8033 : return false;
8034 :
8035 : /* Pass along the name for CLASS methods, where the vtab
8036 : procedure pointer component has to be referenced. */
8037 1702 : if (name)
8038 900 : *name = e->value.compcall.name;
8039 :
8040 1702 : if (!resolve_typebound_generic_call (e, name))
8041 : return false;
8042 1701 : gcc_assert (!e->value.compcall.tbp->is_generic);
8043 :
8044 : /* Take the rank from the function's symbol. */
8045 1701 : if (e->value.compcall.tbp->u.specific->n.sym->as)
8046 : {
8047 155 : e->rank = e->value.compcall.tbp->u.specific->n.sym->as->rank;
8048 155 : e->corank = e->value.compcall.tbp->u.specific->n.sym->as->corank;
8049 : }
8050 :
8051 : /* For now, we simply transform it into an EXPR_FUNCTION call with the same
8052 : arglist to the TBP's binding target. */
8053 :
8054 1701 : if (!resolve_typebound_static (e, &target, &newactual))
8055 : return false;
8056 :
8057 1701 : e->value.function.actual = newactual;
8058 1701 : e->value.function.name = NULL;
8059 1701 : e->value.function.esym = target->n.sym;
8060 1701 : e->value.function.isym = NULL;
8061 1701 : e->symtree = target;
8062 1701 : e->ts = target->n.sym->ts;
8063 1701 : e->expr_type = EXPR_FUNCTION;
8064 :
8065 : /* Resolution is not necessary if this is a class subroutine; this
8066 : function only has to identify the specific proc. Resolution of
8067 : the call will be done next in resolve_typebound_call. */
8068 1701 : return gfc_resolve_expr (e);
8069 : }
8070 :
8071 :
8072 : static bool resolve_fl_derived (gfc_symbol *sym);
8073 :
8074 :
8075 : /* Fix up the references of the EXPR_COMPCALL or EXPR_PPC E, whose base
8076 : object is an inferred type associate name, as for the equivalent
8077 : variable. Look up the type-bound procedure again in the corrected
8078 : type. */
8079 :
8080 : static void
8081 3264 : fixup_inferred_compcall_refs (gfc_expr *e)
8082 : {
8083 3264 : gfc_symbol *sym, *dt;
8084 3264 : gfc_symtree *tbp;
8085 3264 : gfc_expr *var;
8086 3264 : bool t;
8087 :
8088 3264 : sym = e->symtree->n.sym;
8089 3264 : if (!sym->assoc || !sym->assoc->inferred_type
8090 74 : || (sym->ts.type != BT_DERIVED && sym->ts.type != BT_CLASS))
8091 3196 : return;
8092 :
8093 74 : if (e->ref)
8094 : {
8095 42 : var = gfc_get_expr ();
8096 42 : var->expr_type = EXPR_VARIABLE;
8097 42 : var->symtree = e->symtree;
8098 42 : var->ref = e->ref;
8099 42 : var->ts = sym->ts;
8100 42 : var->where = e->where;
8101 42 : gfc_fixup_inferred_type_refs (var);
8102 42 : e->ref = var->ref;
8103 42 : var->ref = NULL;
8104 42 : gfc_free_expr (var);
8105 : }
8106 :
8107 74 : if (e->expr_type != EXPR_COMPCALL || !e->value.compcall.name)
8108 : return;
8109 :
8110 68 : dt = get_declared_from_expr (NULL, NULL, e, true);
8111 68 : if (dt->attr.is_class && dt->components)
8112 48 : dt = dt->components->ts.u.derived;
8113 :
8114 68 : tbp = gfc_find_typebound_proc (dt, &t, e->value.compcall.name, false,
8115 : &e->where);
8116 68 : if (tbp && t)
8117 68 : e->value.compcall.tbp = tbp->n.tb;
8118 : }
8119 :
8120 :
8121 : /* Resolve a typebound function, or 'method'. First separate all
8122 : the non-CLASS references by calling resolve_compcall directly. */
8123 :
8124 : static bool
8125 1711 : resolve_typebound_function (gfc_expr* e)
8126 : {
8127 1711 : gfc_symbol *declared;
8128 1711 : gfc_component *c;
8129 1711 : gfc_ref *new_ref;
8130 1711 : gfc_ref *class_ref;
8131 1711 : gfc_symtree *st;
8132 1711 : const char *name;
8133 1711 : gfc_typespec ts;
8134 1711 : gfc_expr *expr;
8135 1711 : bool overridable;
8136 :
8137 1711 : st = e->symtree;
8138 :
8139 : /* Deal with typebound operators for CLASS objects. */
8140 1711 : expr = e->value.compcall.base_object;
8141 1711 : overridable = !e->value.compcall.tbp->non_overridable;
8142 1711 : if (expr && expr->ts.type == BT_CLASS && e->value.compcall.name)
8143 : {
8144 : /* Since the typebound operators are generic, we have to ensure
8145 : that any delays in resolution are corrected and that the vtab
8146 : is present. */
8147 184 : ts = expr->ts;
8148 184 : declared = ts.u.derived;
8149 184 : if (!resolve_fl_derived (declared))
8150 : return false;
8151 :
8152 184 : c = gfc_find_component (declared, "_vptr", true, true, NULL);
8153 184 : if (c->ts.u.derived == NULL)
8154 0 : c->ts.u.derived = gfc_find_derived_vtab (declared);
8155 :
8156 184 : if (!resolve_compcall (e, &name))
8157 : return false;
8158 :
8159 : /* Use the generic name if it is there. */
8160 184 : name = name ? name : e->value.function.esym->name;
8161 184 : e->symtree = expr->symtree;
8162 184 : e->ref = gfc_copy_ref (expr->ref);
8163 184 : get_declared_from_expr (&class_ref, NULL, e, false);
8164 :
8165 : /* Trim away the extraneous references that emerge from nested
8166 : use of interface.cc (extend_expr). */
8167 184 : if (class_ref && class_ref->next)
8168 : {
8169 0 : gfc_free_ref_list (class_ref->next);
8170 0 : class_ref->next = NULL;
8171 : }
8172 184 : else if (e->ref && !class_ref && expr->ts.type != BT_CLASS)
8173 : {
8174 0 : gfc_free_ref_list (e->ref);
8175 0 : e->ref = NULL;
8176 : }
8177 :
8178 184 : gfc_add_vptr_component (e);
8179 184 : gfc_add_component_ref (e, name);
8180 184 : e->value.function.esym = NULL;
8181 184 : if (expr->expr_type != EXPR_VARIABLE)
8182 80 : e->base_expr = expr;
8183 : return true;
8184 : }
8185 :
8186 1527 : if (st == NULL)
8187 195 : return resolve_compcall (e, NULL);
8188 :
8189 1332 : fixup_inferred_compcall_refs (e);
8190 :
8191 1332 : if (!gfc_resolve_ref (e))
8192 : return false;
8193 :
8194 : /* It can happen that a generic, typebound procedure is marked as overridable
8195 : with all of the specific procedures being non-overridable. If this is the
8196 : case, it is safe to resolve the compcall. */
8197 1332 : if (!expr && overridable
8198 1324 : && e->value.compcall.tbp->is_generic
8199 198 : && e->value.compcall.tbp->u.generic->specific
8200 197 : && e->value.compcall.tbp->u.generic->specific->non_overridable)
8201 : {
8202 : gfc_tbp_generic *g = e->value.compcall.tbp->u.generic;
8203 6 : for (; g; g = g->next)
8204 4 : if (!g->specific->non_overridable)
8205 : break;
8206 2 : if (g == NULL && resolve_compcall (e, &name))
8207 : return true;
8208 : }
8209 :
8210 : /* Get the CLASS declared type. */
8211 1330 : declared = get_declared_from_expr (&class_ref, &new_ref, e, true);
8212 :
8213 1330 : if (!resolve_fl_derived (declared))
8214 : return false;
8215 :
8216 : /* Weed out cases of the ultimate component being a derived type. */
8217 1330 : if ((class_ref && gfc_bt_struct (class_ref->u.c.component->ts.type))
8218 1236 : || (!class_ref && st->n.sym->ts.type != BT_CLASS))
8219 : {
8220 614 : gfc_free_ref_list (new_ref);
8221 614 : return resolve_compcall (e, NULL);
8222 : }
8223 :
8224 716 : c = gfc_find_component (declared, "_data", true, true, NULL);
8225 :
8226 : /* Treat the call as if it is a typebound procedure, in order to roll
8227 : out the correct name for the specific function. */
8228 716 : if (!resolve_compcall (e, &name))
8229 : {
8230 3 : gfc_free_ref_list (new_ref);
8231 3 : return false;
8232 : }
8233 713 : ts = e->ts;
8234 :
8235 713 : if (overridable)
8236 : {
8237 : /* Convert the expression to a procedure pointer component call. */
8238 711 : e->value.function.esym = NULL;
8239 711 : e->symtree = st;
8240 :
8241 711 : if (new_ref)
8242 155 : e->ref = new_ref;
8243 :
8244 : /* '_vptr' points to the vtab, which contains the procedure pointers. */
8245 711 : gfc_add_vptr_component (e);
8246 711 : gfc_add_component_ref (e, name);
8247 :
8248 : /* Recover the typespec for the expression. This is really only
8249 : necessary for generic procedures, where the additional call
8250 : to gfc_add_component_ref seems to throw the collection of the
8251 : correct typespec. */
8252 711 : e->ts = ts;
8253 : }
8254 2 : else if (new_ref)
8255 0 : gfc_free_ref_list (new_ref);
8256 :
8257 : return true;
8258 : }
8259 :
8260 : /* Resolve a typebound subroutine, or 'method'. First separate all
8261 : the non-CLASS references by calling resolve_typebound_call
8262 : directly. */
8263 :
8264 : static bool
8265 1780 : resolve_typebound_subroutine (gfc_code *code)
8266 : {
8267 1780 : gfc_symbol *declared;
8268 1780 : gfc_component *c;
8269 1780 : gfc_ref *new_ref;
8270 1780 : gfc_ref *class_ref;
8271 1780 : gfc_symtree *st;
8272 1780 : const char *name;
8273 1780 : gfc_typespec ts;
8274 1780 : gfc_expr *expr;
8275 1780 : bool overridable;
8276 :
8277 1780 : st = code->expr1->symtree;
8278 :
8279 : /* Deal with typebound operators for CLASS objects. */
8280 1780 : expr = code->expr1->value.compcall.base_object;
8281 1780 : overridable = !code->expr1->value.compcall.tbp->non_overridable;
8282 1780 : if (expr && expr->ts.type == BT_CLASS && code->expr1->value.compcall.name)
8283 : {
8284 : /* If the base_object is not a variable, the corresponding actual
8285 : argument expression must be stored in e->base_expression so
8286 : that the corresponding tree temporary can be used as the base
8287 : object in gfc_conv_procedure_call. */
8288 109 : if (expr->expr_type != EXPR_VARIABLE)
8289 : {
8290 : gfc_actual_arglist *args;
8291 :
8292 : args= code->expr1->value.function.actual;
8293 : for (; args; args = args->next)
8294 : if (expr == args->expr)
8295 : expr = args->expr;
8296 : }
8297 :
8298 : /* Since the typebound operators are generic, we have to ensure
8299 : that any delays in resolution are corrected and that the vtab
8300 : is present. */
8301 109 : declared = expr->ts.u.derived;
8302 109 : c = gfc_find_component (declared, "_vptr", true, true, NULL);
8303 109 : if (c->ts.u.derived == NULL)
8304 0 : c->ts.u.derived = gfc_find_derived_vtab (declared);
8305 :
8306 109 : if (!resolve_typebound_call (code, &name, NULL))
8307 : return false;
8308 :
8309 : /* Use the generic name if it is there. */
8310 109 : name = name ? name : code->expr1->value.function.esym->name;
8311 109 : code->expr1->symtree = expr->symtree;
8312 109 : code->expr1->ref = gfc_copy_ref (expr->ref);
8313 :
8314 : /* Trim away the extraneous references that emerge from nested
8315 : use of interface.cc (extend_expr). */
8316 109 : get_declared_from_expr (&class_ref, NULL, code->expr1, false);
8317 109 : if (class_ref && class_ref->next)
8318 : {
8319 0 : gfc_free_ref_list (class_ref->next);
8320 0 : class_ref->next = NULL;
8321 : }
8322 109 : else if (code->expr1->ref && !class_ref)
8323 : {
8324 18 : gfc_free_ref_list (code->expr1->ref);
8325 18 : code->expr1->ref = NULL;
8326 : }
8327 :
8328 : /* Now use the procedure in the vtable. */
8329 109 : gfc_add_vptr_component (code->expr1);
8330 109 : gfc_add_component_ref (code->expr1, name);
8331 109 : code->expr1->value.function.esym = NULL;
8332 109 : if (expr->expr_type != EXPR_VARIABLE)
8333 0 : code->expr1->base_expr = expr;
8334 : return true;
8335 : }
8336 :
8337 1671 : if (st == NULL)
8338 346 : return resolve_typebound_call (code, NULL, NULL);
8339 :
8340 1325 : fixup_inferred_compcall_refs (code->expr1);
8341 :
8342 1325 : if (!gfc_resolve_ref (code->expr1))
8343 : return false;
8344 :
8345 : /* Get the CLASS declared type. */
8346 1325 : get_declared_from_expr (&class_ref, &new_ref, code->expr1, true);
8347 :
8348 : /* Weed out cases of the ultimate component being a derived type. */
8349 1325 : if ((class_ref && gfc_bt_struct (class_ref->u.c.component->ts.type))
8350 1260 : || (!class_ref && st->n.sym->ts.type != BT_CLASS))
8351 : {
8352 937 : gfc_free_ref_list (new_ref);
8353 937 : return resolve_typebound_call (code, NULL, NULL);
8354 : }
8355 :
8356 388 : if (!resolve_typebound_call (code, &name, &overridable))
8357 : {
8358 5 : gfc_free_ref_list (new_ref);
8359 5 : return false;
8360 : }
8361 383 : ts = code->expr1->ts;
8362 :
8363 383 : if (overridable)
8364 : {
8365 : /* Convert the expression to a procedure pointer component call. */
8366 381 : code->expr1->value.function.esym = NULL;
8367 381 : code->expr1->symtree = st;
8368 :
8369 381 : if (new_ref)
8370 99 : code->expr1->ref = new_ref;
8371 :
8372 : /* '_vptr' points to the vtab, which contains the procedure pointers. */
8373 381 : gfc_add_vptr_component (code->expr1);
8374 381 : gfc_add_component_ref (code->expr1, name);
8375 :
8376 : /* Recover the typespec for the expression. This is really only
8377 : necessary for generic procedures, where the additional call
8378 : to gfc_add_component_ref seems to throw the collection of the
8379 : correct typespec. */
8380 381 : code->expr1->ts = ts;
8381 : }
8382 2 : else if (new_ref)
8383 0 : gfc_free_ref_list (new_ref);
8384 :
8385 : return true;
8386 : }
8387 :
8388 :
8389 : /* Resolve a CALL to a Procedure Pointer Component (Subroutine). */
8390 :
8391 : static bool
8392 124 : resolve_ppc_call (gfc_code* c)
8393 : {
8394 124 : gfc_component *comp;
8395 :
8396 124 : fixup_inferred_compcall_refs (c->expr1);
8397 :
8398 124 : comp = gfc_get_proc_ptr_comp (c->expr1);
8399 124 : gcc_assert (comp != NULL);
8400 :
8401 124 : c->resolved_sym = c->expr1->symtree->n.sym;
8402 124 : c->expr1->expr_type = EXPR_VARIABLE;
8403 :
8404 124 : if (!comp->attr.subroutine)
8405 1 : gfc_add_subroutine (&comp->attr, comp->name, &c->expr1->where);
8406 :
8407 124 : if (!gfc_resolve_ref (c->expr1))
8408 : return false;
8409 :
8410 124 : if (!update_ppc_arglist (c->expr1))
8411 : return false;
8412 :
8413 123 : c->ext.actual = c->expr1->value.compcall.actual;
8414 :
8415 123 : if (!resolve_actual_arglist (c->ext.actual, comp->attr.proc,
8416 123 : !(comp->ts.interface
8417 93 : && comp->ts.interface->formal)))
8418 : return false;
8419 :
8420 123 : if (!pure_subroutine (comp->ts.interface, comp->name, &c->expr1->where))
8421 : return false;
8422 :
8423 122 : gfc_ppc_use (comp, &c->expr1->value.compcall.actual, &c->expr1->where);
8424 :
8425 122 : return true;
8426 : }
8427 :
8428 :
8429 : /* Resolve a Function Call to a Procedure Pointer Component (Function). */
8430 :
8431 : static bool
8432 483 : resolve_expr_ppc (gfc_expr* e)
8433 : {
8434 483 : gfc_component *comp;
8435 :
8436 483 : fixup_inferred_compcall_refs (e);
8437 :
8438 483 : comp = gfc_get_proc_ptr_comp (e);
8439 483 : gcc_assert (comp != NULL);
8440 :
8441 : /* Convert to EXPR_FUNCTION. */
8442 483 : e->expr_type = EXPR_FUNCTION;
8443 483 : e->value.function.isym = NULL;
8444 483 : e->value.function.actual = e->value.compcall.actual;
8445 483 : e->ts = comp->ts;
8446 483 : if (comp->as != NULL)
8447 : {
8448 28 : e->rank = comp->as->rank;
8449 28 : e->corank = comp->as->corank;
8450 : }
8451 :
8452 483 : if (!comp->attr.function)
8453 3 : gfc_add_function (&comp->attr, comp->name, &e->where);
8454 :
8455 483 : if (!gfc_resolve_ref (e))
8456 : return false;
8457 :
8458 483 : if (!resolve_actual_arglist (e->value.function.actual, comp->attr.proc,
8459 483 : !(comp->ts.interface
8460 482 : && comp->ts.interface->formal)))
8461 : return false;
8462 :
8463 483 : if (!update_ppc_arglist (e))
8464 : return false;
8465 :
8466 481 : if (!check_pure_function(e))
8467 : return false;
8468 :
8469 480 : gfc_ppc_use (comp, &e->value.compcall.actual, &e->where);
8470 :
8471 480 : return true;
8472 : }
8473 :
8474 :
8475 : static bool
8476 12607 : gfc_is_expandable_expr (gfc_expr *e)
8477 : {
8478 12607 : gfc_constructor *con;
8479 :
8480 12607 : if (e->expr_type == EXPR_ARRAY)
8481 : {
8482 : /* Traverse the constructor looking for variables that are flavor
8483 : parameter. Parameters must be expanded since they are fully used at
8484 : compile time. */
8485 12607 : con = gfc_constructor_first (e->value.constructor);
8486 33444 : for (; con; con = gfc_constructor_next (con))
8487 : {
8488 14578 : if (con->expr->expr_type == EXPR_VARIABLE
8489 5557 : && con->expr->symtree
8490 5557 : && (con->expr->symtree->n.sym->attr.flavor == FL_PARAMETER
8491 5557 : || con->expr->symtree->n.sym->attr.flavor == FL_VARIABLE))
8492 : return true;
8493 9021 : if (con->expr->expr_type == EXPR_ARRAY
8494 9021 : && gfc_is_expandable_expr (con->expr))
8495 : return true;
8496 : }
8497 : }
8498 :
8499 : return false;
8500 : }
8501 :
8502 :
8503 : /* Sometimes variables in specification expressions of the result
8504 : of module procedures in submodules wind up not being the 'real'
8505 : dummy. Find this, if possible, in the namespace of the first
8506 : formal argument. */
8507 :
8508 : static void
8509 4767 : fixup_unique_dummy (gfc_expr *e)
8510 : {
8511 4767 : gfc_symtree *st = NULL;
8512 4767 : gfc_symbol *s = NULL;
8513 :
8514 4767 : if (e->symtree->n.sym->ns->proc_name
8515 4767 : && e->symtree->n.sym->ns->proc_name->formal)
8516 4767 : s = e->symtree->n.sym->ns->proc_name->formal->sym;
8517 :
8518 4767 : if (s != NULL)
8519 4767 : st = gfc_find_symtree (s->ns->sym_root, e->symtree->n.sym->name);
8520 :
8521 4767 : if (st != NULL
8522 14 : && st->n.sym != NULL
8523 14 : && st->n.sym->attr.dummy)
8524 14 : e->symtree = st;
8525 4767 : }
8526 :
8527 :
8528 : /* Resolve an expression. That is, make sure that types of operands agree
8529 : with their operators, intrinsic operators are converted to function calls
8530 : for overloaded types and unresolved function references are resolved. */
8531 :
8532 : bool
8533 7181162 : gfc_resolve_expr (gfc_expr *e)
8534 : {
8535 7181162 : bool t;
8536 7181162 : bool inquiry_save, actual_arg_save, first_actual_arg_save;
8537 :
8538 7181162 : if (e == NULL || e->do_not_resolve_again)
8539 : return true;
8540 :
8541 : /* inquiry_argument only applies to variables. */
8542 5203451 : inquiry_save = inquiry_argument;
8543 5203451 : actual_arg_save = actual_arg;
8544 5203451 : first_actual_arg_save = first_actual_arg;
8545 :
8546 5203451 : if (e->expr_type != EXPR_VARIABLE)
8547 : {
8548 3841324 : inquiry_argument = false;
8549 3841324 : actual_arg = false;
8550 3841324 : first_actual_arg = false;
8551 : }
8552 1362127 : else if (e->symtree != NULL
8553 1361652 : && *e->symtree->name == '@'
8554 5501 : && e->symtree->n.sym->attr.dummy)
8555 : {
8556 : /* Deal with submodule specification expressions that are not
8557 : found to be referenced in module.cc(read_cleanup). */
8558 4767 : fixup_unique_dummy (e);
8559 : }
8560 :
8561 5203451 : switch (e->expr_type)
8562 : {
8563 544072 : case EXPR_OP:
8564 544072 : t = resolve_operator (e);
8565 544072 : break;
8566 :
8567 170 : case EXPR_CONDITIONAL:
8568 170 : t = resolve_conditional (e);
8569 170 : break;
8570 :
8571 1717226 : case EXPR_FUNCTION:
8572 1717226 : case EXPR_VARIABLE:
8573 :
8574 1717226 : if (check_host_association (e))
8575 355135 : t = resolve_function (e);
8576 : else
8577 1362091 : t = resolve_variable (e);
8578 :
8579 1717226 : if (e->ts.type == BT_CHARACTER && e->ts.u.cl == NULL && e->ref)
8580 7457 : gfc_resolve_substring_charlen (e);
8581 :
8582 : break;
8583 :
8584 1711 : case EXPR_COMPCALL:
8585 1711 : t = resolve_typebound_function (e);
8586 1711 : break;
8587 :
8588 511 : case EXPR_SUBSTRING:
8589 511 : t = gfc_resolve_ref (e);
8590 511 : break;
8591 :
8592 : case EXPR_CONSTANT:
8593 : case EXPR_NULL:
8594 : t = true;
8595 : break;
8596 :
8597 483 : case EXPR_PPC:
8598 483 : t = resolve_expr_ppc (e);
8599 483 : break;
8600 :
8601 75425 : case EXPR_ARRAY:
8602 75425 : t = false;
8603 75425 : if (!gfc_resolve_ref (e))
8604 : break;
8605 :
8606 75425 : t = gfc_resolve_array_constructor (e);
8607 : /* Also try to expand a constructor. */
8608 75425 : if (t)
8609 : {
8610 75323 : gfc_expression_rank (e);
8611 75323 : if (gfc_is_constant_expr (e) || gfc_is_expandable_expr (e))
8612 70387 : gfc_expand_constructor (e, false);
8613 : }
8614 :
8615 : /* This provides the opportunity for the length of constructors with
8616 : character valued function elements to propagate the string length
8617 : to the expression. */
8618 75323 : if (t && e->ts.type == BT_CHARACTER)
8619 : {
8620 : /* For efficiency, we call gfc_expand_constructor for BT_CHARACTER
8621 : here rather then add a duplicate test for it above. */
8622 11085 : gfc_expand_constructor (e, false);
8623 11085 : t = gfc_resolve_character_array_constructor (e);
8624 : }
8625 :
8626 : break;
8627 :
8628 17539 : case EXPR_STRUCTURE:
8629 17539 : t = gfc_resolve_ref (e);
8630 17539 : if (!t)
8631 : break;
8632 :
8633 17539 : t = resolve_structure_cons (e, 0);
8634 17539 : if (!t)
8635 : break;
8636 :
8637 17527 : t = gfc_simplify_expr (e, 0);
8638 17527 : break;
8639 :
8640 0 : default:
8641 0 : gfc_internal_error ("gfc_resolve_expr(): Bad expression type");
8642 : }
8643 :
8644 5203451 : if (e->ts.type == BT_CHARACTER && t && !e->ts.u.cl)
8645 182557 : fixup_charlen (e);
8646 :
8647 5203451 : inquiry_argument = inquiry_save;
8648 5203451 : actual_arg = actual_arg_save;
8649 5203451 : first_actual_arg = first_actual_arg_save;
8650 :
8651 : /* For some reason, resolving these expressions a second time mangles
8652 : the typespec of the expression itself. */
8653 5203451 : if (t && e->expr_type == EXPR_VARIABLE
8654 1359206 : && e->symtree->n.sym->attr.select_rank_temporary
8655 3470 : && UNLIMITED_POLY (e->symtree->n.sym))
8656 83 : e->do_not_resolve_again = 1;
8657 :
8658 5200874 : if (t && gfc_current_ns->import_state != IMPORT_NOT_SET)
8659 7726 : t = check_import_status (e);
8660 :
8661 : return t;
8662 : }
8663 :
8664 :
8665 : /* Resolve an expression from an iterator. They must be scalar and have
8666 : INTEGER or (optionally) REAL type. */
8667 :
8668 : static bool
8669 156621 : gfc_resolve_iterator_expr (gfc_expr *expr, bool real_ok,
8670 : const char *name_msgid)
8671 : {
8672 156621 : if (!gfc_resolve_expr (expr))
8673 : return false;
8674 :
8675 156616 : if (expr->rank != 0)
8676 : {
8677 0 : gfc_error ("%s at %L must be a scalar", _(name_msgid), &expr->where);
8678 0 : return false;
8679 : }
8680 :
8681 156616 : if (expr->ts.type != BT_INTEGER)
8682 : {
8683 317 : if (expr->ts.type == BT_REAL)
8684 : {
8685 317 : if (real_ok)
8686 314 : return gfc_notify_std (GFC_STD_F95_DEL,
8687 : "%s at %L must be integer",
8688 314 : _(name_msgid), &expr->where);
8689 : else
8690 : {
8691 3 : gfc_error ("%s at %L must be INTEGER", _(name_msgid),
8692 : &expr->where);
8693 3 : return false;
8694 : }
8695 : }
8696 : else
8697 : {
8698 0 : gfc_error ("%s at %L must be INTEGER", _(name_msgid), &expr->where);
8699 0 : return false;
8700 : }
8701 : }
8702 : return true;
8703 : }
8704 :
8705 :
8706 : /* Resolve the expressions in an iterator structure. If REAL_OK is
8707 : false allow only INTEGER type iterators, otherwise allow REAL types.
8708 : Set own_scope to true for ac-implied-do and data-implied-do as those
8709 : have a separate scope such that, e.g., a INTENT(IN) doesn't apply. */
8710 :
8711 : bool
8712 39164 : gfc_resolve_iterator (gfc_iterator *iter, bool real_ok, bool own_scope)
8713 : {
8714 39164 : if (!gfc_resolve_iterator_expr (iter->var, real_ok, "Loop variable"))
8715 : return false;
8716 :
8717 39160 : if (!gfc_check_vardef_context (iter->var, false, false, own_scope,
8718 39160 : _("iterator variable")))
8719 : return false;
8720 :
8721 39154 : if (!gfc_resolve_iterator_expr (iter->start, real_ok,
8722 : "Start expression in DO loop"))
8723 : return false;
8724 :
8725 39153 : if (!gfc_resolve_iterator_expr (iter->end, real_ok,
8726 : "End expression in DO loop"))
8727 : return false;
8728 :
8729 39150 : if (!gfc_resolve_iterator_expr (iter->step, real_ok,
8730 : "Step expression in DO loop"))
8731 : return false;
8732 :
8733 : /* Convert start, end, and step to the same type as var. */
8734 39149 : if (iter->start->ts.kind != iter->var->ts.kind
8735 38820 : || iter->start->ts.type != iter->var->ts.type)
8736 393 : gfc_convert_type (iter->start, &iter->var->ts, 1);
8737 :
8738 39149 : if (iter->end->ts.kind != iter->var->ts.kind
8739 38847 : || iter->end->ts.type != iter->var->ts.type)
8740 345 : gfc_convert_type (iter->end, &iter->var->ts, 1);
8741 :
8742 39149 : if (iter->step->ts.kind != iter->var->ts.kind
8743 38857 : || iter->step->ts.type != iter->var->ts.type)
8744 358 : gfc_convert_type (iter->step, &iter->var->ts, 1);
8745 :
8746 39149 : if (iter->step->expr_type == EXPR_CONSTANT)
8747 : {
8748 38026 : if ((iter->step->ts.type == BT_INTEGER
8749 37913 : && mpz_cmp_ui (iter->step->value.integer, 0) == 0)
8750 75937 : || (iter->step->ts.type == BT_REAL
8751 113 : && mpfr_sgn (iter->step->value.real) == 0))
8752 : {
8753 3 : gfc_error ("Step expression in DO loop at %L cannot be zero",
8754 3 : &iter->step->where);
8755 3 : return false;
8756 : }
8757 : }
8758 :
8759 39146 : if (iter->start->expr_type == EXPR_CONSTANT
8760 36002 : && iter->end->expr_type == EXPR_CONSTANT
8761 28097 : && iter->step->expr_type == EXPR_CONSTANT)
8762 : {
8763 27830 : int sgn, cmp;
8764 27830 : if (iter->start->ts.type == BT_INTEGER)
8765 : {
8766 27775 : sgn = mpz_cmp_ui (iter->step->value.integer, 0);
8767 27775 : cmp = mpz_cmp (iter->end->value.integer, iter->start->value.integer);
8768 : }
8769 : else
8770 : {
8771 55 : sgn = mpfr_sgn (iter->step->value.real);
8772 55 : cmp = mpfr_cmp (iter->end->value.real, iter->start->value.real);
8773 : }
8774 27830 : if (warn_zerotrip && ((sgn > 0 && cmp < 0) || (sgn < 0 && cmp > 0)))
8775 146 : gfc_warning (OPT_Wzerotrip,
8776 : "DO loop at %L will be executed zero times",
8777 146 : &iter->step->where);
8778 : }
8779 :
8780 39146 : if (iter->end->expr_type == EXPR_CONSTANT
8781 28465 : && iter->end->ts.type == BT_INTEGER
8782 28410 : && iter->step->expr_type == EXPR_CONSTANT
8783 28100 : && iter->step->ts.type == BT_INTEGER
8784 28100 : && (mpz_cmp_si (iter->step->value.integer, -1L) == 0
8785 27726 : || mpz_cmp_si (iter->step->value.integer, 1L) == 0))
8786 : {
8787 26943 : bool is_step_positive = mpz_cmp_ui (iter->step->value.integer, 1) == 0;
8788 26943 : int k = gfc_validate_kind (BT_INTEGER, iter->end->ts.kind, false);
8789 :
8790 26943 : if (is_step_positive
8791 26569 : && mpz_cmp (iter->end->value.integer, gfc_integer_kinds[k].huge) == 0)
8792 7 : gfc_warning (OPT_Wundefined_do_loop,
8793 : "DO loop at %L is undefined as it overflows",
8794 7 : &iter->step->where);
8795 : else if (!is_step_positive
8796 374 : && mpz_cmp (iter->end->value.integer,
8797 374 : gfc_integer_kinds[k].min_int) == 0)
8798 7 : gfc_warning (OPT_Wundefined_do_loop,
8799 : "DO loop at %L is undefined as it underflows",
8800 7 : &iter->step->where);
8801 : }
8802 :
8803 39146 : gfc_value_set_and_used (iter->var, &iter->var->where, VALUE_VARDEF,
8804 : VALUE_USED);
8805 39146 : gfc_value_used_expr (iter->start, VALUE_USED);
8806 39146 : gfc_value_used_expr (iter->end, VALUE_USED);
8807 39146 : gfc_value_used_expr (iter->step, VALUE_USED);
8808 :
8809 39146 : return true;
8810 : }
8811 :
8812 :
8813 : /* Traversal function for find_forall_index. f == 2 signals that
8814 : that variable itself is not to be checked - only the references. */
8815 :
8816 : static bool
8817 43194 : forall_index (gfc_expr *expr, gfc_symbol *sym, int *f)
8818 : {
8819 43194 : if (expr->expr_type != EXPR_VARIABLE)
8820 : return false;
8821 :
8822 : /* A scalar assignment */
8823 18323 : if (!expr->ref || *f == 1)
8824 : {
8825 12237 : if (expr->symtree->n.sym == sym)
8826 : return true;
8827 : else
8828 8197 : return false;
8829 : }
8830 :
8831 6086 : if (*f == 2)
8832 1731 : *f = 1;
8833 : return false;
8834 : }
8835 :
8836 :
8837 : /* Check whether the FORALL index appears in the expression or not.
8838 : Returns true if SYM is found in EXPR. */
8839 :
8840 : bool
8841 27548 : find_forall_index (gfc_expr *expr, gfc_symbol *sym, int f)
8842 : {
8843 27548 : if (gfc_traverse_expr (expr, sym, forall_index, f))
8844 : return true;
8845 : else
8846 : return false;
8847 : }
8848 :
8849 : /* Check compliance with Fortran 2023's C1133 constraint for DO CONCURRENT
8850 : This constraint specifies rules for variables in locality-specs. */
8851 :
8852 : static int
8853 1149 : do_concur_locality_specs_f2023 (gfc_expr **expr, int *walk_subtrees, void *data)
8854 : {
8855 1149 : struct check_default_none_data *dt = (struct check_default_none_data *) data;
8856 :
8857 1149 : if ((*expr)->expr_type == EXPR_VARIABLE)
8858 : {
8859 22 : gfc_symbol *sym = (*expr)->symtree->n.sym;
8860 22 : for (gfc_expr_list *list = dt->code->ext.concur.locality[LOCALITY_LOCAL];
8861 24 : list; list = list->next)
8862 : {
8863 5 : if (list->expr->symtree->n.sym == sym)
8864 : {
8865 3 : gfc_error ("Variable %qs referenced in concurrent-header at %L "
8866 : "must not appear in LOCAL locality-spec at %L",
8867 : sym->name, &(*expr)->where, &list->expr->where);
8868 3 : *walk_subtrees = 0;
8869 3 : return 1;
8870 : }
8871 : }
8872 : }
8873 :
8874 1146 : *walk_subtrees = 1;
8875 1146 : return 0;
8876 : }
8877 :
8878 : static int
8879 5002 : check_default_none_expr (gfc_expr **e, int *, void *data)
8880 : {
8881 5002 : struct check_default_none_data *d = (struct check_default_none_data*) data;
8882 :
8883 5002 : if ((*e)->expr_type == EXPR_VARIABLE)
8884 : {
8885 2428 : gfc_symbol *sym = (*e)->symtree->n.sym;
8886 :
8887 2428 : if (d->sym_hash->contains (sym))
8888 1471 : sym->mark = 1;
8889 :
8890 957 : else if (d->default_none)
8891 : {
8892 8 : gfc_namespace *ns2 = d->ns;
8893 13 : while (ns2)
8894 : {
8895 8 : if (ns2 == sym->ns)
8896 : break;
8897 5 : ns2 = ns2->parent;
8898 : }
8899 :
8900 : /* A DO CONCURRENT iterator cannot appear in a locality spec.
8901 : Use d->code (the DO CONCURRENT node) rather than sym->ns->code,
8902 : which may be a different code type (e.g. EXEC_ASSOCIATE) whose
8903 : ext union would be read incorrectly. */
8904 8 : for (gfc_forall_iterator *iter = d->code->ext.concur.forall_iterator;
8905 17 : iter; iter = iter->next)
8906 : {
8907 10 : if (!iter->var || !iter->var->symtree)
8908 0 : continue;
8909 10 : const char *iter_name = iter->var->symtree->name;
8910 : /* Use the user-visible name of a shadow iterator. */
8911 10 : if (iter->shadow)
8912 0 : iter_name = iter->shadow_outer_sym->name;
8913 10 : if (strcmp (sym->name, iter_name) == 0)
8914 1 : return 0;
8915 : }
8916 :
8917 : /* A named constant is not a variable, so skip test. */
8918 7 : if (ns2 != NULL && sym->attr.flavor != FL_PARAMETER)
8919 : {
8920 2 : gfc_error ("Variable %qs at %L not specified in a locality spec "
8921 : "of DO CONCURRENT at %L but required due to "
8922 : "DEFAULT (NONE)",
8923 : sym->name, &(*e)->where, &d->code->loc);
8924 2 : d->sym_hash->add (sym);
8925 : }
8926 : }
8927 : }
8928 : return 0;
8929 : }
8930 :
8931 : static void
8932 352 : resolve_locality_spec (gfc_code *code, gfc_namespace *ns)
8933 : {
8934 352 : struct check_default_none_data data;
8935 352 : data.code = code;
8936 352 : data.sym_hash = new hash_set<gfc_symbol *>;
8937 352 : data.ns = ns;
8938 352 : data.default_none = code->ext.concur.default_none;
8939 :
8940 1760 : for (int locality = 0; locality < LOCALITY_NUM; locality++)
8941 : {
8942 1408 : const char *name;
8943 1408 : switch (locality)
8944 : {
8945 : case LOCALITY_LOCAL: name = "LOCAL"; break;
8946 352 : case LOCALITY_LOCAL_INIT: name = "LOCAL_INIT"; break;
8947 352 : case LOCALITY_SHARED: name = "SHARED"; break;
8948 352 : case LOCALITY_REDUCE: name = "REDUCE"; break;
8949 : default: gcc_unreachable ();
8950 : }
8951 :
8952 1947 : for (gfc_expr_list *list = code->ext.concur.locality[locality]; list;
8953 539 : list = list->next)
8954 : {
8955 539 : gfc_expr *expr = list->expr;
8956 :
8957 539 : if (locality == LOCALITY_REDUCE
8958 294 : && (expr->expr_type == EXPR_FUNCTION
8959 196 : || expr->expr_type == EXPR_OP))
8960 109 : continue;
8961 :
8962 441 : if (!gfc_resolve_expr (expr))
8963 3 : continue;
8964 :
8965 438 : if (expr->expr_type != EXPR_VARIABLE
8966 438 : || expr->symtree->n.sym->attr.flavor != FL_VARIABLE
8967 438 : || (expr->ref
8968 151 : && (expr->ref->type != REF_ARRAY
8969 151 : || expr->ref->u.ar.type != AR_FULL
8970 147 : || expr->ref->next)))
8971 : {
8972 4 : gfc_error ("Expected variable name in %s locality spec at %L",
8973 : name, &expr->where);
8974 4 : continue;
8975 : }
8976 :
8977 434 : gfc_symbol *sym = expr->symtree->n.sym;
8978 :
8979 434 : if (data.sym_hash->contains (sym))
8980 : {
8981 4 : gfc_error ("Variable %qs at %L has already been specified in a "
8982 : "locality-spec", sym->name, &expr->where);
8983 4 : continue;
8984 : }
8985 :
8986 430 : for (gfc_forall_iterator *iter = code->ext.concur.forall_iterator;
8987 864 : iter; iter = iter->next)
8988 : {
8989 434 : if (iter->var->symtree->n.sym == sym)
8990 : {
8991 1 : gfc_error ("Index variable %qs at %L cannot be specified in a "
8992 : "locality-spec", sym->name, &expr->where);
8993 1 : continue;
8994 : }
8995 :
8996 433 : data.sym_hash->add (iter->var->symtree->n.sym);
8997 : }
8998 :
8999 430 : if (locality == LOCALITY_LOCAL
9000 430 : || locality == LOCALITY_LOCAL_INIT
9001 430 : || locality == LOCALITY_REDUCE)
9002 : {
9003 272 : if (sym->attr.optional)
9004 3 : gfc_error ("OPTIONAL attribute not permitted for %qs in %s "
9005 : "locality-spec at %L",
9006 : sym->name, name, &expr->where);
9007 :
9008 272 : if (sym->attr.dimension
9009 66 : && sym->as
9010 66 : && sym->as->type == AS_ASSUMED_SIZE)
9011 0 : gfc_error ("Assumed-size array not permitted for %qs in %s "
9012 : "locality-spec at %L",
9013 : sym->name, name, &expr->where);
9014 :
9015 272 : gfc_check_vardef_context (expr, false, false, false, name);
9016 : }
9017 :
9018 272 : if (locality == LOCALITY_LOCAL
9019 : || locality == LOCALITY_LOCAL_INIT)
9020 : {
9021 181 : symbol_attribute attr = gfc_expr_attr (expr);
9022 :
9023 181 : if (attr.allocatable)
9024 2 : gfc_error ("ALLOCATABLE attribute not permitted for %qs in %s "
9025 : "locality-spec at %L",
9026 : sym->name, name, &expr->where);
9027 :
9028 179 : else if (expr->ts.type == BT_CLASS && attr.dummy && !attr.pointer)
9029 2 : gfc_error ("Nonpointer polymorphic dummy argument not permitted"
9030 : " for %qs in %s locality-spec at %L",
9031 : sym->name, name, &expr->where);
9032 :
9033 177 : else if (attr.codimension)
9034 0 : gfc_error ("Coarray not permitted for %qs in %s locality-spec "
9035 : "at %L",
9036 : sym->name, name, &expr->where);
9037 :
9038 177 : else if (expr->ts.type == BT_DERIVED
9039 177 : && gfc_is_finalizable (expr->ts.u.derived, NULL))
9040 0 : gfc_error ("Finalizable type not permitted for %qs in %s "
9041 : "locality-spec at %L",
9042 : sym->name, name, &expr->where);
9043 :
9044 177 : else if (gfc_has_ultimate_allocatable (expr))
9045 4 : gfc_error ("Type with ultimate allocatable component not "
9046 : "permitted for %qs in %s locality-spec at %L",
9047 : sym->name, name, &expr->where);
9048 : }
9049 :
9050 249 : else if (locality == LOCALITY_REDUCE)
9051 : {
9052 91 : if (sym->attr.asynchronous)
9053 1 : gfc_error ("ASYNCHRONOUS attribute not permitted for %qs in "
9054 : "REDUCE locality-spec at %L",
9055 : sym->name, &expr->where);
9056 91 : if (sym->attr.volatile_)
9057 1 : gfc_error ("VOLATILE attribute not permitted for %qs in REDUCE "
9058 : "locality-spec at %L", sym->name, &expr->where);
9059 : }
9060 :
9061 430 : data.sym_hash->add (sym);
9062 : }
9063 :
9064 1408 : if (locality == LOCALITY_LOCAL)
9065 : {
9066 352 : gcc_assert (locality == 0);
9067 :
9068 352 : for (gfc_forall_iterator *iter = code->ext.concur.forall_iterator;
9069 723 : iter; iter = iter->next)
9070 : {
9071 371 : gfc_expr_walker (&iter->start,
9072 : do_concur_locality_specs_f2023,
9073 : &data);
9074 :
9075 371 : gfc_expr_walker (&iter->end,
9076 : do_concur_locality_specs_f2023,
9077 : &data);
9078 :
9079 371 : gfc_expr_walker (&iter->stride,
9080 : do_concur_locality_specs_f2023,
9081 : &data);
9082 : }
9083 :
9084 352 : if (code->expr1)
9085 7 : gfc_expr_walker (&code->expr1,
9086 : do_concur_locality_specs_f2023,
9087 : &data);
9088 : }
9089 : }
9090 :
9091 352 : gfc_expr *reduce_op = NULL;
9092 :
9093 352 : for (gfc_expr_list *list = code->ext.concur.locality[LOCALITY_REDUCE];
9094 548 : list; list = list->next)
9095 : {
9096 196 : gfc_expr *expr = list->expr;
9097 :
9098 196 : if (expr->expr_type != EXPR_VARIABLE)
9099 : {
9100 98 : reduce_op = expr;
9101 98 : continue;
9102 : }
9103 :
9104 98 : if (reduce_op->expr_type == EXPR_OP)
9105 : {
9106 91 : switch (reduce_op->value.op.op)
9107 : {
9108 91 : case INTRINSIC_PLUS:
9109 91 : case INTRINSIC_TIMES:
9110 91 : if (!gfc_numeric_ts (&expr->ts))
9111 3 : gfc_error ("Expected numeric type for %qs in REDUCE at %L, "
9112 3 : "got %s", expr->symtree->n.sym->name,
9113 : &expr->where, gfc_basic_typename (expr->ts.type));
9114 : break;
9115 0 : case INTRINSIC_AND:
9116 0 : case INTRINSIC_OR:
9117 0 : case INTRINSIC_EQV:
9118 0 : case INTRINSIC_NEQV:
9119 0 : if (expr->ts.type != BT_LOGICAL)
9120 0 : gfc_error ("Expected logical type for %qs in REDUCE at %L, "
9121 0 : "got %qs", expr->symtree->n.sym->name,
9122 : &expr->where, gfc_basic_typename (expr->ts.type));
9123 : break;
9124 0 : default:
9125 0 : gcc_unreachable ();
9126 : }
9127 : }
9128 :
9129 7 : else if (reduce_op->expr_type == EXPR_FUNCTION)
9130 : {
9131 7 : switch (reduce_op->value.function.isym->id)
9132 : {
9133 6 : case GFC_ISYM_MIN:
9134 6 : case GFC_ISYM_MAX:
9135 6 : if (expr->ts.type != BT_INTEGER
9136 : && expr->ts.type != BT_REAL
9137 : && expr->ts.type != BT_CHARACTER)
9138 2 : gfc_error ("Expected INTEGER, REAL or CHARACTER type for %qs "
9139 : "in REDUCE with MIN/MAX at %L, got %s",
9140 2 : expr->symtree->n.sym->name, &expr->where,
9141 : gfc_basic_typename (expr->ts.type));
9142 : break;
9143 1 : case GFC_ISYM_IAND:
9144 1 : case GFC_ISYM_IOR:
9145 1 : case GFC_ISYM_IEOR:
9146 1 : if (expr->ts.type != BT_INTEGER)
9147 1 : gfc_error ("Expected integer type for %qs in REDUCE with "
9148 : "IAND/IOR/IEOR at %L, got %s",
9149 1 : expr->symtree->n.sym->name, &expr->where,
9150 : gfc_basic_typename (expr->ts.type));
9151 : break;
9152 0 : default:
9153 0 : gcc_unreachable ();
9154 : }
9155 : }
9156 :
9157 : else
9158 0 : gcc_unreachable ();
9159 : }
9160 :
9161 1760 : for (int locality = 0; locality < LOCALITY_NUM; locality++)
9162 : {
9163 1947 : for (gfc_expr_list *list = code->ext.concur.locality[locality]; list;
9164 539 : list = list->next)
9165 : {
9166 539 : if (list->expr->expr_type == EXPR_VARIABLE)
9167 441 : list->expr->symtree->n.sym->mark = 0;
9168 : }
9169 : }
9170 :
9171 352 : gfc_code_walker (&code->block->next, gfc_dummy_code_callback,
9172 : check_default_none_expr, &data);
9173 :
9174 2112 : for (int locality = 0; locality < LOCALITY_NUM; locality++)
9175 : {
9176 1408 : gfc_expr_list **plist = &code->ext.concur.locality[locality];
9177 1947 : while (*plist)
9178 : {
9179 539 : gfc_expr *expr = (*plist)->expr;
9180 539 : if (expr->expr_type == EXPR_VARIABLE)
9181 : {
9182 441 : gfc_symbol *sym = expr->symtree->n.sym;
9183 441 : if (sym->mark == 0)
9184 : {
9185 70 : gfc_warning (OPT_Wunused_variable, "Variable %qs in "
9186 : "locality-spec at %L is not used",
9187 : sym->name, &expr->where);
9188 70 : gfc_expr_list *tmp = *plist;
9189 70 : *plist = (*plist)->next;
9190 70 : gfc_free_expr (tmp->expr);
9191 70 : free (tmp);
9192 70 : continue;
9193 70 : }
9194 : }
9195 469 : plist = &((*plist)->next);
9196 : }
9197 : }
9198 :
9199 704 : delete data.sym_hash;
9200 352 : }
9201 :
9202 : /* Resolve a list of FORALL iterators. The FORALL index-name is constrained
9203 : to be a scalar INTEGER variable. The subscripts and stride are scalar
9204 : INTEGERs, and if stride is a constant it must be nonzero.
9205 : Furthermore "A subscript or stride in a forall-triplet-spec shall
9206 : not contain a reference to any index-name in the
9207 : forall-triplet-spec-list in which it appears." (7.5.4.1) */
9208 :
9209 : static void
9210 2345 : resolve_forall_iterators (gfc_forall_iterator *it)
9211 : {
9212 2345 : gfc_forall_iterator *iter, *iter2;
9213 :
9214 6608 : for (iter = it; iter; iter = iter->next)
9215 : {
9216 4263 : if (gfc_resolve_expr (iter->var)
9217 4263 : && (iter->var->ts.type != BT_INTEGER || iter->var->rank != 0))
9218 0 : gfc_error ("FORALL index-name at %L must be a scalar INTEGER",
9219 : &iter->var->where);
9220 :
9221 4263 : if (gfc_resolve_expr (iter->start)
9222 4263 : && (iter->start->ts.type != BT_INTEGER || iter->start->rank != 0))
9223 0 : gfc_error ("FORALL start expression at %L must be a scalar INTEGER",
9224 : &iter->start->where);
9225 4263 : if (iter->var->ts.kind != iter->start->ts.kind)
9226 1 : gfc_convert_type (iter->start, &iter->var->ts, 1);
9227 :
9228 4263 : if (gfc_resolve_expr (iter->end)
9229 4263 : && (iter->end->ts.type != BT_INTEGER || iter->end->rank != 0))
9230 0 : gfc_error ("FORALL end expression at %L must be a scalar INTEGER",
9231 : &iter->end->where);
9232 4263 : if (iter->var->ts.kind != iter->end->ts.kind)
9233 2 : gfc_convert_type (iter->end, &iter->var->ts, 1);
9234 :
9235 4263 : if (gfc_resolve_expr (iter->stride))
9236 : {
9237 4263 : if (iter->stride->ts.type != BT_INTEGER || iter->stride->rank != 0)
9238 0 : gfc_error ("FORALL stride expression at %L must be a scalar %s",
9239 : &iter->stride->where, "INTEGER");
9240 :
9241 4263 : if (iter->stride->expr_type == EXPR_CONSTANT
9242 4259 : && mpz_cmp_ui (iter->stride->value.integer, 0) == 0)
9243 1 : gfc_error ("FORALL stride expression at %L cannot be zero",
9244 : &iter->stride->where);
9245 : }
9246 4263 : if (iter->var->ts.kind != iter->stride->ts.kind)
9247 1 : gfc_convert_type (iter->stride, &iter->var->ts, 1);
9248 :
9249 4263 : gfc_value_set_and_used (iter->var, &iter->var->where, VALUE_VARDEF,
9250 : VALUE_USED);
9251 4263 : gfc_value_used_expr (iter->start, VALUE_USED);
9252 4263 : gfc_value_used_expr (iter->end, VALUE_USED);
9253 4263 : gfc_value_used_expr (iter->stride, VALUE_USED);
9254 : }
9255 :
9256 6608 : for (iter = it; iter; iter = iter->next)
9257 11370 : for (iter2 = iter; iter2; iter2 = iter2->next)
9258 : {
9259 7107 : if (find_forall_index (iter2->start, iter->var->symtree->n.sym, 0)
9260 7105 : || find_forall_index (iter2->end, iter->var->symtree->n.sym, 0)
9261 14210 : || find_forall_index (iter2->stride, iter->var->symtree->n.sym, 0))
9262 6 : gfc_error ("FORALL index %qs may not appear in triplet "
9263 6 : "specification at %L", iter->var->symtree->name,
9264 6 : &iter2->start->where);
9265 : }
9266 2345 : }
9267 :
9268 :
9269 : /* Given a pointer to a symbol that is a derived type, see if it's
9270 : inaccessible, i.e. if it's defined in another module and the components are
9271 : PRIVATE. The search is recursive if necessary. Returns zero if no
9272 : inaccessible components are found, nonzero otherwise. */
9273 :
9274 : static bool
9275 1364 : derived_inaccessible (gfc_symbol *sym)
9276 : {
9277 1364 : gfc_component *c;
9278 :
9279 1364 : if (sym->attr.use_assoc && sym->attr.private_comp)
9280 : return 1;
9281 :
9282 4031 : for (c = sym->components; c; c = c->next)
9283 : {
9284 : /* Prevent an infinite loop through this function. */
9285 2680 : if (c->ts.type == BT_DERIVED
9286 289 : && (c->attr.pointer || c->attr.allocatable)
9287 72 : && sym == c->ts.u.derived)
9288 72 : continue;
9289 :
9290 2608 : if (c->ts.type == BT_DERIVED && derived_inaccessible (c->ts.u.derived))
9291 : return 1;
9292 : }
9293 :
9294 : return 0;
9295 : }
9296 :
9297 :
9298 : /* Resolve the argument of a deallocate expression. The expression must be
9299 : a pointer or a full array. */
9300 :
9301 : static bool
9302 8698 : resolve_deallocate_expr (gfc_expr *e)
9303 : {
9304 8698 : symbol_attribute attr;
9305 8698 : int allocatable, pointer;
9306 8698 : gfc_ref *ref;
9307 8698 : gfc_symbol *sym;
9308 8698 : gfc_component *c;
9309 8698 : bool unlimited;
9310 :
9311 8698 : if (!gfc_resolve_expr (e))
9312 : return false;
9313 :
9314 8698 : if (e->expr_type != EXPR_VARIABLE)
9315 0 : goto bad;
9316 :
9317 8698 : sym = e->symtree->n.sym;
9318 8698 : unlimited = UNLIMITED_POLY(sym);
9319 :
9320 8698 : if (sym->ts.type == BT_CLASS && sym->attr.class_ok && CLASS_DATA (sym))
9321 : {
9322 1659 : allocatable = CLASS_DATA (sym)->attr.allocatable;
9323 1659 : pointer = CLASS_DATA (sym)->attr.class_pointer;
9324 : }
9325 : else
9326 : {
9327 7039 : allocatable = sym->attr.allocatable;
9328 7039 : pointer = sym->attr.pointer;
9329 : }
9330 17360 : for (ref = e->ref; ref; ref = ref->next)
9331 : {
9332 8662 : switch (ref->type)
9333 : {
9334 6477 : case REF_ARRAY:
9335 6477 : if (ref->u.ar.type != AR_FULL
9336 6735 : && !(ref->u.ar.type == AR_ELEMENT && ref->u.ar.as->rank == 0
9337 258 : && ref->u.ar.codimen && gfc_ref_this_image (ref)))
9338 : allocatable = 0;
9339 : break;
9340 :
9341 2185 : case REF_COMPONENT:
9342 2185 : c = ref->u.c.component;
9343 2185 : if (c->ts.type == BT_CLASS)
9344 : {
9345 303 : allocatable = CLASS_DATA (c)->attr.allocatable;
9346 303 : pointer = CLASS_DATA (c)->attr.class_pointer;
9347 : }
9348 : else
9349 : {
9350 1882 : allocatable = c->attr.allocatable;
9351 1882 : pointer = c->attr.pointer;
9352 : }
9353 : break;
9354 :
9355 : case REF_SUBSTRING:
9356 : case REF_INQUIRY:
9357 8662 : allocatable = 0;
9358 : break;
9359 : }
9360 : }
9361 :
9362 8698 : attr = gfc_expr_attr (e);
9363 :
9364 8698 : if (allocatable == 0 && attr.pointer == 0 && !unlimited)
9365 : {
9366 3 : bad:
9367 3 : gfc_error ("Allocate-object at %L must be ALLOCATABLE or a POINTER",
9368 : &e->where);
9369 3 : return false;
9370 : }
9371 :
9372 : /* F2008, C644. */
9373 8695 : if (gfc_is_coindexed (e))
9374 : {
9375 1 : gfc_error ("Coindexed allocatable object at %L", &e->where);
9376 1 : return false;
9377 : }
9378 :
9379 8694 : if (pointer
9380 11098 : && !gfc_check_vardef_context (e, true, true, false,
9381 2404 : _("DEALLOCATE object")))
9382 : return false;
9383 8692 : if (!gfc_check_vardef_context (e, false, true, false,
9384 8692 : _("DEALLOCATE object")))
9385 : return false;
9386 :
9387 : return true;
9388 : }
9389 :
9390 :
9391 : /* Returns true if the expression e contains a reference to the symbol sym. */
9392 : static bool
9393 47489 : sym_in_expr (gfc_expr *e, gfc_symbol *sym, int *f ATTRIBUTE_UNUSED)
9394 : {
9395 47489 : if (e->expr_type == EXPR_VARIABLE && e->symtree->n.sym == sym)
9396 2081 : return true;
9397 :
9398 : return false;
9399 : }
9400 :
9401 : bool
9402 20080 : gfc_find_sym_in_expr (gfc_symbol *sym, gfc_expr *e)
9403 : {
9404 20080 : return gfc_traverse_expr (e, sym, sym_in_expr, 0);
9405 : }
9406 :
9407 : /* Same as gfc_find_sym_in_expr, but do not descend into length type parameter
9408 : of character expressions. */
9409 : static bool
9410 20585 : gfc_find_var_in_expr (gfc_symbol *sym, gfc_expr *e)
9411 : {
9412 0 : return gfc_traverse_expr (e, sym, sym_in_expr, -1);
9413 : }
9414 :
9415 :
9416 : /* Given the expression node e for an allocatable/pointer of derived type to be
9417 : allocated, get the expression node to be initialized afterwards (needed for
9418 : derived types with default initializers, and derived types with allocatable
9419 : components that need nullification.) */
9420 :
9421 : gfc_expr *
9422 6147 : gfc_expr_to_initialize (gfc_expr *e)
9423 : {
9424 6147 : gfc_expr *result;
9425 6147 : gfc_ref *ref;
9426 6147 : int i;
9427 :
9428 6147 : result = gfc_copy_expr (e);
9429 :
9430 : /* Change the last array reference from AR_ELEMENT to AR_FULL. */
9431 12417 : for (ref = result->ref; ref; ref = ref->next)
9432 9775 : if (ref->type == REF_ARRAY && ref->next == NULL)
9433 : {
9434 3505 : if (ref->u.ar.dimen == 0
9435 89 : && ref->u.ar.as && ref->u.ar.as->corank)
9436 : return result;
9437 :
9438 3416 : ref->u.ar.type = AR_FULL;
9439 :
9440 7690 : for (i = 0; i < ref->u.ar.dimen; i++)
9441 4274 : ref->u.ar.start[i] = ref->u.ar.end[i] = ref->u.ar.stride[i] = NULL;
9442 :
9443 : break;
9444 : }
9445 :
9446 6058 : gfc_free_shape (&result->shape, result->rank);
9447 :
9448 : /* Recalculate rank, shape, etc. */
9449 6058 : gfc_resolve_expr (result);
9450 6058 : return result;
9451 : }
9452 :
9453 :
9454 : /* If the last ref of an expression is an array ref, return a copy of the
9455 : expression with that one removed. Otherwise, a copy of the original
9456 : expression. This is used for allocate-expressions and pointer assignment
9457 : LHS, where there may be an array specification that needs to be stripped
9458 : off when using gfc_check_vardef_context. */
9459 :
9460 : static gfc_expr*
9461 28850 : remove_last_array_ref (gfc_expr* e)
9462 : {
9463 28850 : gfc_expr* e2;
9464 28850 : gfc_ref** r;
9465 :
9466 28850 : e2 = gfc_copy_expr (e);
9467 37517 : for (r = &e2->ref; *r; r = &(*r)->next)
9468 25759 : if ((*r)->type == REF_ARRAY && !(*r)->next)
9469 : {
9470 17092 : gfc_free_ref_list (*r);
9471 17092 : *r = NULL;
9472 17092 : break;
9473 : }
9474 :
9475 28850 : return e2;
9476 : }
9477 :
9478 :
9479 : /* Used in resolve_allocate_expr to check that a allocation-object and
9480 : a source-expr are conformable. This does not catch all possible
9481 : cases; in particular a runtime checking is needed. */
9482 :
9483 : static bool
9484 1976 : conformable_arrays (gfc_expr *e1, gfc_expr *e2)
9485 : {
9486 1976 : gfc_ref *tail;
9487 1976 : bool scalar;
9488 :
9489 2798 : for (tail = e2->ref; tail && tail->next; tail = tail->next);
9490 :
9491 : /* If MOLD= is present and is not scalar, and the allocate-object has an
9492 : explicit-shape-spec, the ranks need not agree. This may be unintended,
9493 : so let's emit a warning if -Wsurprising is given. */
9494 1976 : scalar = !tail || tail->type == REF_COMPONENT;
9495 1976 : if (e1->mold && e1->rank > 0
9496 166 : && (scalar || (tail->type == REF_ARRAY && tail->u.ar.type != AR_FULL)))
9497 : {
9498 27 : if (scalar || (tail->u.ar.as && e1->rank != tail->u.ar.as->rank))
9499 15 : gfc_warning (OPT_Wsurprising, "Allocate-object at %L has rank %d "
9500 : "but MOLD= expression at %L has rank %d",
9501 6 : &e2->where, scalar ? 0 : tail->u.ar.as->rank,
9502 : &e1->where, e1->rank);
9503 : return true;
9504 : }
9505 :
9506 : /* First compare rank. */
9507 1946 : if ((tail && (!tail->u.ar.as || e1->rank != tail->u.ar.as->rank))
9508 2 : || (!tail && e1->rank != e2->rank))
9509 : {
9510 7 : gfc_error ("Source-expr at %L must be scalar or have the "
9511 : "same rank as the allocate-object at %L",
9512 : &e1->where, &e2->where);
9513 7 : return false;
9514 : }
9515 :
9516 1939 : if (e1->shape)
9517 : {
9518 1415 : int i;
9519 1415 : mpz_t s;
9520 :
9521 1415 : mpz_init (s);
9522 :
9523 3273 : for (i = 0; i < e1->rank; i++)
9524 : {
9525 1421 : if (tail->u.ar.start[i] == NULL)
9526 : break;
9527 :
9528 443 : if (tail->u.ar.end[i])
9529 : {
9530 54 : mpz_set (s, tail->u.ar.end[i]->value.integer);
9531 54 : mpz_sub (s, s, tail->u.ar.start[i]->value.integer);
9532 54 : mpz_add_ui (s, s, 1);
9533 : }
9534 : else
9535 : {
9536 389 : mpz_set (s, tail->u.ar.start[i]->value.integer);
9537 : }
9538 :
9539 443 : if (mpz_cmp (e1->shape[i], s) != 0)
9540 : {
9541 0 : gfc_error ("Source-expr at %L and allocate-object at %L must "
9542 : "have the same shape", &e1->where, &e2->where);
9543 0 : mpz_clear (s);
9544 0 : return false;
9545 : }
9546 : }
9547 :
9548 1415 : mpz_clear (s);
9549 : }
9550 :
9551 : return true;
9552 : }
9553 :
9554 :
9555 : /* Resolve the expression in an ALLOCATE statement, doing the additional
9556 : checks to see whether the expression is OK or not. The expression must
9557 : have a trailing array reference that gives the size of the array. */
9558 :
9559 : static bool
9560 18144 : resolve_allocate_expr (gfc_expr *e, gfc_code *code, bool *array_alloc_wo_spec)
9561 : {
9562 18144 : int i, pointer, allocatable, dimension, is_abstract;
9563 18144 : int codimension;
9564 18144 : bool coindexed;
9565 18144 : bool unlimited;
9566 18144 : symbol_attribute attr;
9567 18144 : gfc_ref *ref, *ref2;
9568 18144 : gfc_expr *e2;
9569 18144 : gfc_array_ref *ar;
9570 18144 : gfc_symbol *sym = NULL;
9571 18144 : gfc_alloc *a;
9572 18144 : gfc_component *c;
9573 18144 : bool t;
9574 :
9575 : /* Mark the utmost array component as being in allocate to allow DIMEN_STAR
9576 : checking of coarrays. */
9577 23392 : for (ref = e->ref; ref; ref = ref->next)
9578 18930 : if (ref->next == NULL)
9579 : break;
9580 :
9581 18144 : if (ref && ref->type == REF_ARRAY)
9582 12457 : ref->u.ar.in_allocate = true;
9583 :
9584 18144 : if (!gfc_resolve_expr (e))
9585 1 : goto failure;
9586 :
9587 : /* Make sure the expression is allocatable or a pointer. If it is
9588 : pointer, the next-to-last reference must be a pointer. */
9589 :
9590 18143 : ref2 = NULL;
9591 18143 : if (e->symtree)
9592 18143 : sym = e->symtree->n.sym;
9593 :
9594 : /* Check whether ultimate component is abstract and CLASS. */
9595 36286 : is_abstract = 0;
9596 :
9597 : /* Is the allocate-object unlimited polymorphic? */
9598 18143 : unlimited = UNLIMITED_POLY(e);
9599 :
9600 18143 : if (e->expr_type != EXPR_VARIABLE)
9601 : {
9602 0 : allocatable = 0;
9603 0 : attr = gfc_expr_attr (e);
9604 0 : pointer = attr.pointer;
9605 0 : dimension = attr.dimension;
9606 0 : codimension = attr.codimension;
9607 : }
9608 : else
9609 : {
9610 18143 : if (sym->ts.type == BT_CLASS && CLASS_DATA (sym))
9611 : {
9612 3703 : allocatable = CLASS_DATA (sym)->attr.allocatable;
9613 3703 : pointer = CLASS_DATA (sym)->attr.class_pointer;
9614 3703 : dimension = CLASS_DATA (sym)->attr.dimension;
9615 3703 : codimension = CLASS_DATA (sym)->attr.codimension;
9616 3703 : is_abstract = CLASS_DATA (sym)->attr.abstract;
9617 : }
9618 : else
9619 : {
9620 14440 : allocatable = sym->attr.allocatable;
9621 14440 : pointer = sym->attr.pointer;
9622 14440 : dimension = sym->attr.dimension;
9623 14440 : codimension = sym->attr.codimension;
9624 : }
9625 :
9626 18143 : coindexed = false;
9627 :
9628 37067 : for (ref = e->ref; ref; ref2 = ref, ref = ref->next)
9629 : {
9630 18926 : switch (ref->type)
9631 : {
9632 14090 : case REF_ARRAY:
9633 14090 : if (ref->u.ar.codimen > 0)
9634 : {
9635 866 : int n;
9636 1173 : for (n = ref->u.ar.dimen;
9637 1173 : n < ref->u.ar.dimen + ref->u.ar.codimen; n++)
9638 907 : if (ref->u.ar.dimen_type[n] != DIMEN_THIS_IMAGE)
9639 : {
9640 : coindexed = true;
9641 : break;
9642 : }
9643 : }
9644 :
9645 14090 : if (ref->next != NULL)
9646 1635 : pointer = 0;
9647 : break;
9648 :
9649 4836 : case REF_COMPONENT:
9650 : /* F2008, C644. */
9651 4836 : if (coindexed)
9652 : {
9653 2 : gfc_error ("Coindexed allocatable object at %L",
9654 : &e->where);
9655 2 : goto failure;
9656 : }
9657 :
9658 4834 : c = ref->u.c.component;
9659 4834 : if (c->ts.type == BT_CLASS)
9660 : {
9661 1084 : allocatable = CLASS_DATA (c)->attr.allocatable;
9662 1084 : pointer = CLASS_DATA (c)->attr.class_pointer;
9663 1084 : dimension = CLASS_DATA (c)->attr.dimension;
9664 1084 : codimension = CLASS_DATA (c)->attr.codimension;
9665 1084 : is_abstract = CLASS_DATA (c)->attr.abstract;
9666 : }
9667 : else
9668 : {
9669 3750 : allocatable = c->attr.allocatable;
9670 3750 : pointer = c->attr.pointer;
9671 3750 : dimension = c->attr.dimension;
9672 3750 : codimension = c->attr.codimension;
9673 3750 : is_abstract = c->attr.abstract;
9674 : }
9675 : break;
9676 :
9677 0 : case REF_SUBSTRING:
9678 0 : case REF_INQUIRY:
9679 0 : allocatable = 0;
9680 0 : pointer = 0;
9681 0 : break;
9682 : }
9683 : }
9684 : }
9685 :
9686 : /* Check for F08:C628 (F2018:C932). Each allocate-object shall be a data
9687 : pointer or an allocatable variable. */
9688 18141 : if (allocatable == 0 && pointer == 0)
9689 : {
9690 4 : gfc_error ("Allocate-object at %L must be ALLOCATABLE or a POINTER",
9691 : &e->where);
9692 4 : goto failure;
9693 : }
9694 :
9695 : /* Some checks for the SOURCE tag. */
9696 18137 : if (code->expr3)
9697 : {
9698 : /* Check F03:C632: "The source-expr shall be a scalar or have the same
9699 : rank as allocate-object". This would require the MOLD argument to
9700 : NULL() as source-expr for subsequent checking. However, even the
9701 : resulting disassociated pointer or unallocated array has no shape that
9702 : could be used for SOURCE= or MOLD=. */
9703 4050 : if (code->expr3->expr_type == EXPR_NULL)
9704 : {
9705 4 : gfc_error ("The intrinsic NULL cannot be used as source-expr at %L",
9706 : &code->expr3->where);
9707 4 : goto failure;
9708 : }
9709 :
9710 : /* Check F03:C631. */
9711 4046 : if (!gfc_type_compatible (&e->ts, &code->expr3->ts))
9712 : {
9713 10 : gfc_error ("Type of entity at %L is type incompatible with "
9714 10 : "source-expr at %L", &e->where, &code->expr3->where);
9715 10 : goto failure;
9716 : }
9717 :
9718 : /* Check F03:C632 and restriction following Note 6.18. */
9719 4036 : if (code->expr3->rank > 0 && !conformable_arrays (code->expr3, e))
9720 7 : goto failure;
9721 :
9722 : /* Check F03:C633. */
9723 4029 : if (code->expr3->ts.kind != e->ts.kind && !unlimited)
9724 : {
9725 1 : gfc_error ("The allocate-object at %L and the source-expr at %L "
9726 : "shall have the same kind type parameter",
9727 : &e->where, &code->expr3->where);
9728 1 : goto failure;
9729 : }
9730 :
9731 : /* Check F2008, C642. */
9732 4028 : if (code->expr3->ts.type == BT_DERIVED
9733 4028 : && ((codimension && gfc_expr_attr (code->expr3).lock_comp)
9734 1288 : || (code->expr3->ts.u.derived->from_intmod
9735 : == INTMOD_ISO_FORTRAN_ENV
9736 0 : && code->expr3->ts.u.derived->intmod_sym_id
9737 : == ISOFORTRAN_LOCK_TYPE)))
9738 : {
9739 0 : gfc_error ("The source-expr at %L shall neither be of type "
9740 : "LOCK_TYPE nor have a LOCK_TYPE component if "
9741 : "allocate-object at %L is a coarray",
9742 0 : &code->expr3->where, &e->where);
9743 0 : goto failure;
9744 : }
9745 :
9746 : /* Check F2008:C639: "Corresponding kind type parameters of
9747 : allocate-object and source-expr shall have the same values." */
9748 4028 : if (e->ts.type == BT_CHARACTER
9749 822 : && !e->ts.deferred
9750 162 : && e->ts.u.cl->length
9751 162 : && code->expr3->ts.type == BT_CHARACTER
9752 4190 : && !gfc_check_same_strlen (e, code->expr3, "ALLOCATE with "
9753 : "SOURCE= or MOLD= specifier"))
9754 17 : goto failure;
9755 :
9756 : /* Check TS18508, C702/C703. */
9757 4011 : if (code->expr3->ts.type == BT_DERIVED
9758 5299 : && ((codimension && gfc_expr_attr (code->expr3).event_comp)
9759 1288 : || (code->expr3->ts.u.derived->from_intmod
9760 : == INTMOD_ISO_FORTRAN_ENV
9761 0 : && code->expr3->ts.u.derived->intmod_sym_id
9762 : == ISOFORTRAN_EVENT_TYPE)))
9763 : {
9764 0 : gfc_error ("The source-expr at %L shall neither be of type "
9765 : "EVENT_TYPE nor have a EVENT_TYPE component if "
9766 : "allocate-object at %L is a coarray",
9767 0 : &code->expr3->where, &e->where);
9768 0 : goto failure;
9769 : }
9770 : }
9771 :
9772 : /* Check F08:C629. */
9773 18098 : if (is_abstract && code->ext.alloc.ts.type == BT_UNKNOWN
9774 159 : && !code->expr3)
9775 : {
9776 2 : gcc_assert (e->ts.type == BT_CLASS);
9777 2 : gfc_error ("Allocating %s of ABSTRACT base type at %L requires a "
9778 : "type-spec or source-expr", sym->name, &e->where);
9779 2 : goto failure;
9780 : }
9781 :
9782 : /* F2003:C626 (R623) A type-param-value in a type-spec shall be an asterisk
9783 : if and only if each allocate-object is a dummy argument for which the
9784 : corresponding type parameter is assumed. */
9785 18096 : if (code->ext.alloc.ts.type == BT_CHARACTER
9786 533 : && code->ext.alloc.ts.u.cl->length != NULL
9787 518 : && e->ts.type == BT_CHARACTER && !e->ts.deferred
9788 23 : && e->ts.u.cl->length == NULL
9789 2 : && e->symtree->n.sym->attr.dummy)
9790 : {
9791 2 : gfc_error ("The type parameter in ALLOCATE statement with type-spec "
9792 : "shall be an asterisk as allocate object %qs at %L is a "
9793 : "dummy argument with assumed type parameter",
9794 : sym->name, &e->where);
9795 2 : goto failure;
9796 : }
9797 :
9798 : /* Check F08:C632. */
9799 18094 : if (code->ext.alloc.ts.type == BT_CHARACTER && !e->ts.deferred
9800 60 : && !UNLIMITED_POLY (e))
9801 : {
9802 36 : int cmp = 0;
9803 :
9804 36 : if (!e->ts.u.cl->length)
9805 15 : goto failure;
9806 :
9807 42 : cmp = gfc_dep_compare_expr (e->ts.u.cl->length,
9808 21 : code->ext.alloc.ts.u.cl->length);
9809 21 : if (cmp == 1 || cmp == -1)
9810 : {
9811 2 : gfc_error ("Allocating %s at %L with type-spec requires the same "
9812 : "character-length parameter as in the declaration",
9813 : sym->name, &e->where);
9814 2 : goto failure;
9815 : }
9816 : }
9817 :
9818 : /* In the variable definition context checks, gfc_expr_attr is used
9819 : on the expression. This is fooled by the array specification
9820 : present in e, thus we have to eliminate that one temporarily. */
9821 18077 : e2 = remove_last_array_ref (e);
9822 18077 : t = true;
9823 18077 : if (t && pointer)
9824 3942 : t = gfc_check_vardef_context (e2, true, true, false,
9825 3942 : _("ALLOCATE object"));
9826 3942 : if (t)
9827 18069 : t = gfc_check_vardef_context (e2, false, true, false,
9828 18069 : _("ALLOCATE object"));
9829 18077 : gfc_free_expr (e2);
9830 18077 : if (!t)
9831 11 : goto failure;
9832 :
9833 18066 : code->ext.alloc.expr3_not_explicit = 0;
9834 18066 : if (e->ts.type == BT_CLASS && CLASS_DATA (e)->attr.dimension
9835 1770 : && !code->expr3 && code->ext.alloc.ts.type == BT_DERIVED)
9836 : {
9837 : /* For class arrays, the initialization with SOURCE is done
9838 : using _copy and trans_call. It is convenient to exploit that
9839 : when the allocated type is different from the declared type but
9840 : no SOURCE exists by setting expr3. */
9841 377 : code->expr3 = gfc_default_initializer (&code->ext.alloc.ts);
9842 377 : code->ext.alloc.expr3_not_explicit = 1;
9843 : }
9844 17689 : else if (flag_coarray != GFC_FCOARRAY_LIB && e->ts.type == BT_DERIVED
9845 2829 : && e->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
9846 6 : && e->ts.u.derived->intmod_sym_id == ISOFORTRAN_EVENT_TYPE)
9847 : {
9848 : /* We have to zero initialize the integer variable. */
9849 2 : code->expr3 = gfc_get_int_expr (gfc_default_integer_kind, &e->where, 0);
9850 2 : code->ext.alloc.expr3_not_explicit = 1;
9851 : }
9852 :
9853 18066 : if (e->ts.type == BT_CLASS && !unlimited && !UNLIMITED_POLY (code->expr3))
9854 : {
9855 : /* Make sure the vtab symbol is present when
9856 : the module variables are generated. */
9857 3219 : gfc_typespec ts = e->ts;
9858 3219 : if (code->expr3)
9859 1397 : ts = code->expr3->ts;
9860 1822 : else if (code->ext.alloc.ts.type == BT_DERIVED)
9861 798 : ts = code->ext.alloc.ts;
9862 :
9863 : /* Finding the vtab also publishes the type's symbol. Therefore this
9864 : statement is necessary. */
9865 3219 : gfc_find_derived_vtab (ts.u.derived);
9866 3219 : }
9867 14847 : else if (unlimited && !UNLIMITED_POLY (code->expr3))
9868 : {
9869 : /* Again, make sure the vtab symbol is present when
9870 : the module variables are generated. */
9871 488 : gfc_typespec *ts = NULL;
9872 488 : if (code->expr3)
9873 377 : ts = &code->expr3->ts;
9874 : else
9875 : {
9876 111 : ts = &code->ext.alloc.ts;
9877 111 : if (ts->type == BT_DERIVED && ts->u.derived->attr.pdt_type)
9878 : {
9879 24 : code->expr3 = gfc_default_initializer (ts);
9880 24 : code->expr3->mold = 1;
9881 24 : code->ext.alloc.expr3_not_explicit = 1;
9882 : }
9883 : }
9884 :
9885 377 : gcc_assert (ts);
9886 :
9887 : /* Finding the vtab also publishes the type's symbol. Therefore this
9888 : statement is necessary. */
9889 488 : gfc_find_vtab (ts);
9890 : }
9891 :
9892 18066 : if (dimension == 0 && codimension == 0)
9893 5640 : goto success;
9894 :
9895 : /* Make sure the last reference node is an array specification. */
9896 :
9897 12426 : if (!ref2 || ref2->type != REF_ARRAY || ref2->u.ar.type == AR_FULL
9898 11151 : || (dimension && ref2->u.ar.dimen == 0))
9899 : {
9900 : /* F08:C633. */
9901 1275 : if (code->expr3)
9902 : {
9903 1274 : if (!gfc_notify_std (GFC_STD_F2008, "Array specification required "
9904 : "in ALLOCATE statement at %L", &e->where))
9905 0 : goto failure;
9906 1274 : if (code->expr3->rank != 0)
9907 1273 : *array_alloc_wo_spec = true;
9908 : else
9909 : {
9910 1 : gfc_error ("Array specification or array-valued SOURCE= "
9911 : "expression required in ALLOCATE statement at %L",
9912 : &e->where);
9913 1 : goto failure;
9914 : }
9915 : }
9916 : else
9917 : {
9918 1 : gfc_error ("Array specification required in ALLOCATE statement "
9919 : "at %L", &e->where);
9920 1 : goto failure;
9921 : }
9922 : }
9923 :
9924 : /* Make sure that the array section reference makes sense in the
9925 : context of an ALLOCATE specification. */
9926 :
9927 12424 : ar = &ref2->u.ar;
9928 :
9929 12424 : if (codimension)
9930 1382 : for (i = ar->dimen; i < ar->dimen + ar->codimen; i++)
9931 : {
9932 795 : switch (ar->dimen_type[i])
9933 : {
9934 2 : case DIMEN_THIS_IMAGE:
9935 2 : gfc_error ("Coarray specification required in ALLOCATE statement "
9936 : "at %L", &e->where);
9937 2 : goto failure;
9938 :
9939 98 : case DIMEN_RANGE:
9940 : /* F2018:R937:
9941 : * allocate-coshape-spec is [ lower-bound-expr : ] upper-bound-expr
9942 : */
9943 98 : if (ar->start[i] == 0 || ar->end[i] == 0 || ar->stride[i] != NULL)
9944 : {
9945 8 : gfc_error ("Bad coarray specification in ALLOCATE statement "
9946 : "at %L", &e->where);
9947 8 : goto failure;
9948 : }
9949 90 : else if (gfc_dep_compare_expr (ar->start[i], ar->end[i]) == 1)
9950 : {
9951 2 : gfc_error ("Upper cobound is less than lower cobound at %L",
9952 2 : &ar->start[i]->where);
9953 2 : goto failure;
9954 : }
9955 : break;
9956 :
9957 108 : case DIMEN_ELEMENT:
9958 108 : if (ar->start[i]->expr_type == EXPR_CONSTANT)
9959 : {
9960 100 : gcc_assert (ar->start[i]->ts.type == BT_INTEGER);
9961 100 : if (mpz_cmp_si (ar->start[i]->value.integer, 1) < 0)
9962 : {
9963 1 : gfc_error ("Upper cobound is less than lower cobound "
9964 : "of 1 at %L", &ar->start[i]->where);
9965 1 : goto failure;
9966 : }
9967 : }
9968 : break;
9969 :
9970 : case DIMEN_STAR:
9971 : break;
9972 :
9973 0 : default:
9974 0 : gfc_error ("Bad array specification in ALLOCATE statement at %L",
9975 : &e->where);
9976 0 : goto failure;
9977 :
9978 : }
9979 : }
9980 30188 : for (i = 0; i < ar->dimen; i++)
9981 : {
9982 17781 : if (ar->type == AR_ELEMENT || ar->type == AR_FULL)
9983 15042 : goto check_symbols;
9984 :
9985 2739 : switch (ar->dimen_type[i])
9986 : {
9987 : case DIMEN_ELEMENT:
9988 : break;
9989 :
9990 2473 : case DIMEN_RANGE:
9991 2473 : if (ar->start[i] != NULL
9992 2473 : && ar->end[i] != NULL
9993 2472 : && ar->stride[i] == NULL)
9994 : break;
9995 :
9996 : /* Fall through. */
9997 :
9998 1 : case DIMEN_UNKNOWN:
9999 1 : case DIMEN_VECTOR:
10000 1 : case DIMEN_STAR:
10001 1 : case DIMEN_THIS_IMAGE:
10002 1 : gfc_error ("Bad array specification in ALLOCATE statement at %L",
10003 : &e->where);
10004 1 : goto failure;
10005 : }
10006 :
10007 2472 : check_symbols:
10008 46004 : for (a = code->ext.alloc.list; a; a = a->next)
10009 : {
10010 28227 : sym = a->expr->symtree->n.sym;
10011 :
10012 : /* TODO - check derived type components. */
10013 28227 : if (gfc_bt_struct (sym->ts.type) || sym->ts.type == BT_CLASS)
10014 9684 : continue;
10015 :
10016 18543 : if ((ar->start[i] != NULL
10017 17862 : && gfc_find_var_in_expr (sym, ar->start[i]))
10018 36402 : || (ar->end[i] != NULL
10019 2723 : && gfc_find_var_in_expr (sym, ar->end[i])))
10020 : {
10021 3 : gfc_error ("%qs must not appear in the array specification at "
10022 : "%L in the same ALLOCATE statement where it is "
10023 : "itself allocated", sym->name, &ar->where);
10024 3 : goto failure;
10025 : }
10026 : }
10027 : }
10028 :
10029 12601 : for (i = ar->dimen; i < ar->codimen + ar->dimen; i++)
10030 : {
10031 974 : if (ar->dimen_type[i] == DIMEN_ELEMENT
10032 780 : || ar->dimen_type[i] == DIMEN_RANGE)
10033 : {
10034 194 : if (i == (ar->dimen + ar->codimen - 1))
10035 : {
10036 0 : gfc_error ("Expected %<*%> in coindex specification in ALLOCATE "
10037 : "statement at %L", &e->where);
10038 0 : goto failure;
10039 : }
10040 194 : continue;
10041 : }
10042 :
10043 586 : if (ar->dimen_type[i] == DIMEN_STAR && i == (ar->dimen + ar->codimen - 1)
10044 586 : && ar->stride[i] == NULL)
10045 : break;
10046 :
10047 0 : gfc_error ("Bad coarray specification in ALLOCATE statement at %L",
10048 : &e->where);
10049 0 : goto failure;
10050 : }
10051 :
10052 12407 : success:
10053 18047 : gfc_used_in_allocate_expr (e, &e->where, ALLOCATED_ALLOCATE_STMT);
10054 :
10055 18047 : if (code->expr3)
10056 4266 : gfc_value_set_at (e->symtree->n.sym, &code->expr3->where, VALUE_VARDEF);
10057 :
10058 : return true;
10059 :
10060 18144 : failure:
10061 : return false;
10062 : }
10063 :
10064 :
10065 : static void
10066 21459 : resolve_allocate_deallocate (gfc_code *code, const char *fcn)
10067 : {
10068 21459 : gfc_expr *stat, *errmsg, *pe, *qe;
10069 21459 : gfc_alloc *a, *p, *q;
10070 :
10071 21459 : stat = code->expr1;
10072 21459 : errmsg = code->expr2;
10073 :
10074 : /* Check the stat variable. */
10075 21459 : if (stat)
10076 : {
10077 716 : if (!gfc_check_vardef_context (stat, false, false, false,
10078 716 : _("STAT variable")))
10079 8 : goto done_stat;
10080 :
10081 708 : if (stat->ts.type != BT_INTEGER
10082 699 : || stat->rank > 0)
10083 11 : gfc_error ("Stat-variable at %L must be a scalar INTEGER "
10084 : "variable", &stat->where);
10085 :
10086 708 : if (stat->expr_type == EXPR_CONSTANT || stat->symtree == NULL)
10087 0 : goto done_stat;
10088 :
10089 : /* F2018:9.7.4: The stat-variable shall not be allocated or deallocated
10090 : * within the ALLOCATE or DEALLOCATE statement in which it appears ...
10091 : */
10092 1464 : for (p = code->ext.alloc.list; p; p = p->next)
10093 763 : if (p->expr->symtree->n.sym->name == stat->symtree->n.sym->name)
10094 : {
10095 9 : gfc_ref *ref1, *ref2;
10096 9 : bool found = true;
10097 :
10098 16 : for (ref1 = p->expr->ref, ref2 = stat->ref; ref1 && ref2;
10099 7 : ref1 = ref1->next, ref2 = ref2->next)
10100 : {
10101 9 : if (ref1->type != REF_COMPONENT || ref2->type != REF_COMPONENT)
10102 5 : continue;
10103 4 : if (ref1->u.c.component->name != ref2->u.c.component->name)
10104 : {
10105 : found = false;
10106 : break;
10107 : }
10108 : }
10109 :
10110 9 : if (found)
10111 : {
10112 7 : gfc_error ("Stat-variable at %L shall not be %sd within "
10113 : "the same %s statement", &stat->where, fcn, fcn);
10114 7 : break;
10115 : }
10116 : }
10117 : }
10118 :
10119 20743 : done_stat:
10120 :
10121 : /* Check the errmsg variable. */
10122 21459 : if (errmsg)
10123 : {
10124 169 : if (!stat)
10125 2 : gfc_warning (0, "ERRMSG at %L is useless without a STAT tag",
10126 : &errmsg->where);
10127 :
10128 169 : if (!gfc_check_vardef_context (errmsg, false, false, false,
10129 169 : _("ERRMSG variable")))
10130 6 : goto done_errmsg;
10131 :
10132 : /* F18:R928 alloc-opt is ERRMSG = errmsg-variable
10133 : F18:R930 errmsg-variable is scalar-default-char-variable
10134 : F18:R906 default-char-variable is variable
10135 : F18:C906 default-char-variable shall be default character. */
10136 163 : if (errmsg->ts.type != BT_CHARACTER
10137 161 : || errmsg->rank > 0
10138 160 : || errmsg->ts.kind != gfc_default_character_kind)
10139 4 : gfc_error ("ERRMSG variable at %L shall be a scalar default CHARACTER "
10140 : "variable", &errmsg->where);
10141 :
10142 163 : if (errmsg->expr_type == EXPR_CONSTANT || errmsg->symtree == NULL)
10143 0 : goto done_errmsg;
10144 :
10145 : /* F2018:9.7.5: The errmsg-variable shall not be allocated or deallocated
10146 : * within the ALLOCATE or DEALLOCATE statement in which it appears ...
10147 : */
10148 324 : for (p = code->ext.alloc.list; p; p = p->next)
10149 166 : if (p->expr->symtree->n.sym->name == errmsg->symtree->n.sym->name)
10150 : {
10151 9 : gfc_ref *ref1, *ref2;
10152 9 : bool found = true;
10153 :
10154 16 : for (ref1 = p->expr->ref, ref2 = errmsg->ref; ref1 && ref2;
10155 7 : ref1 = ref1->next, ref2 = ref2->next)
10156 : {
10157 11 : if (ref1->type != REF_COMPONENT || ref2->type != REF_COMPONENT)
10158 4 : continue;
10159 7 : if (ref1->u.c.component->name != ref2->u.c.component->name)
10160 : {
10161 : found = false;
10162 : break;
10163 : }
10164 : }
10165 :
10166 9 : if (found)
10167 : {
10168 5 : gfc_error ("Errmsg-variable at %L shall not be %sd within "
10169 : "the same %s statement", &errmsg->where, fcn, fcn);
10170 5 : break;
10171 : }
10172 : }
10173 : }
10174 :
10175 21290 : done_errmsg:
10176 :
10177 : /* Check that an allocate-object appears only once in the statement. */
10178 :
10179 48301 : for (p = code->ext.alloc.list; p; p = p->next)
10180 : {
10181 26842 : pe = p->expr;
10182 36227 : for (q = p->next; q; q = q->next)
10183 : {
10184 9385 : qe = q->expr;
10185 9385 : if (pe->symtree->n.sym->name == qe->symtree->n.sym->name)
10186 : {
10187 : /* This is a potential collision. */
10188 2094 : gfc_ref *pr = pe->ref;
10189 2094 : gfc_ref *qr = qe->ref;
10190 :
10191 : /* Follow the references until
10192 : a) They start to differ, in which case there is no error;
10193 : you can deallocate a%b and a%c in a single statement
10194 : b) Both of them stop, which is an error
10195 : c) One of them stops, which is also an error. */
10196 4518 : while (1)
10197 : {
10198 3306 : if (pr == NULL && qr == NULL)
10199 : {
10200 7 : gfc_error ("Allocate-object at %L also appears at %L",
10201 : &pe->where, &qe->where);
10202 7 : break;
10203 : }
10204 3299 : else if (pr != NULL && qr == NULL)
10205 : {
10206 2 : gfc_error ("Allocate-object at %L is subobject of"
10207 : " object at %L", &pe->where, &qe->where);
10208 2 : break;
10209 : }
10210 3297 : else if (pr == NULL && qr != NULL)
10211 : {
10212 2 : gfc_error ("Allocate-object at %L is subobject of"
10213 : " object at %L", &qe->where, &pe->where);
10214 2 : break;
10215 : }
10216 : /* Here, pr != NULL && qr != NULL */
10217 3295 : gcc_assert(pr->type == qr->type);
10218 3295 : if (pr->type == REF_ARRAY)
10219 : {
10220 : /* Handle cases like allocate(v(3)%x(3), v(2)%x(3)),
10221 : which are legal. */
10222 1065 : gcc_assert (qr->type == REF_ARRAY);
10223 :
10224 1065 : if (pr->next && qr->next)
10225 : {
10226 : int i;
10227 : gfc_array_ref *par = &(pr->u.ar);
10228 : gfc_array_ref *qar = &(qr->u.ar);
10229 :
10230 1840 : for (i=0; i<par->dimen; i++)
10231 : {
10232 954 : if ((par->start[i] != NULL
10233 0 : || qar->start[i] != NULL)
10234 1908 : && gfc_dep_compare_expr (par->start[i],
10235 954 : qar->start[i]) != 0)
10236 168 : goto break_label;
10237 : }
10238 : }
10239 : }
10240 : else
10241 : {
10242 2230 : if (pr->u.c.component->name != qr->u.c.component->name)
10243 : break;
10244 : }
10245 :
10246 1212 : pr = pr->next;
10247 1212 : qr = qr->next;
10248 1212 : }
10249 9385 : break_label:
10250 : ;
10251 : }
10252 : }
10253 : }
10254 :
10255 21459 : if (strcmp (fcn, "ALLOCATE") == 0)
10256 : {
10257 15081 : bool arr_alloc_wo_spec = false;
10258 :
10259 : /* Resolve and mark as used the length of the type spec. */
10260 15081 : if (code->ext.alloc.ts.type == BT_CHARACTER)
10261 : {
10262 491 : gfc_expr *length = code->ext.alloc.ts.u.cl->length;
10263 491 : gfc_resolve_expr (length);
10264 491 : gfc_value_used_expr (length, VALUE_USED);
10265 : }
10266 :
10267 : /* Resolving the expr3 in the loop over all objects to allocate would
10268 : execute loop invariant code for each loop item. Therefore do it just
10269 : once here. */
10270 15081 : if (code->expr3 && code->expr3->mold
10271 381 : && code->expr3->ts.type == BT_DERIVED
10272 48 : && !IS_PDT (code->expr3) && !IS_CLASS_PDT (code->expr3)
10273 27 : && !(code->expr3->ref && code->expr3->ref->type == REF_ARRAY))
10274 : {
10275 : /* Default initialization via MOLD (non-polymorphic). */
10276 25 : gfc_expr *rhs = gfc_default_initializer (&code->expr3->ts);
10277 25 : if (rhs != NULL)
10278 : {
10279 6 : gfc_resolve_expr (rhs);
10280 6 : gfc_free_expr (code->expr3);
10281 6 : code->expr3 = rhs;
10282 : }
10283 : }
10284 33225 : for (a = code->ext.alloc.list; a; a = a->next)
10285 18144 : resolve_allocate_expr (a->expr, code, &arr_alloc_wo_spec);
10286 :
10287 15081 : if (arr_alloc_wo_spec && code->expr3)
10288 : {
10289 : /* Mark the allocate to have to take the array specification
10290 : from the expr3. */
10291 1267 : code->ext.alloc.arr_spec_from_expr3 = 1;
10292 : }
10293 : }
10294 : else
10295 : {
10296 15076 : for (a = code->ext.alloc.list; a; a = a->next)
10297 8698 : resolve_deallocate_expr (a->expr);
10298 : }
10299 21459 : }
10300 :
10301 :
10302 : /************ SELECT CASE resolution subroutines ************/
10303 :
10304 : /* Callback function for our mergesort variant. Determines interval
10305 : overlaps for CASEs. Return <0 if op1 < op2, 0 for overlap, >0 for
10306 : op1 > op2. Assumes we're not dealing with the default case.
10307 : We have op1 = (:L), (K:L) or (K:) and op2 = (:N), (M:N) or (M:).
10308 : There are nine situations to check. */
10309 :
10310 : static int
10311 1623 : compare_cases (const gfc_case *op1, const gfc_case *op2)
10312 : {
10313 1623 : int retval;
10314 :
10315 1623 : if (op1->low == NULL) /* op1 = (:L) */
10316 : {
10317 : /* op2 = (:N), so overlap. */
10318 52 : retval = 0;
10319 : /* op2 = (M:) or (M:N), L < M */
10320 52 : if (op2->low != NULL
10321 52 : && gfc_compare_expr (op1->high, op2->low, INTRINSIC_LT) < 0)
10322 : retval = -1;
10323 : }
10324 1571 : else if (op1->high == NULL) /* op1 = (K:) */
10325 : {
10326 : /* op2 = (M:), so overlap. */
10327 10 : retval = 0;
10328 : /* op2 = (:N) or (M:N), K > N */
10329 10 : if (op2->high != NULL
10330 10 : && gfc_compare_expr (op1->low, op2->high, INTRINSIC_GT) > 0)
10331 : retval = 1;
10332 : }
10333 : else /* op1 = (K:L) */
10334 : {
10335 1561 : if (op2->low == NULL) /* op2 = (:N), K > N */
10336 18 : retval = (gfc_compare_expr (op1->low, op2->high, INTRINSIC_GT) > 0)
10337 18 : ? 1 : 0;
10338 1543 : else if (op2->high == NULL) /* op2 = (M:), L < M */
10339 10 : retval = (gfc_compare_expr (op1->high, op2->low, INTRINSIC_LT) < 0)
10340 10 : ? -1 : 0;
10341 : else /* op2 = (M:N) */
10342 : {
10343 1533 : retval = 0;
10344 : /* L < M */
10345 1533 : if (gfc_compare_expr (op1->high, op2->low, INTRINSIC_LT) < 0)
10346 : retval = -1;
10347 : /* K > N */
10348 412 : else if (gfc_compare_expr (op1->low, op2->high, INTRINSIC_GT) > 0)
10349 438 : retval = 1;
10350 : }
10351 : }
10352 :
10353 1623 : return retval;
10354 : }
10355 :
10356 :
10357 : /* Merge-sort a double linked case list, detecting overlap in the
10358 : process. LIST is the head of the double linked case list before it
10359 : is sorted. Returns the head of the sorted list if we don't see any
10360 : overlap, or NULL otherwise. */
10361 :
10362 : static gfc_case *
10363 666 : check_case_overlap (gfc_case *list)
10364 : {
10365 666 : gfc_case *p, *q, *e, *tail;
10366 666 : int insize, nmerges, psize, qsize, cmp, overlap_seen;
10367 :
10368 : /* If the passed list was empty, return immediately. */
10369 666 : if (!list)
10370 : return NULL;
10371 :
10372 : overlap_seen = 0;
10373 : insize = 1;
10374 :
10375 : /* Loop unconditionally. The only exit from this loop is a return
10376 : statement, when we've finished sorting the case list. */
10377 1398 : for (;;)
10378 : {
10379 1032 : p = list;
10380 1032 : list = NULL;
10381 1032 : tail = NULL;
10382 :
10383 : /* Count the number of merges we do in this pass. */
10384 1032 : nmerges = 0;
10385 :
10386 : /* Loop while there exists a merge to be done. */
10387 2605 : while (p)
10388 : {
10389 1573 : int i;
10390 :
10391 : /* Count this merge. */
10392 1573 : nmerges++;
10393 :
10394 : /* Cut the list in two pieces by stepping INSIZE places
10395 : forward in the list, starting from P. */
10396 1573 : psize = 0;
10397 1573 : q = p;
10398 3301 : for (i = 0; i < insize; i++)
10399 : {
10400 2305 : psize++;
10401 2305 : q = q->right;
10402 2305 : if (!q)
10403 : break;
10404 : }
10405 1573 : qsize = insize;
10406 :
10407 : /* Now we have two lists. Merge them! */
10408 5157 : while (psize > 0 || (qsize > 0 && q != NULL))
10409 : {
10410 : /* See from which the next case to merge comes from. */
10411 841 : if (psize == 0)
10412 : {
10413 : /* P is empty so the next case must come from Q. */
10414 841 : e = q;
10415 841 : q = q->right;
10416 841 : qsize--;
10417 : }
10418 2743 : else if (qsize == 0 || q == NULL)
10419 : {
10420 : /* Q is empty. */
10421 1120 : e = p;
10422 1120 : p = p->right;
10423 1120 : psize--;
10424 : }
10425 : else
10426 : {
10427 1623 : cmp = compare_cases (p, q);
10428 1623 : if (cmp < 0)
10429 : {
10430 : /* The whole case range for P is less than the
10431 : one for Q. */
10432 1181 : e = p;
10433 1181 : p = p->right;
10434 1181 : psize--;
10435 : }
10436 442 : else if (cmp > 0)
10437 : {
10438 : /* The whole case range for Q is greater than
10439 : the case range for P. */
10440 438 : e = q;
10441 438 : q = q->right;
10442 438 : qsize--;
10443 : }
10444 : else
10445 : {
10446 : /* The cases overlap, or they are the same
10447 : element in the list. Either way, we must
10448 : issue an error and get the next case from P. */
10449 : /* FIXME: Sort P and Q by line number. */
10450 4 : gfc_error ("CASE label at %L overlaps with CASE "
10451 : "label at %L", &p->where, &q->where);
10452 4 : overlap_seen = 1;
10453 4 : e = p;
10454 4 : p = p->right;
10455 4 : psize--;
10456 : }
10457 : }
10458 :
10459 : /* Add the next element to the merged list. */
10460 3584 : if (tail)
10461 2552 : tail->right = e;
10462 : else
10463 : list = e;
10464 3584 : e->left = tail;
10465 3584 : tail = e;
10466 : }
10467 :
10468 : /* P has now stepped INSIZE places along, and so has Q. So
10469 : they're the same. */
10470 : p = q;
10471 : }
10472 1032 : tail->right = NULL;
10473 :
10474 : /* If we have done only one merge or none at all, we've
10475 : finished sorting the cases. */
10476 1032 : if (nmerges <= 1)
10477 : {
10478 666 : if (!overlap_seen)
10479 : return list;
10480 : else
10481 4 : return NULL;
10482 : }
10483 :
10484 : /* Otherwise repeat, merging lists twice the size. */
10485 366 : insize *= 2;
10486 366 : }
10487 : }
10488 :
10489 :
10490 : /* Check to see if an expression is suitable for use in a CASE statement.
10491 : Makes sure that all case expressions are scalar constants of the same
10492 : type. Return false if anything is wrong. */
10493 :
10494 : static bool
10495 3409 : validate_case_label_expr (gfc_expr *e, gfc_expr *case_expr)
10496 : {
10497 3409 : if (e == NULL) return true;
10498 :
10499 3316 : if (e->ts.type != case_expr->ts.type)
10500 : {
10501 4 : gfc_error ("Expression in CASE statement at %L must be of type %s",
10502 : &e->where, gfc_basic_typename (case_expr->ts.type));
10503 4 : return false;
10504 : }
10505 :
10506 : /* C805 (R808) For a given case-construct, each case-value shall be of
10507 : the same type as case-expr. For character type, length differences
10508 : are allowed, but the kind type parameters shall be the same. */
10509 :
10510 3312 : if (case_expr->ts.type == BT_CHARACTER && e->ts.kind != case_expr->ts.kind)
10511 : {
10512 4 : gfc_error ("Expression in CASE statement at %L must be of kind %d",
10513 : &e->where, case_expr->ts.kind);
10514 4 : return false;
10515 : }
10516 :
10517 : /* Convert the case value kind to that of case expression kind,
10518 : if needed */
10519 :
10520 3308 : if (e->ts.kind != case_expr->ts.kind)
10521 14 : gfc_convert_type_warn (e, &case_expr->ts, 2, 0);
10522 :
10523 3308 : if (e->rank != 0)
10524 : {
10525 0 : gfc_error ("Expression in CASE statement at %L must be scalar",
10526 : &e->where);
10527 0 : return false;
10528 : }
10529 :
10530 : return true;
10531 : }
10532 :
10533 :
10534 : /* Given a completely parsed select statement, we:
10535 :
10536 : - Validate all expressions and code within the SELECT.
10537 : - Make sure that the selection expression is not of the wrong type.
10538 : - Make sure that no case ranges overlap.
10539 : - Eliminate unreachable cases and unreachable code resulting from
10540 : removing case labels.
10541 :
10542 : The standard does allow unreachable cases, e.g. CASE (5:3). But
10543 : they are a hassle for code generation, and to prevent that, we just
10544 : cut them out here. This is not necessary for overlapping cases
10545 : because they are illegal and we never even try to generate code.
10546 :
10547 : We have the additional caveat that a SELECT construct could have
10548 : been a computed GOTO in the source code. Fortunately we can fairly
10549 : easily work around that here: The case_expr for a "real" SELECT CASE
10550 : is in code->expr1, but for a computed GOTO it is in code->expr2. All
10551 : we have to do is make sure that the case_expr is a scalar integer
10552 : expression. */
10553 :
10554 : static void
10555 707 : resolve_select (gfc_code *code, bool select_type)
10556 : {
10557 707 : gfc_code *body;
10558 707 : gfc_expr *case_expr;
10559 707 : gfc_case *cp, *default_case, *tail, *head;
10560 707 : int seen_unreachable;
10561 707 : int seen_logical;
10562 707 : int ncases;
10563 707 : bt type;
10564 707 : bool t;
10565 :
10566 707 : if (code->expr1 == NULL)
10567 : {
10568 : /* This was actually a computed GOTO statement. */
10569 5 : case_expr = code->expr2;
10570 5 : if (case_expr->ts.type != BT_INTEGER|| case_expr->rank != 0)
10571 3 : gfc_error ("Selection expression in computed GOTO statement "
10572 : "at %L must be a scalar integer expression",
10573 : &case_expr->where);
10574 :
10575 : /* Further checking is not necessary because this SELECT was built
10576 : by the compiler, so it should always be OK. Just move the
10577 : case_expr from expr2 to expr so that we can handle computed
10578 : GOTOs as normal SELECTs from here on. */
10579 5 : code->expr1 = code->expr2;
10580 5 : code->expr2 = NULL;
10581 5 : gfc_value_used_expr (code->expr1, VALUE_USED);
10582 5 : return;
10583 : }
10584 :
10585 702 : case_expr = code->expr1;
10586 702 : type = case_expr->ts.type;
10587 :
10588 : /* F08:C830. */
10589 702 : if (type != BT_LOGICAL && type != BT_INTEGER && type != BT_CHARACTER
10590 6 : && (!flag_unsigned || (flag_unsigned && type != BT_UNSIGNED)))
10591 :
10592 : {
10593 0 : gfc_error ("Argument of SELECT statement at %L cannot be %s",
10594 : &case_expr->where, gfc_typename (case_expr));
10595 :
10596 : /* Punt. Going on here just produce more garbage error messages. */
10597 0 : return;
10598 : }
10599 :
10600 : /* F08:R842. */
10601 702 : if (!select_type && case_expr->rank != 0)
10602 : {
10603 1 : gfc_error ("Argument of SELECT statement at %L must be a scalar "
10604 : "expression", &case_expr->where);
10605 :
10606 : /* Punt. */
10607 1 : return;
10608 : }
10609 :
10610 : /* Raise a warning if an INTEGER case value exceeds the range of
10611 : the case-expr. Later, all expressions will be promoted to the
10612 : largest kind of all case-labels. */
10613 :
10614 701 : if (type == BT_INTEGER)
10615 1999 : for (body = code->block; body; body = body->block)
10616 2956 : for (cp = body->ext.block.case_list; cp; cp = cp->next)
10617 : {
10618 1514 : if (cp->low
10619 1514 : && gfc_check_integer_range (cp->low->value.integer,
10620 : case_expr->ts.kind) != ARITH_OK)
10621 6 : gfc_warning (0, "Expression in CASE statement at %L is "
10622 6 : "not in the range of %s", &cp->low->where,
10623 : gfc_typename (case_expr));
10624 :
10625 1514 : if (cp->high
10626 1229 : && cp->low != cp->high
10627 1622 : && gfc_check_integer_range (cp->high->value.integer,
10628 : case_expr->ts.kind) != ARITH_OK)
10629 0 : gfc_warning (0, "Expression in CASE statement at %L is "
10630 0 : "not in the range of %s", &cp->high->where,
10631 : gfc_typename (case_expr));
10632 : }
10633 :
10634 : /* PR 19168 has a long discussion concerning a mismatch of the kinds
10635 : of the SELECT CASE expression and its CASE values. Walk the lists
10636 : of case values, and if we find a mismatch, promote case_expr to
10637 : the appropriate kind. */
10638 :
10639 701 : if (type == BT_LOGICAL || type == BT_INTEGER)
10640 : {
10641 2185 : for (body = code->block; body; body = body->block)
10642 : {
10643 : /* Walk the case label list. */
10644 3217 : for (cp = body->ext.block.case_list; cp; cp = cp->next)
10645 : {
10646 : /* Intercept the DEFAULT case. It does not have a kind. */
10647 1649 : if (cp->low == NULL && cp->high == NULL)
10648 293 : continue;
10649 :
10650 : /* Unreachable case ranges are discarded, so ignore. */
10651 1311 : if (cp->low != NULL && cp->high != NULL
10652 1263 : && cp->low != cp->high
10653 1421 : && gfc_compare_expr (cp->low, cp->high, INTRINSIC_GT) > 0)
10654 33 : continue;
10655 :
10656 1323 : if (cp->low != NULL
10657 1323 : && case_expr->ts.kind != gfc_kind_max(case_expr, cp->low))
10658 17 : gfc_convert_type_warn (case_expr, &cp->low->ts, 1, 0);
10659 :
10660 1323 : if (cp->high != NULL
10661 1323 : && case_expr->ts.kind != gfc_kind_max(case_expr, cp->high))
10662 4 : gfc_convert_type_warn (case_expr, &cp->high->ts, 1, 0);
10663 : }
10664 : }
10665 : }
10666 :
10667 : /* Assume there is no DEFAULT case. */
10668 701 : default_case = NULL;
10669 701 : head = tail = NULL;
10670 701 : ncases = 0;
10671 701 : seen_logical = 0;
10672 :
10673 2574 : for (body = code->block; body; body = body->block)
10674 : {
10675 : /* Assume the CASE list is OK, and all CASE labels can be matched. */
10676 1873 : t = true;
10677 1873 : seen_unreachable = 0;
10678 :
10679 : /* Walk the case label list, making sure that all case labels
10680 : are legal. */
10681 3933 : for (cp = body->ext.block.case_list; cp; cp = cp->next)
10682 : {
10683 : /* Count the number of cases in the whole construct. */
10684 2071 : ncases++;
10685 :
10686 : /* Intercept the DEFAULT case. */
10687 2071 : if (cp->low == NULL && cp->high == NULL)
10688 : {
10689 363 : if (default_case != NULL)
10690 : {
10691 0 : gfc_error ("The DEFAULT CASE at %L cannot be followed "
10692 : "by a second DEFAULT CASE at %L",
10693 : &default_case->where, &cp->where);
10694 0 : t = false;
10695 0 : break;
10696 : }
10697 : else
10698 : {
10699 363 : default_case = cp;
10700 363 : continue;
10701 : }
10702 : }
10703 :
10704 : /* Deal with single value cases and case ranges. Errors are
10705 : issued from the validation function. */
10706 1708 : if (!validate_case_label_expr (cp->low, case_expr)
10707 1708 : || !validate_case_label_expr (cp->high, case_expr))
10708 : {
10709 : t = false;
10710 : break;
10711 : }
10712 :
10713 1700 : if (type == BT_LOGICAL
10714 78 : && ((cp->low == NULL || cp->high == NULL)
10715 76 : || cp->low != cp->high))
10716 : {
10717 2 : gfc_error ("Logical range in CASE statement at %L is not "
10718 : "allowed",
10719 1 : cp->low ? &cp->low->where : &cp->high->where);
10720 2 : t = false;
10721 2 : break;
10722 : }
10723 :
10724 76 : if (type == BT_LOGICAL && cp->low->expr_type == EXPR_CONSTANT)
10725 : {
10726 76 : int value;
10727 76 : value = cp->low->value.logical == 0 ? 2 : 1;
10728 76 : if (value & seen_logical)
10729 : {
10730 1 : gfc_error ("Constant logical value in CASE statement "
10731 : "is repeated at %L",
10732 : &cp->low->where);
10733 1 : t = false;
10734 1 : break;
10735 : }
10736 75 : seen_logical |= value;
10737 : }
10738 :
10739 1653 : if (cp->low != NULL && cp->high != NULL
10740 1606 : && cp->low != cp->high
10741 1809 : && gfc_compare_expr (cp->low, cp->high, INTRINSIC_GT) > 0)
10742 : {
10743 35 : if (warn_surprising)
10744 1 : gfc_warning (OPT_Wsurprising,
10745 : "Range specification at %L can never be matched",
10746 : &cp->where);
10747 :
10748 35 : cp->unreachable = 1;
10749 35 : seen_unreachable = 1;
10750 : }
10751 : else
10752 : {
10753 : /* If the case range can be matched, it can also overlap with
10754 : other cases. To make sure it does not, we put it in a
10755 : double linked list here. We sort that with a merge sort
10756 : later on to detect any overlapping cases. */
10757 1662 : if (!head)
10758 : {
10759 666 : head = tail = cp;
10760 666 : head->right = head->left = NULL;
10761 : }
10762 : else
10763 : {
10764 996 : tail->right = cp;
10765 996 : tail->right->left = tail;
10766 996 : tail = tail->right;
10767 996 : tail->right = NULL;
10768 : }
10769 : }
10770 : }
10771 :
10772 : /* It there was a failure in the previous case label, give up
10773 : for this case label list. Continue with the next block. */
10774 1873 : if (!t)
10775 11 : continue;
10776 :
10777 : /* See if any case labels that are unreachable have been seen.
10778 : If so, we eliminate them. This is a bit of a kludge because
10779 : the case lists for a single case statement (label) is a
10780 : single forward linked lists. */
10781 1862 : if (seen_unreachable)
10782 : {
10783 : /* Advance until the first case in the list is reachable. */
10784 69 : while (body->ext.block.case_list != NULL
10785 69 : && body->ext.block.case_list->unreachable)
10786 : {
10787 34 : gfc_case *n = body->ext.block.case_list;
10788 34 : body->ext.block.case_list = body->ext.block.case_list->next;
10789 34 : n->next = NULL;
10790 34 : gfc_free_case_list (n);
10791 : }
10792 :
10793 : /* Strip all other unreachable cases. */
10794 35 : if (body->ext.block.case_list)
10795 : {
10796 2 : for (cp = body->ext.block.case_list; cp && cp->next; cp = cp->next)
10797 : {
10798 1 : if (cp->next->unreachable)
10799 : {
10800 1 : gfc_case *n = cp->next;
10801 1 : cp->next = cp->next->next;
10802 1 : n->next = NULL;
10803 1 : gfc_free_case_list (n);
10804 : }
10805 : }
10806 : }
10807 : }
10808 : }
10809 :
10810 : /* See if there were overlapping cases. If the check returns NULL,
10811 : there was overlap. In that case we don't do anything. If head
10812 : is non-NULL, we prepend the DEFAULT case. The sorted list can
10813 : then used during code generation for SELECT CASE constructs with
10814 : a case expression of a CHARACTER type. */
10815 701 : if (head)
10816 : {
10817 666 : head = check_case_overlap (head);
10818 :
10819 : /* Prepend the default_case if it is there. */
10820 666 : if (head != NULL && default_case)
10821 : {
10822 346 : default_case->left = NULL;
10823 346 : default_case->right = head;
10824 346 : head->left = default_case;
10825 : }
10826 : }
10827 :
10828 : /* Eliminate dead blocks that may be the result if we've seen
10829 : unreachable case labels for a block. */
10830 2540 : for (body = code; body && body->block; body = body->block)
10831 : {
10832 1839 : if (body->block->ext.block.case_list == NULL)
10833 : {
10834 : /* Cut the unreachable block from the code chain. */
10835 34 : gfc_code *c = body->block;
10836 34 : body->block = c->block;
10837 :
10838 : /* Kill the dead block, but not the blocks below it. */
10839 34 : c->block = NULL;
10840 34 : gfc_free_statements (c);
10841 : }
10842 : }
10843 :
10844 : /* More than two cases is legal but insane for logical selects.
10845 : Issue a warning for it. */
10846 701 : if (warn_surprising && type == BT_LOGICAL && ncases > 2)
10847 0 : gfc_warning (OPT_Wsurprising,
10848 : "Logical SELECT CASE block at %L has more that two cases",
10849 : &code->loc);
10850 :
10851 : /* Finally, mark the expression as used. */
10852 701 : gfc_value_used_expr (case_expr, VALUE_USED);
10853 : }
10854 :
10855 :
10856 : /* Check if a derived type is extensible. */
10857 :
10858 : bool
10859 25245 : gfc_type_is_extensible (gfc_symbol *sym)
10860 : {
10861 25245 : return !(sym->attr.is_bind_c || sym->attr.sequence
10862 25229 : || (sym->attr.is_class
10863 2235 : && sym->components->ts.u.derived->attr.unlimited_polymorphic));
10864 : }
10865 :
10866 :
10867 : static void
10868 : resolve_types (gfc_namespace *ns);
10869 :
10870 : /* Resolve an associate-name: Resolve target and ensure the type-spec is
10871 : correct as well as possibly the array-spec. */
10872 :
10873 : static void
10874 13847 : resolve_assoc_var (gfc_symbol* sym, bool resolve_target)
10875 : {
10876 13847 : gfc_expr* target;
10877 :
10878 13847 : gcc_assert (sym->assoc);
10879 13847 : gcc_assert (sym->attr.flavor == FL_VARIABLE);
10880 :
10881 13847 : if (sym->assoc->target
10882 8407 : && sym->assoc->target->expr_type == EXPR_FUNCTION
10883 752 : && sym->assoc->target->symtree
10884 752 : && sym->assoc->target->symtree->n.sym
10885 752 : && sym->assoc->target->symtree->n.sym->attr.generic)
10886 : {
10887 33 : if (gfc_resolve_expr (sym->assoc->target))
10888 33 : sym->ts = sym->assoc->target->ts;
10889 : else
10890 : {
10891 0 : gfc_error ("%s could not be resolved to a specific function at %L",
10892 0 : sym->assoc->target->symtree->n.sym->name,
10893 0 : &sym->assoc->target->where);
10894 0 : return;
10895 : }
10896 : }
10897 :
10898 : /* If this is for SELECT TYPE, the target may not yet be set. In that
10899 : case, return. Resolution will be called later manually again when
10900 : this is done. */
10901 13847 : target = sym->assoc->target;
10902 13847 : if (!target)
10903 : return;
10904 8407 : gcc_assert (!sym->assoc->dangling);
10905 :
10906 8407 : if (resolve_target && !gfc_resolve_expr (target))
10907 : return;
10908 :
10909 8402 : if (sym->assoc->ar)
10910 : {
10911 : int dim;
10912 : gfc_array_ref *ar = sym->assoc->ar;
10913 68 : for (dim = 0; dim < sym->assoc->ar->dimen; dim++)
10914 : {
10915 39 : if (!(ar->start[dim] && gfc_resolve_expr (ar->start[dim])
10916 39 : && ar->start[dim]->ts.type == BT_INTEGER)
10917 78 : || !(ar->end[dim] && gfc_resolve_expr (ar->end[dim])
10918 39 : && ar->end[dim]->ts.type == BT_INTEGER))
10919 0 : gfc_error ("(F202y)Missing or invalid bound in ASSOCIATE rank "
10920 : "remapping of associate name %s at %L",
10921 : sym->name, &sym->declared_at);
10922 : }
10923 : }
10924 :
10925 : /* F2023:C1105 - the selector shall be neither a procedure pointer
10926 : designator nor a function reference returning a procedure pointer.
10927 : Note that calling a procedure pointer is fine; what matters here is
10928 : whether the function result is itself a procedure pointer. */
10929 8402 : if (target->expr_type == EXPR_VARIABLE
10930 8402 : && gfc_expr_attr (target).proc_pointer)
10931 : {
10932 2 : gfc_error ("Associating entity %qs at %L is a procedure pointer",
10933 2 : target->symtree->n.sym->name, &target->where);
10934 2 : return;
10935 : }
10936 :
10937 8400 : if (target->expr_type == EXPR_FUNCTION)
10938 : {
10939 700 : gfc_symbol *fsym = target->value.function.esym;
10940 700 : gfc_symbol *result = NULL;
10941 :
10942 700 : if (fsym && fsym->attr.proc_pointer)
10943 : /* Called through a procedure pointer, whose own result symbol is
10944 : itself; the result is described by the interface instead. */
10945 3 : result = fsym->ts.interface ? fsym->ts.interface->result : NULL;
10946 697 : else if (fsym)
10947 643 : result = fsym->result;
10948 54 : else if (target->symtree && target->symtree->n.sym->ts.interface)
10949 0 : result = target->symtree->n.sym->ts.interface->result;
10950 :
10951 646 : if (result && result->attr.proc_pointer)
10952 : {
10953 4 : gfc_error ("Selector at %L returns a procedure pointer",
10954 : &target->where);
10955 4 : return;
10956 : }
10957 : }
10958 :
10959 : /* For variable targets, we get some attributes from the target. */
10960 8396 : if (target->expr_type == EXPR_VARIABLE
10961 1315 : || (target->expr_type == EXPR_OP
10962 317 : && target->value.op.op == INTRINSIC_PARENTHESES
10963 86 : && target->value.op.op1->expr_type == EXPR_VARIABLE))
10964 : {
10965 7154 : gfc_symbol *tsym, *dsym;
10966 :
10967 7154 : tsym = target->expr_type == EXPR_VARIABLE ? target->symtree->n.sym :
10968 73 : target->value.op.op1->symtree->n.sym;
10969 :
10970 74 : if (tsym->attr.flavor == FL_PROCEDURE && tsym->generic
10971 2 : && (dsym = gfc_find_dt_in_generic (tsym)) != NULL
10972 7155 : && dsym->attr.flavor == FL_DERIVED)
10973 : {
10974 1 : gfc_error ("Derived type %qs cannot be used as a variable at %L",
10975 : tsym->name, &target->where);
10976 1 : return;
10977 : }
10978 :
10979 7153 : if (tsym->attr.flavor == FL_PROCEDURE)
10980 : {
10981 73 : bool is_error = true;
10982 73 : if (tsym->attr.function && tsym->result == tsym)
10983 141 : for (gfc_namespace *ns = sym->ns; ns; ns = ns->parent)
10984 137 : if (tsym == ns->proc_name)
10985 : {
10986 : is_error = false;
10987 : break;
10988 : }
10989 64 : if (is_error)
10990 : {
10991 13 : gfc_error ("Associating entity %qs at %L is a procedure name",
10992 : tsym->name, &target->where);
10993 13 : return;
10994 : }
10995 : }
10996 :
10997 7140 : if (target->expr_type == EXPR_VARIABLE)
10998 : {
10999 7069 : sym->attr.asynchronous = tsym->attr.asynchronous;
11000 7069 : sym->attr.volatile_ = tsym->attr.volatile_;
11001 :
11002 14138 : sym->attr.target = tsym->attr.target
11003 7069 : || gfc_expr_attr (target).pointer;
11004 7069 : if (is_subref_array (target))
11005 474 : sym->attr.subref_array_pointer = 1;
11006 : }
11007 : }
11008 1242 : else if (target->ts.type == BT_PROCEDURE)
11009 : {
11010 0 : gfc_error ("Associating selector-expression at %L yields a procedure",
11011 : &target->where);
11012 0 : return;
11013 : }
11014 :
11015 : /* The elements of a pointer function result may be spaced by more than
11016 : the element size. */
11017 8382 : if (target->expr_type == EXPR_FUNCTION
11018 696 : && target->rank > 0
11019 9078 : && gfc_expr_attr (target).pointer)
11020 37 : sym->attr.subref_array_pointer = 1;
11021 :
11022 8382 : if (sym->assoc->inferred_type || IS_INFERRED_TYPE (target))
11023 : {
11024 : /* By now, the type of the target has been fixed up. */
11025 444 : symbol_attribute attr;
11026 :
11027 444 : if (sym->ts.type == BT_DERIVED
11028 305 : && target->ts.type == BT_CLASS
11029 56 : && !UNLIMITED_POLY (target))
11030 : {
11031 : /* Inferred to be derived type but the target has type class. */
11032 56 : sym->ts = CLASS_DATA (target)->ts;
11033 56 : if (!sym->as)
11034 56 : sym->as = gfc_copy_array_spec (CLASS_DATA (target)->as);
11035 56 : attr = CLASS_DATA (sym) ? CLASS_DATA (sym)->attr : sym->attr;
11036 56 : sym->attr.dimension = target->rank ? 1 : 0;
11037 56 : gfc_change_class (&sym->ts, &attr, sym->as, target->rank,
11038 : target->corank);
11039 56 : sym->as = NULL;
11040 : }
11041 388 : else if (target->ts.type == BT_DERIVED
11042 249 : && target->symtree && target->symtree->n.sym
11043 225 : && target->symtree->n.sym->ts.type == BT_CLASS
11044 0 : && IS_INFERRED_TYPE (target)
11045 0 : && target->ref && target->ref->next
11046 0 : && target->ref->next->type == REF_ARRAY
11047 0 : && !target->ref->next->next)
11048 : {
11049 : /* A inferred type selector whose symbol has been determined to be
11050 : a class array but which only has an array reference. Change the
11051 : associate name and the selector to class type. */
11052 0 : sym->ts = target->ts;
11053 0 : attr = CLASS_DATA (sym) ? CLASS_DATA (sym)->attr : sym->attr;
11054 0 : sym->attr.dimension = target->rank ? 1 : 0;
11055 0 : gfc_change_class (&sym->ts, &attr, sym->as, target->rank,
11056 : target->corank);
11057 0 : sym->as = NULL;
11058 0 : target->ts = sym->ts;
11059 : }
11060 388 : else if ((target->ts.type == BT_DERIVED)
11061 139 : || (sym->ts.type == BT_CLASS && target->ts.type == BT_CLASS
11062 67 : && CLASS_DATA (target)->as && !CLASS_DATA (sym)->as))
11063 : /* Confirmed to be either a derived type or misidentified to be a
11064 : scalar class object, when the selector is a class array. */
11065 255 : sym->ts = target->ts;
11066 133 : else if (sym->assoc->inferred_type
11067 120 : && (sym->ts.type == BT_COMPLEX
11068 78 : || sym->ts.type == BT_CHARACTER)
11069 66 : && target->ts.type == sym->ts.type
11070 66 : && sym->ts.kind != target->ts.kind)
11071 : /* The inferred type was set from a %re, %im or %len inquiry on
11072 : the associate name with the default kind, before the target's
11073 : actual type was known. Now that the target has been resolved,
11074 : update the kind to match. */
11075 6 : sym->ts = target->ts;
11076 : }
11077 :
11078 :
11079 8382 : if (target->expr_type == EXPR_NULL)
11080 : {
11081 1 : gfc_error ("Selector at %L cannot be NULL()", &target->where);
11082 1 : return;
11083 : }
11084 8381 : else if (target->ts.type == BT_UNKNOWN)
11085 : {
11086 2 : gfc_error ("Selector at %L has no type", &target->where);
11087 2 : return;
11088 : }
11089 :
11090 : /* Get type if this was not already set. Note that it can be
11091 : some other type than the target in case this is a SELECT TYPE
11092 : selector! So we must not update when the type is already there. */
11093 8379 : if (sym->ts.type == BT_UNKNOWN)
11094 266 : sym->ts = target->ts;
11095 :
11096 8379 : gcc_assert (sym->ts.type != BT_UNKNOWN);
11097 :
11098 : /* See if this is a valid association-to-variable. */
11099 16758 : sym->assoc->variable = ((target->expr_type == EXPR_VARIABLE
11100 7069 : && !gfc_has_vector_subscript (target))
11101 8406 : || gfc_is_ptr_fcn (target));
11102 :
11103 : /* A type parameter inquiry is not a variable. */
11104 8379 : if (sym->assoc->variable && target->expr_type == EXPR_VARIABLE)
11105 15699 : for (gfc_ref *ref = target->ref; ref; ref = ref->next)
11106 8681 : if (ref->type == REF_INQUIRY
11107 24 : && (ref->u.i == INQUIRY_LEN || ref->u.i == INQUIRY_KIND))
11108 : {
11109 24 : sym->assoc->variable = false;
11110 24 : break;
11111 : }
11112 :
11113 : /* Finally resolve if this is an array or not. */
11114 8379 : if (target->expr_type == EXPR_FUNCTION && target->rank == 0
11115 310 : && (sym->ts.type == BT_CLASS || sym->ts.type == BT_DERIVED))
11116 : {
11117 212 : gfc_expression_rank (target);
11118 212 : if (target->ts.type == BT_DERIVED
11119 140 : && !sym->as
11120 140 : && target->symtree->n.sym->as)
11121 : {
11122 0 : sym->as = gfc_copy_array_spec (target->symtree->n.sym->as);
11123 0 : sym->attr.dimension = 1;
11124 : }
11125 212 : else if (target->ts.type == BT_CLASS
11126 72 : && CLASS_DATA (target)->as)
11127 : {
11128 0 : target->rank = CLASS_DATA (target)->as->rank;
11129 0 : target->corank = CLASS_DATA (target)->as->corank;
11130 0 : if (!(sym->ts.type == BT_CLASS && CLASS_DATA (sym)->as))
11131 : {
11132 0 : sym->ts = target->ts;
11133 0 : sym->attr.dimension = 0;
11134 : }
11135 : }
11136 : }
11137 :
11138 :
11139 8379 : if (sym->attr.dimension && target->rank == 0)
11140 : {
11141 : /* primary.cc makes the assumption that a reference to an associate
11142 : name followed by a left parenthesis is an array reference. */
11143 17 : if (sym->assoc->inferred_type && sym->ts.type != BT_CLASS)
11144 : {
11145 12 : gfc_expression_rank (sym->assoc->target);
11146 12 : sym->attr.dimension = sym->assoc->target->rank ? 1 : 0;
11147 12 : if (!sym->attr.dimension && sym->as)
11148 0 : sym->as = NULL;
11149 : }
11150 :
11151 17 : if (sym->attr.dimension && target->rank == 0)
11152 : {
11153 5 : if (sym->ts.type != BT_CHARACTER)
11154 5 : gfc_error ("Associate-name %qs at %L is used as array",
11155 : sym->name, &sym->declared_at);
11156 5 : sym->attr.dimension = 0;
11157 5 : return;
11158 : }
11159 : }
11160 :
11161 : /* We cannot deal with class selectors that need temporaries. */
11162 8374 : if (target->ts.type == BT_CLASS
11163 8374 : && gfc_ref_needs_temporary_p (target->ref))
11164 : {
11165 1 : gfc_error ("CLASS selector at %L needs a temporary which is not "
11166 : "yet implemented", &target->where);
11167 1 : return;
11168 : }
11169 :
11170 8373 : if (target->ts.type == BT_CLASS)
11171 3073 : gfc_fix_class_refs (target);
11172 :
11173 8373 : if ((target->rank > 0 || target->corank > 0)
11174 3037 : && !sym->attr.select_rank_temporary)
11175 : {
11176 3037 : gfc_array_spec *as;
11177 : /* The rank may be incorrectly guessed at parsing, therefore make sure
11178 : it is corrected now. */
11179 3037 : if (sym->ts.type != BT_CLASS
11180 2378 : && (!sym->as || sym->as->corank != target->corank))
11181 : {
11182 187 : if (!sym->as)
11183 180 : sym->as = gfc_get_array_spec ();
11184 187 : as = sym->as;
11185 187 : as->rank = target->rank;
11186 187 : as->type = AS_DEFERRED;
11187 187 : as->corank = target->corank;
11188 187 : sym->attr.dimension = 1;
11189 187 : if (as->corank != 0)
11190 7 : sym->attr.codimension = 1;
11191 : }
11192 2850 : else if (sym->ts.type == BT_CLASS && CLASS_DATA (sym)
11193 658 : && (!CLASS_DATA (sym)->as
11194 652 : || CLASS_DATA (sym)->as->corank != target->corank))
11195 : {
11196 6 : if (!CLASS_DATA (sym)->as)
11197 6 : CLASS_DATA (sym)->as = gfc_get_array_spec ();
11198 6 : as = CLASS_DATA (sym)->as;
11199 6 : as->rank = target->rank;
11200 6 : as->type = AS_DEFERRED;
11201 6 : as->corank = target->corank;
11202 6 : CLASS_DATA (sym)->attr.dimension = 1;
11203 6 : if (as->corank != 0)
11204 0 : CLASS_DATA (sym)->attr.codimension = 1;
11205 : }
11206 : }
11207 5336 : else if (!sym->attr.select_rank_temporary)
11208 : {
11209 : /* target's rank is 0, but the type of the sym is still array valued,
11210 : which has to be corrected. */
11211 3911 : if (sym->ts.type == BT_CLASS && sym->ts.u.derived
11212 797 : && CLASS_DATA (sym) && CLASS_DATA (sym)->as)
11213 : {
11214 24 : gfc_array_spec *as;
11215 24 : symbol_attribute attr;
11216 : /* The associated variable's type is still the array type
11217 : correct this now. */
11218 24 : gfc_typespec *ts = &target->ts;
11219 24 : gfc_ref *ref;
11220 : /* Internal_ref is true, when this is ref'ing only _data and co-ref.
11221 : */
11222 24 : bool internal_ref = true;
11223 :
11224 72 : for (ref = target->ref; ref != NULL; ref = ref->next)
11225 : {
11226 48 : switch (ref->type)
11227 : {
11228 24 : case REF_COMPONENT:
11229 24 : ts = &ref->u.c.component->ts;
11230 24 : internal_ref
11231 24 : = target->ref == ref && ref->next
11232 48 : && strncmp ("_data", ref->u.c.component->name, 5) == 0;
11233 : break;
11234 24 : case REF_ARRAY:
11235 24 : if (ts->type == BT_CLASS)
11236 0 : ts = &ts->u.derived->components->ts;
11237 24 : if (internal_ref && ref->u.ar.codimen > 0)
11238 0 : for (int i = ref->u.ar.dimen;
11239 : internal_ref
11240 0 : && i < ref->u.ar.dimen + ref->u.ar.codimen;
11241 : ++i)
11242 0 : internal_ref
11243 0 : = ref->u.ar.dimen_type[i] == DIMEN_THIS_IMAGE;
11244 : break;
11245 : default:
11246 : break;
11247 : }
11248 : }
11249 : /* Only rewrite the type of this symbol, when the refs are not the
11250 : internal ones for class and co-array this-image. */
11251 24 : if (!internal_ref)
11252 : {
11253 : /* Create a scalar instance of the current class type. Because
11254 : the rank of a class array goes into its name, the type has to
11255 : be rebuilt. The alternative of (re-)setting just the
11256 : attributes and as in the current type, destroys the type also
11257 : in other places. */
11258 0 : as = NULL;
11259 0 : sym->ts = *ts;
11260 0 : sym->ts.type = BT_CLASS;
11261 0 : attr = CLASS_DATA (sym) ? CLASS_DATA (sym)->attr : sym->attr;
11262 0 : gfc_change_class (&sym->ts, &attr, as, 0, 0);
11263 0 : sym->as = NULL;
11264 : }
11265 : }
11266 : }
11267 :
11268 : /* Mark this as an associate variable. */
11269 8373 : sym->attr.associate_var = 1;
11270 :
11271 : /* Fix up the type-spec for CHARACTER types. */
11272 8373 : if (sym->ts.type == BT_CHARACTER && !sym->attr.select_type_temporary)
11273 : {
11274 563 : gfc_ref *ref;
11275 853 : for (ref = target->ref; ref; ref = ref->next)
11276 316 : if (ref->type == REF_SUBSTRING
11277 74 : && (ref->u.ss.start == NULL
11278 74 : || ref->u.ss.start->expr_type != EXPR_CONSTANT
11279 74 : || ref->u.ss.end == NULL
11280 54 : || ref->u.ss.end->expr_type != EXPR_CONSTANT))
11281 : break;
11282 :
11283 563 : if (!sym->ts.u.cl)
11284 182 : sym->ts.u.cl = target->ts.u.cl;
11285 :
11286 563 : if (sym->ts.deferred
11287 231 : && sym->ts.u.cl == target->ts.u.cl)
11288 : {
11289 116 : sym->ts.u.cl = gfc_new_charlen (sym->ns, NULL);
11290 116 : sym->ts.deferred = 1;
11291 : }
11292 :
11293 563 : if (!sym->ts.u.cl->length
11294 357 : && !sym->ts.deferred
11295 126 : && target->expr_type == EXPR_CONSTANT)
11296 : {
11297 30 : sym->ts.u.cl->length =
11298 30 : gfc_get_int_expr (gfc_charlen_int_kind, NULL,
11299 30 : target->value.character.length);
11300 : }
11301 533 : else if (((!sym->ts.u.cl->length
11302 206 : || sym->ts.u.cl->length->expr_type != EXPR_CONSTANT)
11303 333 : && target->expr_type != EXPR_VARIABLE)
11304 403 : || ref)
11305 : {
11306 156 : if (!sym->ts.deferred)
11307 : {
11308 45 : sym->ts.u.cl = gfc_new_charlen (sym->ns, NULL);
11309 45 : sym->ts.deferred = 1;
11310 : }
11311 :
11312 : /* This is reset in trans-stmt.cc after the assignment
11313 : of the target expression to the associate name. */
11314 156 : if (ref && sym->as)
11315 26 : sym->attr.pointer = 1;
11316 : else
11317 130 : sym->attr.allocatable = 1;
11318 : }
11319 : }
11320 :
11321 8373 : if (sym->ts.type == BT_CLASS
11322 1601 : && IS_INFERRED_TYPE (target)
11323 19 : && target->ts.type == BT_DERIVED
11324 0 : && CLASS_DATA (sym)->ts.u.derived == target->ts.u.derived
11325 0 : && target->ref && target->ref->next && !target->ref->next->next
11326 0 : && target->ref->next->type == REF_ARRAY)
11327 0 : target->ts = target->symtree->n.sym->ts;
11328 :
11329 : /* If the target is a good class object, so is the associate variable. */
11330 8373 : if (sym->ts.type == BT_CLASS && gfc_expr_attr (target).class_ok)
11331 1378 : sym->attr.class_ok = 1;
11332 :
11333 : /* If the target is a contiguous pointer, so is the associate variable. */
11334 8373 : if (gfc_expr_attr (target).pointer && gfc_expr_attr (target).contiguous)
11335 4 : sym->attr.contiguous = 1;
11336 : }
11337 :
11338 :
11339 : /* Ensure that SELECT TYPE expressions have the correct rank and a full
11340 : array reference, where necessary. The symbols are artificial and so
11341 : the dimension attribute and arrayspec can also be set. In addition,
11342 : sometimes the expr1 arrives as BT_DERIVED, when the symbol is BT_CLASS.
11343 : This is corrected here as well.*/
11344 :
11345 : static void
11346 1863 : fixup_array_ref (gfc_expr **expr1, gfc_expr *expr2, int rank, int corank,
11347 : gfc_ref *ref)
11348 : {
11349 1863 : gfc_ref *nref = (*expr1)->ref;
11350 1863 : gfc_symbol *sym1 = (*expr1)->symtree->n.sym;
11351 1863 : gfc_symbol *sym2;
11352 1863 : gfc_expr *selector = gfc_copy_expr (expr2);
11353 :
11354 1863 : (*expr1)->rank = rank;
11355 1863 : (*expr1)->corank = corank;
11356 1863 : if (selector)
11357 : {
11358 378 : gfc_resolve_expr (selector);
11359 378 : if (selector->expr_type == EXPR_OP
11360 2 : && selector->value.op.op == INTRINSIC_PARENTHESES)
11361 2 : sym2 = selector->value.op.op1->symtree->n.sym;
11362 376 : else if (selector->expr_type == EXPR_VARIABLE
11363 13 : || selector->expr_type == EXPR_FUNCTION)
11364 376 : sym2 = selector->symtree->n.sym;
11365 : else
11366 0 : gcc_unreachable ();
11367 : }
11368 : else
11369 : sym2 = NULL;
11370 :
11371 1863 : if (sym1->ts.type == BT_CLASS)
11372 : {
11373 1863 : if ((*expr1)->ts.type != BT_CLASS)
11374 19 : (*expr1)->ts = sym1->ts;
11375 :
11376 1863 : CLASS_DATA (sym1)->attr.dimension = rank > 0 ? 1 : 0;
11377 1863 : CLASS_DATA (sym1)->attr.codimension = corank > 0 ? 1 : 0;
11378 1863 : if (CLASS_DATA (sym1)->as == NULL && sym2)
11379 1 : CLASS_DATA (sym1)->as
11380 1 : = gfc_copy_array_spec (CLASS_DATA (sym2)->as);
11381 : }
11382 : else
11383 : {
11384 0 : sym1->attr.dimension = rank > 0 ? 1 : 0;
11385 0 : sym1->attr.codimension = corank > 0 ? 1 : 0;
11386 0 : if (sym1->as == NULL && sym2)
11387 0 : sym1->as = gfc_copy_array_spec (sym2->as);
11388 : }
11389 :
11390 3342 : for (; nref; nref = nref->next)
11391 2964 : if (nref->next == NULL)
11392 : break;
11393 :
11394 1863 : if (ref && nref && nref->type != REF_ARRAY)
11395 6 : nref->next = gfc_copy_ref (ref);
11396 1857 : else if (ref && !nref)
11397 363 : (*expr1)->ref = gfc_copy_ref (ref);
11398 1494 : else if (ref && nref->u.ar.codimen != corank)
11399 : {
11400 976 : for (int i = nref->u.ar.dimen; i < GFC_MAX_DIMENSIONS; ++i)
11401 915 : nref->u.ar.dimen_type[i] = DIMEN_THIS_IMAGE;
11402 61 : nref->u.ar.codimen = corank;
11403 : }
11404 1863 : }
11405 :
11406 :
11407 : static gfc_expr *
11408 7222 : build_loc_call (gfc_expr *sym_expr)
11409 : {
11410 7222 : gfc_expr *loc_call;
11411 7222 : loc_call = gfc_get_expr ();
11412 7222 : loc_call->expr_type = EXPR_FUNCTION;
11413 7222 : gfc_get_sym_tree ("_loc", gfc_current_ns, &loc_call->symtree, false);
11414 7222 : loc_call->symtree->n.sym->attr.flavor = FL_PROCEDURE;
11415 7222 : loc_call->symtree->n.sym->attr.intrinsic = 1;
11416 7222 : loc_call->symtree->n.sym->result = loc_call->symtree->n.sym;
11417 7222 : gfc_commit_symbol (loc_call->symtree->n.sym);
11418 7222 : loc_call->ts.type = BT_INTEGER;
11419 7222 : loc_call->ts.kind = gfc_index_integer_kind;
11420 7222 : loc_call->value.function.isym = gfc_intrinsic_function_by_id (GFC_ISYM_LOC);
11421 7222 : loc_call->value.function.actual = gfc_get_actual_arglist ();
11422 7222 : loc_call->value.function.actual->expr = sym_expr;
11423 7222 : loc_call->where = sym_expr->where;
11424 7222 : return loc_call;
11425 : }
11426 :
11427 : /* Resolve a SELECT TYPE statement. */
11428 :
11429 : static void
11430 3255 : resolve_select_type (gfc_code *code, gfc_namespace *old_ns)
11431 : {
11432 3255 : gfc_symbol *selector_type;
11433 3255 : gfc_code *body, *new_st, *if_st, *tail;
11434 3255 : gfc_code *class_is = NULL, *default_case = NULL;
11435 3255 : gfc_case *c;
11436 3255 : gfc_symtree *st;
11437 3255 : char name[GFC_MAX_SYMBOL_LEN + 12 + 1];
11438 3255 : gfc_namespace *ns;
11439 3255 : int error = 0;
11440 3255 : int rank = 0, corank = 0;
11441 3255 : gfc_ref* ref = NULL;
11442 3255 : gfc_expr *selector_expr = NULL;
11443 3255 : gfc_code *old_code = code;
11444 :
11445 3255 : ns = code->ext.block.ns;
11446 3255 : if (code->expr2)
11447 : {
11448 : /* Set this, or coarray checks in resolve will fail. */
11449 748 : code->expr1->symtree->n.sym->attr.select_type_temporary = 1;
11450 : }
11451 3255 : gfc_resolve (ns);
11452 :
11453 : /* Check for F03:C813. */
11454 3255 : if (code->expr1->ts.type != BT_CLASS
11455 42 : && !(code->expr2 && code->expr2->ts.type == BT_CLASS))
11456 : {
11457 13 : gfc_error ("Selector shall be polymorphic in SELECT TYPE statement "
11458 : "at %L", &code->loc);
11459 42 : return;
11460 : }
11461 :
11462 : /* Prevent segfault, when class type is not initialized due to previous
11463 : error. */
11464 3242 : if (!code->expr1->symtree->n.sym->attr.class_ok
11465 3240 : || (code->expr1->ts.type == BT_CLASS && !code->expr1->ts.u.derived))
11466 : return;
11467 :
11468 3235 : if (code->expr2)
11469 : {
11470 739 : gfc_ref *ref2 = NULL;
11471 1712 : for (ref = code->expr2->ref; ref != NULL; ref = ref->next)
11472 973 : if (ref->type == REF_COMPONENT
11473 495 : && ref->u.c.component->ts.type == BT_CLASS)
11474 973 : ref2 = ref;
11475 :
11476 739 : if (ref2)
11477 : {
11478 395 : if (code->expr1->symtree->n.sym->attr.untyped)
11479 1 : code->expr1->symtree->n.sym->ts = ref2->u.c.component->ts;
11480 395 : selector_type = CLASS_DATA (ref2->u.c.component)->ts.u.derived;
11481 : }
11482 : else
11483 : {
11484 344 : if (code->expr1->symtree->n.sym->attr.untyped)
11485 34 : code->expr1->symtree->n.sym->ts = code->expr2->ts;
11486 : /* Sometimes the selector expression is given the typespec of the
11487 : '_data' field, which is logical enough but inappropriate here. */
11488 344 : if (code->expr2->ts.type == BT_DERIVED
11489 73 : && code->expr2->symtree
11490 73 : && code->expr2->symtree->n.sym->ts.type == BT_CLASS)
11491 73 : code->expr2->ts = code->expr2->symtree->n.sym->ts;
11492 344 : selector_type = CLASS_DATA (code->expr2)
11493 : ? CLASS_DATA (code->expr2)->ts.u.derived : code->expr2->ts.u.derived;
11494 : }
11495 :
11496 739 : if (code->expr1->ts.type == BT_CLASS && CLASS_DATA (code->expr1)->as)
11497 : {
11498 358 : CLASS_DATA (code->expr1)->as->rank = code->expr2->rank;
11499 358 : CLASS_DATA (code->expr1)->as->corank = code->expr2->corank;
11500 358 : CLASS_DATA (code->expr1)->as->cotype = AS_DEFERRED;
11501 : }
11502 :
11503 : /* F2008: C803 The selector expression must not be coindexed. */
11504 739 : if (gfc_is_coindexed (code->expr2))
11505 : {
11506 4 : gfc_error ("Selector at %L must not be coindexed",
11507 4 : &code->expr2->where);
11508 4 : return;
11509 : }
11510 :
11511 : }
11512 : else
11513 : {
11514 2496 : selector_type = CLASS_DATA (code->expr1)->ts.u.derived;
11515 :
11516 2496 : if (gfc_is_coindexed (code->expr1))
11517 : {
11518 0 : gfc_error ("Selector at %L must not be coindexed",
11519 0 : &code->expr1->where);
11520 0 : return;
11521 : }
11522 : }
11523 :
11524 : /* Loop over TYPE IS / CLASS IS cases. */
11525 8981 : for (body = code->block; body; body = body->block)
11526 : {
11527 5751 : c = body->ext.block.case_list;
11528 :
11529 5751 : if (!error)
11530 : {
11531 : /* Check for repeated cases. */
11532 8878 : for (tail = code->block; tail; tail = tail->block)
11533 : {
11534 8878 : gfc_case *d = tail->ext.block.case_list;
11535 8878 : if (tail == body)
11536 : break;
11537 :
11538 3136 : if (c->ts.type == d->ts.type
11539 540 : && ((c->ts.type == BT_DERIVED
11540 424 : && c->ts.u.derived && d->ts.u.derived
11541 424 : && !strcmp (c->ts.u.derived->name,
11542 : d->ts.u.derived->name))
11543 539 : || c->ts.type == BT_UNKNOWN
11544 539 : || (!(c->ts.type == BT_DERIVED || c->ts.type == BT_CLASS)
11545 55 : && c->ts.kind == d->ts.kind)))
11546 : {
11547 1 : gfc_error ("TYPE IS at %L overlaps with TYPE IS at %L",
11548 : &c->where, &d->where);
11549 1 : return;
11550 : }
11551 : }
11552 : }
11553 :
11554 : /* Check F03:C815. */
11555 3634 : if ((c->ts.type == BT_DERIVED || c->ts.type == BT_CLASS)
11556 2484 : && selector_type
11557 2484 : && !selector_type->attr.unlimited_polymorphic
11558 7875 : && !gfc_type_is_extensible (c->ts.u.derived))
11559 : {
11560 1 : gfc_error ("Derived type %qs at %L must be extensible",
11561 1 : c->ts.u.derived->name, &c->where);
11562 1 : error++;
11563 1 : continue;
11564 : }
11565 :
11566 : /* Check F03:C816. */
11567 5755 : if (c->ts.type != BT_UNKNOWN
11568 4007 : && selector_type && !selector_type->attr.unlimited_polymorphic
11569 7877 : && ((c->ts.type != BT_DERIVED && c->ts.type != BT_CLASS)
11570 2124 : || !gfc_type_is_extension_of (selector_type, c->ts.u.derived)))
11571 : {
11572 6 : if (c->ts.type == BT_DERIVED || c->ts.type == BT_CLASS)
11573 2 : gfc_error ("Derived type %qs at %L must be an extension of %qs",
11574 2 : c->ts.u.derived->name, &c->where, selector_type->name);
11575 : else
11576 4 : gfc_error ("Unexpected intrinsic type %qs at %L",
11577 : gfc_basic_typename (c->ts.type), &c->where);
11578 6 : error++;
11579 6 : continue;
11580 : }
11581 :
11582 : /* Check F03:C814. */
11583 5743 : if (c->ts.type == BT_CHARACTER
11584 754 : && (c->ts.u.cl->length != NULL || c->ts.deferred))
11585 : {
11586 0 : gfc_error ("The type-spec at %L shall specify that each length "
11587 : "type parameter is assumed", &c->where);
11588 0 : error++;
11589 0 : continue;
11590 : }
11591 :
11592 : /* Intercept the DEFAULT case. */
11593 5743 : if (c->ts.type == BT_UNKNOWN)
11594 : {
11595 : /* Check F03:C818. */
11596 1742 : if (default_case)
11597 : {
11598 1 : gfc_error ("The DEFAULT CASE at %L cannot be followed "
11599 : "by a second DEFAULT CASE at %L",
11600 1 : &default_case->ext.block.case_list->where, &c->where);
11601 1 : error++;
11602 1 : continue;
11603 : }
11604 :
11605 : default_case = body;
11606 : }
11607 : }
11608 :
11609 3230 : if (error > 0)
11610 : return;
11611 :
11612 : /* Transform SELECT TYPE statement to BLOCK and associate selector to
11613 : target if present. If there are any EXIT statements referring to the
11614 : SELECT TYPE construct, this is no problem because the gfc_code
11615 : reference stays the same and EXIT is equally possible from the BLOCK
11616 : it is changed to. */
11617 3227 : code->op = EXEC_BLOCK;
11618 3227 : if (code->expr2)
11619 : {
11620 735 : gfc_association_list* assoc;
11621 :
11622 735 : assoc = gfc_get_association_list ();
11623 735 : assoc->st = code->expr1->symtree;
11624 735 : assoc->target = gfc_copy_expr (code->expr2);
11625 735 : assoc->target->where = code->expr2->where;
11626 : /* assoc->variable will be set by resolve_assoc_var. */
11627 :
11628 735 : code->ext.block.assoc = assoc;
11629 735 : code->expr1->symtree->n.sym->assoc = assoc;
11630 :
11631 735 : resolve_assoc_var (code->expr1->symtree->n.sym, false);
11632 : }
11633 : else
11634 2492 : code->ext.block.assoc = NULL;
11635 :
11636 : /* Ensure that the selector rank and arrayspec are available to
11637 : correct expressions in which they might be missing. */
11638 3227 : if (code->expr2 && (code->expr2->rank || code->expr2->corank))
11639 : {
11640 378 : rank = code->expr2->rank;
11641 378 : corank = code->expr2->corank;
11642 692 : for (ref = code->expr2->ref; ref; ref = ref->next)
11643 677 : if (ref->next == NULL)
11644 : break;
11645 378 : if (ref && ref->type == REF_ARRAY)
11646 363 : ref = gfc_copy_ref (ref);
11647 :
11648 : /* Fixup expr1 if necessary. */
11649 378 : if (rank || corank)
11650 378 : fixup_array_ref (&code->expr1, code->expr2, rank, corank, ref);
11651 : }
11652 2849 : else if (code->expr1->rank || code->expr1->corank)
11653 : {
11654 928 : rank = code->expr1->rank;
11655 928 : corank = code->expr1->corank;
11656 928 : for (ref = code->expr1->ref; ref; ref = ref->next)
11657 928 : if (ref->next == NULL)
11658 : break;
11659 928 : if (ref && ref->type == REF_ARRAY)
11660 928 : ref = gfc_copy_ref (ref);
11661 : }
11662 :
11663 3227 : gfc_expr *orig_expr1 = code->expr1;
11664 :
11665 : /* Add EXEC_SELECT to switch on type. */
11666 3227 : new_st = gfc_get_code (code->op);
11667 3227 : new_st->expr1 = code->expr1;
11668 3227 : new_st->expr2 = code->expr2;
11669 3227 : new_st->block = code->block;
11670 3227 : code->expr1 = code->expr2 = NULL;
11671 3227 : code->block = NULL;
11672 3227 : if (!ns->code)
11673 3227 : ns->code = new_st;
11674 : else
11675 0 : ns->code->next = new_st;
11676 3227 : code = new_st;
11677 3227 : code->op = EXEC_SELECT_TYPE;
11678 :
11679 : /* Use the intrinsic LOC function to generate an integer expression
11680 : for the vtable of the selector. Note that the rank of the selector
11681 : expression has to be set to zero. */
11682 3227 : gfc_add_vptr_component (code->expr1);
11683 3227 : code->expr1->rank = 0;
11684 3227 : code->expr1->corank = 0;
11685 3227 : code->expr1 = build_loc_call (code->expr1);
11686 3227 : selector_expr = code->expr1->value.function.actual->expr;
11687 :
11688 : /* Loop over TYPE IS / CLASS IS cases. */
11689 8962 : for (body = code->block; body; body = body->block)
11690 : {
11691 5735 : gfc_symbol *vtab;
11692 5735 : c = body->ext.block.case_list;
11693 :
11694 : /* Generate an index integer expression for address of the
11695 : TYPE/CLASS vtable and store it in c->low. The hash expression
11696 : is stored in c->high and is used to resolve intrinsic cases. */
11697 5735 : if (c->ts.type != BT_UNKNOWN)
11698 : {
11699 3995 : gfc_expr *e;
11700 3995 : if (c->ts.type == BT_DERIVED || c->ts.type == BT_CLASS)
11701 : {
11702 2475 : vtab = gfc_find_derived_vtab (c->ts.u.derived);
11703 2475 : gcc_assert (vtab);
11704 2475 : c->high = gfc_get_int_expr (gfc_integer_4_kind, NULL,
11705 2475 : c->ts.u.derived->hash_value);
11706 : }
11707 : else
11708 : {
11709 1520 : vtab = gfc_find_vtab (&c->ts);
11710 1520 : gcc_assert (vtab && CLASS_DATA (vtab)->initializer);
11711 1520 : e = CLASS_DATA (vtab)->initializer;
11712 1520 : c->high = gfc_copy_expr (e);
11713 1520 : if (c->high->ts.kind != gfc_integer_4_kind)
11714 : {
11715 1 : gfc_typespec ts;
11716 1 : ts.kind = gfc_integer_4_kind;
11717 1 : ts.type = BT_INTEGER;
11718 1 : gfc_convert_type_warn (c->high, &ts, 2, 0);
11719 : }
11720 : }
11721 :
11722 3995 : e = gfc_lval_expr_from_sym (vtab);
11723 3995 : c->low = build_loc_call (e);
11724 : }
11725 : else
11726 1740 : continue;
11727 :
11728 : /* Associate temporary to selector. This should only be done
11729 : when this case is actually true, so build a new ASSOCIATE
11730 : that does precisely this here (instead of using the
11731 : 'global' one). */
11732 :
11733 : /* First check the derived type import status. */
11734 3995 : if (gfc_current_ns->import_state != IMPORT_NOT_SET
11735 6 : && (c->ts.type == BT_DERIVED || c->ts.type == BT_CLASS))
11736 : {
11737 12 : st = gfc_find_symtree (gfc_current_ns->sym_root,
11738 6 : c->ts.u.derived->name);
11739 6 : if (!check_sym_import_status (c->ts.u.derived, st, NULL, old_code,
11740 : gfc_current_ns))
11741 6 : error++;
11742 : }
11743 :
11744 3995 : const char * var_name = gfc_var_name_for_select_type_temp (orig_expr1);
11745 3995 : if (c->ts.type == BT_CLASS)
11746 366 : snprintf (name, sizeof (name), "__tmp_class_%s_%s",
11747 366 : c->ts.u.derived->name, var_name);
11748 3629 : else if (c->ts.type == BT_DERIVED)
11749 2109 : snprintf (name, sizeof (name), "__tmp_type_%s_%s",
11750 2109 : c->ts.u.derived->name, var_name);
11751 1520 : else if (c->ts.type == BT_CHARACTER)
11752 : {
11753 754 : HOST_WIDE_INT charlen = 0;
11754 754 : if (c->ts.u.cl && c->ts.u.cl->length
11755 0 : && c->ts.u.cl->length->expr_type == EXPR_CONSTANT)
11756 0 : charlen = gfc_mpz_get_hwi (c->ts.u.cl->length->value.integer);
11757 754 : snprintf (name, sizeof (name),
11758 : "__tmp_%s_" HOST_WIDE_INT_PRINT_DEC "_%d_%s",
11759 : gfc_basic_typename (c->ts.type), charlen, c->ts.kind,
11760 : var_name);
11761 : }
11762 : else
11763 766 : snprintf (name, sizeof (name), "__tmp_%s_%d_%s",
11764 : gfc_basic_typename (c->ts.type), c->ts.kind, var_name);
11765 :
11766 3995 : st = gfc_find_symtree (ns->sym_root, name);
11767 3995 : gcc_assert (st->n.sym->assoc);
11768 3995 : st->n.sym->assoc->target = gfc_get_variable_expr (selector_expr->symtree);
11769 3995 : st->n.sym->assoc->target->where = selector_expr->where;
11770 3995 : if (c->ts.type != BT_CLASS && c->ts.type != BT_UNKNOWN)
11771 : {
11772 3629 : gfc_add_data_component (st->n.sym->assoc->target);
11773 : /* Fixup the target expression if necessary. */
11774 3629 : if (rank || corank)
11775 1485 : fixup_array_ref (&st->n.sym->assoc->target, nullptr, rank, corank,
11776 : ref);
11777 : }
11778 :
11779 3995 : new_st = gfc_get_code (EXEC_BLOCK);
11780 3995 : new_st->ext.block.ns = gfc_build_block_ns (ns);
11781 3995 : new_st->ext.block.ns->code = body->next;
11782 3995 : body->next = new_st;
11783 :
11784 : /* Chain in the new list only if it is marked as dangling. Otherwise
11785 : there is a CASE label overlap and this is already used. Just ignore,
11786 : the error is diagnosed elsewhere. */
11787 3995 : if (st->n.sym->assoc->dangling)
11788 : {
11789 3994 : new_st->ext.block.assoc = st->n.sym->assoc;
11790 3994 : st->n.sym->assoc->dangling = 0;
11791 : }
11792 :
11793 3995 : resolve_assoc_var (st->n.sym, false);
11794 : }
11795 :
11796 : /* Take out CLASS IS cases for separate treatment. */
11797 : body = code;
11798 8962 : while (body && body->block)
11799 : {
11800 5735 : if (body->block->ext.block.case_list->ts.type == BT_CLASS)
11801 : {
11802 : /* Add to class_is list. */
11803 366 : if (class_is == NULL)
11804 : {
11805 323 : class_is = body->block;
11806 323 : tail = class_is;
11807 : }
11808 : else
11809 : {
11810 61 : for (tail = class_is; tail->block; tail = tail->block) ;
11811 43 : tail->block = body->block;
11812 43 : tail = tail->block;
11813 : }
11814 : /* Remove from EXEC_SELECT list. */
11815 366 : body->block = body->block->block;
11816 366 : tail->block = NULL;
11817 : }
11818 : else
11819 : body = body->block;
11820 : }
11821 :
11822 3227 : if (class_is)
11823 : {
11824 323 : gfc_symbol *vtab;
11825 :
11826 323 : if (!default_case)
11827 : {
11828 : /* Add a default case to hold the CLASS IS cases. */
11829 321 : for (tail = code; tail->block; tail = tail->block) ;
11830 213 : tail->block = gfc_get_code (EXEC_SELECT_TYPE);
11831 213 : tail = tail->block;
11832 213 : tail->ext.block.case_list = gfc_get_case ();
11833 213 : tail->ext.block.case_list->ts.type = BT_UNKNOWN;
11834 213 : tail->next = NULL;
11835 213 : default_case = tail;
11836 : }
11837 :
11838 : /* More than one CLASS IS block? */
11839 323 : if (class_is->block)
11840 : {
11841 43 : gfc_code **c1,*c2;
11842 43 : bool swapped;
11843 : /* Sort CLASS IS blocks by extension level. */
11844 42 : do
11845 : {
11846 43 : swapped = false;
11847 115 : for (c1 = &class_is; (*c1) && (*c1)->block; c1 = &((*c1)->block))
11848 : {
11849 : #define C1_DERIVED (*c1)->ext.block.case_list->ts.u.derived
11850 : #define C2_DERIVED c2->ext.block.case_list->ts.u.derived
11851 73 : c2 = (*c1)->block;
11852 :
11853 : /* F03:C817 (check for doubles). */
11854 73 : if (C1_DERIVED->hash_value == C2_DERIVED->hash_value)
11855 : {
11856 1 : gfc_error ("Double CLASS IS block in SELECT TYPE "
11857 : "statement at %L",
11858 : &c2->ext.block.case_list->where);
11859 1 : return;
11860 : }
11861 : #undef C1_DERIVED
11862 : #undef C2_DERIVED
11863 72 : if ((*c1)->ext.block.case_list->ts.u.derived->attr.extension
11864 72 : < c2->ext.block.case_list->ts.u.derived->attr.extension)
11865 : {
11866 : /* Swap. */
11867 24 : (*c1)->block = c2->block;
11868 24 : c2->block = *c1;
11869 24 : *c1 = c2;
11870 24 : swapped = true;
11871 : }
11872 : }
11873 : }
11874 : while (swapped);
11875 : }
11876 :
11877 : /* Generate IF chain. */
11878 322 : if_st = gfc_get_code (EXEC_IF);
11879 322 : new_st = if_st;
11880 686 : for (body = class_is; body; body = body->block)
11881 : {
11882 364 : new_st->block = gfc_get_code (EXEC_IF);
11883 364 : new_st = new_st->block;
11884 : /* Set up IF condition: Call _gfortran_is_extension_of. */
11885 364 : new_st->expr1 = gfc_get_expr ();
11886 364 : new_st->expr1->expr_type = EXPR_FUNCTION;
11887 364 : new_st->expr1->ts.type = BT_LOGICAL;
11888 364 : new_st->expr1->ts.kind = 4;
11889 364 : new_st->expr1->value.function.name = gfc_get_string (PREFIX ("is_extension_of"));
11890 364 : new_st->expr1->value.function.isym = XCNEW (gfc_intrinsic_sym);
11891 364 : new_st->expr1->value.function.isym->id = GFC_ISYM_EXTENDS_TYPE_OF;
11892 : /* Set up arguments. */
11893 364 : new_st->expr1->value.function.actual = gfc_get_actual_arglist ();
11894 364 : new_st->expr1->value.function.actual->expr = gfc_get_variable_expr (selector_expr->symtree);
11895 364 : new_st->expr1->value.function.actual->expr->where = code->loc;
11896 364 : new_st->expr1->where = code->loc;
11897 364 : gfc_add_vptr_component (new_st->expr1->value.function.actual->expr);
11898 364 : vtab = gfc_find_derived_vtab (body->ext.block.case_list->ts.u.derived);
11899 364 : st = gfc_find_symtree (vtab->ns->sym_root, vtab->name);
11900 364 : new_st->expr1->value.function.actual->next = gfc_get_actual_arglist ();
11901 364 : new_st->expr1->value.function.actual->next->expr = gfc_get_variable_expr (st);
11902 364 : new_st->expr1->value.function.actual->next->expr->where = code->loc;
11903 : /* Set up types in formal arg list. */
11904 364 : new_st->expr1->value.function.isym->formal = XCNEW (gfc_intrinsic_arg);
11905 364 : new_st->expr1->value.function.isym->formal->ts = new_st->expr1->value.function.actual->expr->ts;
11906 364 : new_st->expr1->value.function.isym->formal->next = XCNEW (gfc_intrinsic_arg);
11907 364 : new_st->expr1->value.function.isym->formal->next->ts = new_st->expr1->value.function.actual->next->expr->ts;
11908 :
11909 364 : new_st->next = body->next;
11910 : }
11911 322 : if (default_case->next)
11912 : {
11913 110 : new_st->block = gfc_get_code (EXEC_IF);
11914 110 : new_st = new_st->block;
11915 110 : new_st->next = default_case->next;
11916 : }
11917 :
11918 : /* Replace CLASS DEFAULT code by the IF chain. */
11919 322 : default_case->next = if_st;
11920 : }
11921 :
11922 : /* Resolve the internal code. This cannot be done earlier because
11923 : it requires that the sym->assoc of selectors is set already. */
11924 3226 : gfc_current_ns = ns;
11925 3226 : gfc_resolve_blocks (code->block, gfc_current_ns);
11926 3226 : gfc_current_ns = old_ns;
11927 :
11928 3226 : free (ref);
11929 : }
11930 :
11931 :
11932 : /* Resolve a SELECT RANK statement. */
11933 :
11934 : static void
11935 1048 : resolve_select_rank (gfc_code *code, gfc_namespace *old_ns)
11936 : {
11937 1048 : gfc_namespace *ns;
11938 1048 : gfc_code *body, *new_st, *tail;
11939 1048 : gfc_case *c;
11940 1048 : char tname[GFC_MAX_SYMBOL_LEN + 7];
11941 1048 : char name[2 * GFC_MAX_SYMBOL_LEN];
11942 1048 : gfc_symtree *st;
11943 1048 : gfc_expr *selector_expr = NULL;
11944 1048 : int case_value;
11945 1048 : HOST_WIDE_INT charlen = 0;
11946 :
11947 1048 : ns = code->ext.block.ns;
11948 1048 : gfc_resolve (ns);
11949 :
11950 1048 : code->op = EXEC_BLOCK;
11951 1048 : if (code->expr2)
11952 : {
11953 42 : gfc_association_list* assoc;
11954 :
11955 42 : assoc = gfc_get_association_list ();
11956 42 : assoc->st = code->expr1->symtree;
11957 42 : assoc->target = gfc_copy_expr (code->expr2);
11958 42 : assoc->target->where = code->expr2->where;
11959 : /* assoc->variable will be set by resolve_assoc_var. */
11960 :
11961 42 : code->ext.block.assoc = assoc;
11962 42 : code->expr1->symtree->n.sym->assoc = assoc;
11963 :
11964 42 : resolve_assoc_var (code->expr1->symtree->n.sym, false);
11965 : }
11966 : else
11967 1006 : code->ext.block.assoc = NULL;
11968 :
11969 : /* Loop over RANK cases. Note that returning on the errors causes a
11970 : cascade of further errors because the case blocks do not compile
11971 : correctly. */
11972 3416 : for (body = code->block; body; body = body->block)
11973 : {
11974 2368 : c = body->ext.block.case_list;
11975 2368 : if (c->low)
11976 1425 : case_value = (int) mpz_get_si (c->low->value.integer);
11977 : else
11978 : case_value = -2;
11979 :
11980 : /* Check for repeated cases. */
11981 5950 : for (tail = code->block; tail; tail = tail->block)
11982 : {
11983 5950 : gfc_case *d = tail->ext.block.case_list;
11984 5950 : int case_value2;
11985 :
11986 5950 : if (tail == body)
11987 : break;
11988 :
11989 : /* Check F2018: C1153. */
11990 3582 : if (!c->low && !d->low)
11991 1 : gfc_error ("RANK DEFAULT at %L is repeated at %L",
11992 : &c->where, &d->where);
11993 :
11994 3582 : if (!c->low || !d->low)
11995 1289 : continue;
11996 :
11997 : /* Check F2018: C1153. */
11998 2293 : case_value2 = (int) mpz_get_si (d->low->value.integer);
11999 2293 : if ((case_value == case_value2) && case_value == -1)
12000 1 : gfc_error ("RANK (*) at %L is repeated at %L",
12001 : &c->where, &d->where);
12002 2292 : else if (case_value == case_value2)
12003 1 : gfc_error ("RANK (%i) at %L is repeated at %L",
12004 : case_value, &c->where, &d->where);
12005 : }
12006 :
12007 2368 : if (!c->low)
12008 943 : continue;
12009 :
12010 : /* Check F2018: C1155. */
12011 1425 : if (case_value == -1 && (gfc_expr_attr (code->expr1).allocatable
12012 1425 : || gfc_expr_attr (code->expr1).pointer))
12013 3 : gfc_error ("RANK (*) at %L cannot be used with the pointer or "
12014 3 : "allocatable selector at %L", &c->where, &code->expr1->where);
12015 : }
12016 :
12017 : /* Add EXEC_SELECT to switch on rank. */
12018 1048 : new_st = gfc_get_code (code->op);
12019 1048 : new_st->expr1 = code->expr1;
12020 1048 : new_st->expr2 = code->expr2;
12021 1048 : new_st->block = code->block;
12022 1048 : code->expr1 = code->expr2 = NULL;
12023 1048 : code->block = NULL;
12024 1048 : if (!ns->code)
12025 1048 : ns->code = new_st;
12026 : else
12027 0 : ns->code->next = new_st;
12028 1048 : code = new_st;
12029 1048 : code->op = EXEC_SELECT_RANK;
12030 :
12031 1048 : selector_expr = code->expr1;
12032 :
12033 : /* Loop over SELECT RANK cases. */
12034 3416 : for (body = code->block; body; body = body->block)
12035 : {
12036 2368 : c = body->ext.block.case_list;
12037 2368 : int case_value;
12038 :
12039 : /* Pass on the default case. */
12040 2368 : if (c->low == NULL)
12041 943 : continue;
12042 :
12043 : /* Associate temporary to selector. This should only be done
12044 : when this case is actually true, so build a new ASSOCIATE
12045 : that does precisely this here (instead of using the
12046 : 'global' one). */
12047 1425 : if (c->ts.type == BT_CHARACTER && c->ts.u.cl && c->ts.u.cl->length
12048 265 : && c->ts.u.cl->length->expr_type == EXPR_CONSTANT)
12049 186 : charlen = gfc_mpz_get_hwi (c->ts.u.cl->length->value.integer);
12050 :
12051 1425 : if (c->ts.type == BT_CLASS)
12052 145 : sprintf (tname, "class_%s", c->ts.u.derived->name);
12053 1280 : else if (c->ts.type == BT_DERIVED)
12054 116 : sprintf (tname, "type_%s", c->ts.u.derived->name);
12055 1164 : else if (c->ts.type != BT_CHARACTER)
12056 605 : sprintf (tname, "%s_%d", gfc_basic_typename (c->ts.type), c->ts.kind);
12057 : else
12058 559 : sprintf (tname, "%s_" HOST_WIDE_INT_PRINT_DEC "_%d",
12059 : gfc_basic_typename (c->ts.type), charlen, c->ts.kind);
12060 :
12061 1425 : case_value = (int) mpz_get_si (c->low->value.integer);
12062 1425 : if (case_value >= 0)
12063 1392 : sprintf (name, "__tmp_%s_rank_%d", tname, case_value);
12064 : else
12065 33 : sprintf (name, "__tmp_%s_rank_m%d", tname, -case_value);
12066 :
12067 1425 : st = gfc_find_symtree (ns->sym_root, name);
12068 1425 : gcc_assert (st->n.sym->assoc);
12069 :
12070 1425 : st->n.sym->assoc->target = gfc_get_variable_expr (selector_expr->symtree);
12071 1425 : st->n.sym->assoc->target->where = selector_expr->where;
12072 :
12073 1425 : new_st = gfc_get_code (EXEC_BLOCK);
12074 1425 : new_st->ext.block.ns = gfc_build_block_ns (ns);
12075 1425 : new_st->ext.block.ns->code = body->next;
12076 1425 : body->next = new_st;
12077 :
12078 : /* Chain in the new list only if it is marked as dangling. Otherwise
12079 : there is a CASE label overlap and this is already used. Just ignore,
12080 : the error is diagnosed elsewhere. */
12081 1425 : if (st->n.sym->assoc->dangling)
12082 : {
12083 1423 : new_st->ext.block.assoc = st->n.sym->assoc;
12084 1423 : st->n.sym->assoc->dangling = 0;
12085 : }
12086 :
12087 1425 : resolve_assoc_var (st->n.sym, false);
12088 : }
12089 :
12090 1048 : gfc_current_ns = ns;
12091 1048 : gfc_resolve_blocks (code->block, gfc_current_ns);
12092 1048 : gfc_current_ns = old_ns;
12093 1048 : }
12094 :
12095 :
12096 : /* Resolve a transfer statement. This is making sure that:
12097 : -- a derived type being transferred has only non-pointer components
12098 : -- a derived type being transferred doesn't have private components, unless
12099 : it's being transferred from the module where the type was defined
12100 : -- we're not trying to transfer a whole assumed size array. */
12101 :
12102 : static void
12103 48047 : resolve_transfer (gfc_code *code)
12104 : {
12105 48047 : gfc_symbol *sym, *derived;
12106 48047 : gfc_ref *ref;
12107 48047 : gfc_expr *exp;
12108 48047 : bool write = false;
12109 48047 : bool formatted = false;
12110 48047 : gfc_dt *dt = code->ext.dt;
12111 48047 : gfc_symbol *dtio_sub = NULL;
12112 :
12113 48047 : exp = code->expr1;
12114 :
12115 96100 : while (exp != NULL && exp->expr_type == EXPR_OP
12116 48987 : && exp->value.op.op == INTRINSIC_PARENTHESES)
12117 6 : exp = exp->value.op.op1;
12118 :
12119 48047 : if (exp && exp->expr_type == EXPR_NULL
12120 2 : && code->ext.dt)
12121 : {
12122 2 : gfc_error ("Invalid context for NULL () intrinsic at %L",
12123 : &exp->where);
12124 2 : return;
12125 : }
12126 :
12127 48045 : if (dt && (dt->dt_io_kind->value.iokind == M_WRITE
12128 47893 : || dt->dt_io_kind->value.iokind == M_PRINT))
12129 40239 : gfc_value_used_expr (exp, VALUE_USED);
12130 :
12131 48045 : if (exp == NULL || (exp->expr_type != EXPR_VARIABLE
12132 : && exp->expr_type != EXPR_FUNCTION
12133 : && exp->expr_type != EXPR_ARRAY
12134 : && exp->expr_type != EXPR_STRUCTURE))
12135 : return;
12136 :
12137 26690 : if (dt && dt->dt_io_kind->value.iokind == M_READ)
12138 : {
12139 : /* If we are reading, the variable will be changed. Note that
12140 : code->ext.dt may be NULL if the TRANSFER is related to an INQUIRE
12141 : statement -- but in this case, we are not reading, either. */
12142 7654 : if (!gfc_check_vardef_context (exp, false, false, false,
12143 7654 : _("item in READ")))
12144 : return;
12145 :
12146 7650 : gfc_expr_set_at (exp, &exp->where, VALUE_READ);
12147 : }
12148 :
12149 26686 : const gfc_typespec *ts = exp->expr_type == EXPR_STRUCTURE
12150 26686 : || exp->expr_type == EXPR_FUNCTION
12151 22235 : || exp->expr_type == EXPR_ARRAY
12152 48921 : ? &exp->ts : &exp->symtree->n.sym->ts;
12153 :
12154 : /* Go to actual component transferred. */
12155 34597 : for (ref = exp->ref; ref; ref = ref->next)
12156 7911 : if (ref->type == REF_COMPONENT)
12157 2229 : ts = &ref->u.c.component->ts;
12158 :
12159 26686 : if (dt && dt->dt_io_kind->value.iokind != M_INQUIRE
12160 26538 : && (ts->type == BT_DERIVED || ts->type == BT_CLASS))
12161 : {
12162 720 : derived = ts->u.derived;
12163 :
12164 : /* Determine when to use the formatted DTIO procedure. */
12165 720 : if (dt && (dt->format_expr || dt->format_label))
12166 645 : formatted = true;
12167 :
12168 720 : write = dt->dt_io_kind->value.iokind == M_WRITE
12169 720 : || dt->dt_io_kind->value.iokind == M_PRINT;
12170 720 : dtio_sub = gfc_find_specific_dtio_proc (derived, write, formatted);
12171 :
12172 720 : if (dtio_sub != NULL && exp->expr_type == EXPR_VARIABLE)
12173 : {
12174 450 : dt->udtio = exp;
12175 450 : sym = exp->symtree->n.sym->ns->proc_name;
12176 : /* Check to see if this is a nested DTIO call, with the
12177 : dummy as the io-list object. */
12178 450 : if (sym && sym == dtio_sub && sym->formal
12179 30 : && sym->formal->sym == exp->symtree->n.sym
12180 30 : && exp->ref == NULL)
12181 : {
12182 0 : if (!sym->attr.recursive)
12183 : {
12184 0 : gfc_error ("DTIO %s procedure at %L must be recursive",
12185 : sym->name, &sym->declared_at);
12186 0 : return;
12187 : }
12188 : }
12189 : }
12190 : }
12191 :
12192 26686 : if (ts->type == BT_CLASS && dtio_sub == NULL)
12193 : {
12194 3 : gfc_error ("Data transfer element at %L cannot be polymorphic unless "
12195 : "it is processed by a defined input/output procedure",
12196 : &code->loc);
12197 3 : return;
12198 : }
12199 :
12200 26683 : if (ts->type == BT_DERIVED)
12201 : {
12202 : /* Check that transferred derived type doesn't contain POINTER
12203 : components unless it is processed by a defined input/output
12204 : procedure". */
12205 688 : if (ts->u.derived->attr.pointer_comp && dtio_sub == NULL)
12206 : {
12207 2 : gfc_error ("Data transfer element at %L cannot have POINTER "
12208 : "components unless it is processed by a defined "
12209 : "input/output procedure", &code->loc);
12210 2 : return;
12211 : }
12212 :
12213 : /* F08:C935. */
12214 686 : if (ts->u.derived->attr.proc_pointer_comp)
12215 : {
12216 2 : gfc_error ("Data transfer element at %L cannot have "
12217 : "procedure pointer components", &code->loc);
12218 2 : return;
12219 : }
12220 :
12221 684 : if (ts->u.derived->attr.alloc_comp && dtio_sub == NULL)
12222 : {
12223 6 : gfc_error ("Data transfer element at %L cannot have ALLOCATABLE "
12224 : "components unless it is processed by a defined "
12225 : "input/output procedure", &code->loc);
12226 6 : return;
12227 : }
12228 :
12229 : /* C_PTR and C_FUNPTR have private components which means they cannot
12230 : be printed. However, if -std=gnu and not -pedantic, allow
12231 : the component to be printed to help debugging. */
12232 678 : if (ts->u.derived->ts.f90_type == BT_VOID)
12233 : {
12234 4 : gfc_error ("Data transfer element at %L "
12235 : "cannot have PRIVATE components", &code->loc);
12236 4 : return;
12237 : }
12238 674 : else if (derived_inaccessible (ts->u.derived) && dtio_sub == NULL)
12239 : {
12240 4 : gfc_error ("Data transfer element at %L cannot have "
12241 : "PRIVATE components unless it is processed by "
12242 : "a defined input/output procedure", &code->loc);
12243 4 : return;
12244 : }
12245 : }
12246 :
12247 26665 : if (exp->expr_type == EXPR_STRUCTURE)
12248 : return;
12249 :
12250 26620 : if (exp->expr_type == EXPR_ARRAY)
12251 : return;
12252 :
12253 26238 : sym = exp->symtree->n.sym;
12254 :
12255 26238 : if (sym->as != NULL && sym->as->type == AS_ASSUMED_SIZE && exp->ref
12256 81 : && exp->ref->type == REF_ARRAY && exp->ref->u.ar.type == AR_FULL)
12257 : {
12258 1 : gfc_error ("Data transfer element at %L cannot be a full reference to "
12259 : "an assumed-size array", &code->loc);
12260 1 : return;
12261 : }
12262 :
12263 : }
12264 :
12265 :
12266 : /*********** Toplevel code resolution subroutines ***********/
12267 :
12268 : /* Find the set of labels that are reachable from this block. We also
12269 : record the last statement in each block. */
12270 :
12271 : static void
12272 712427 : find_reachable_labels (gfc_code *block)
12273 : {
12274 712427 : gfc_code *c;
12275 :
12276 712427 : if (!block)
12277 : return;
12278 :
12279 438559 : cs_base->reachable_labels = bitmap_alloc (&labels_obstack);
12280 :
12281 : /* Collect labels in this block. We don't keep those corresponding
12282 : to END {IF|SELECT}, these are checked in resolve_branch by going
12283 : up through the code_stack. */
12284 1605029 : for (c = block; c; c = c->next)
12285 : {
12286 1166470 : if (c->here && c->op != EXEC_END_NESTED_BLOCK)
12287 3716 : bitmap_set_bit (cs_base->reachable_labels, c->here->value);
12288 : }
12289 :
12290 : /* Merge with labels from parent block. */
12291 438559 : if (cs_base->prev)
12292 : {
12293 359302 : gcc_assert (cs_base->prev->reachable_labels);
12294 359302 : bitmap_ior_into (cs_base->reachable_labels,
12295 : cs_base->prev->reachable_labels);
12296 : }
12297 : }
12298 :
12299 : static void
12300 197 : resolve_lock_unlock_event (gfc_code *code)
12301 : {
12302 197 : if ((code->op == EXEC_LOCK || code->op == EXEC_UNLOCK)
12303 197 : && (code->expr1->ts.type != BT_DERIVED
12304 137 : || code->expr1->expr_type != EXPR_VARIABLE
12305 137 : || code->expr1->ts.u.derived->from_intmod != INTMOD_ISO_FORTRAN_ENV
12306 136 : || code->expr1->ts.u.derived->intmod_sym_id != ISOFORTRAN_LOCK_TYPE
12307 136 : || code->expr1->rank != 0
12308 181 : || (!gfc_is_coarray (code->expr1) &&
12309 46 : !gfc_is_coindexed (code->expr1))))
12310 4 : gfc_error ("Lock variable at %L must be a scalar of type LOCK_TYPE",
12311 4 : &code->expr1->where);
12312 193 : else if ((code->op == EXEC_EVENT_POST || code->op == EXEC_EVENT_WAIT)
12313 58 : && (code->expr1->ts.type != BT_DERIVED
12314 58 : || code->expr1->expr_type != EXPR_VARIABLE
12315 58 : || code->expr1->ts.u.derived->from_intmod
12316 : != INTMOD_ISO_FORTRAN_ENV
12317 58 : || code->expr1->ts.u.derived->intmod_sym_id
12318 : != ISOFORTRAN_EVENT_TYPE
12319 58 : || code->expr1->rank != 0))
12320 0 : gfc_error ("Event variable at %L must be a scalar of type EVENT_TYPE",
12321 : &code->expr1->where);
12322 34 : else if (code->op == EXEC_EVENT_POST && !gfc_is_coarray (code->expr1)
12323 209 : && !gfc_is_coindexed (code->expr1))
12324 0 : gfc_error ("Event variable argument at %L must be a coarray or coindexed",
12325 0 : &code->expr1->where);
12326 193 : else if (code->op == EXEC_EVENT_WAIT && !gfc_is_coarray (code->expr1))
12327 0 : gfc_error ("Event variable argument at %L must be a coarray but not "
12328 0 : "coindexed", &code->expr1->where);
12329 :
12330 : /* Check STAT. */
12331 197 : if (code->expr2
12332 54 : && (code->expr2->ts.type != BT_INTEGER || code->expr2->rank != 0
12333 54 : || code->expr2->expr_type != EXPR_VARIABLE))
12334 0 : gfc_error ("STAT= argument at %L must be a scalar INTEGER variable",
12335 : &code->expr2->where);
12336 :
12337 197 : if (code->expr2
12338 251 : && !gfc_check_vardef_context (code->expr2, false, false, false,
12339 54 : _("STAT variable")))
12340 : return;
12341 :
12342 : /* Check ERRMSG. */
12343 197 : if (code->expr3
12344 2 : && (code->expr3->ts.type != BT_CHARACTER || code->expr3->rank != 0
12345 2 : || code->expr3->expr_type != EXPR_VARIABLE))
12346 0 : gfc_error ("ERRMSG= argument at %L must be a scalar CHARACTER variable",
12347 : &code->expr3->where);
12348 :
12349 197 : if (code->expr3
12350 199 : && !gfc_check_vardef_context (code->expr3, false, false, false,
12351 2 : _("ERRMSG variable")))
12352 : return;
12353 :
12354 : /* Check for LOCK the ACQUIRED_LOCK. */
12355 197 : if (code->op != EXEC_EVENT_WAIT && code->expr4
12356 22 : && (code->expr4->ts.type != BT_LOGICAL || code->expr4->rank != 0
12357 22 : || code->expr4->expr_type != EXPR_VARIABLE))
12358 0 : gfc_error ("ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL "
12359 : "variable", &code->expr4->where);
12360 :
12361 173 : if (code->op != EXEC_EVENT_WAIT && code->expr4
12362 219 : && !gfc_check_vardef_context (code->expr4, false, false, false,
12363 22 : _("ACQUIRED_LOCK variable")))
12364 : return;
12365 :
12366 : /* Check for EVENT WAIT the UNTIL_COUNT. */
12367 197 : if (code->op == EXEC_EVENT_WAIT && code->expr4)
12368 : {
12369 36 : if (!gfc_resolve_expr (code->expr4) || code->expr4->ts.type != BT_INTEGER
12370 36 : || code->expr4->rank != 0)
12371 0 : gfc_error ("UNTIL_COUNT= argument at %L must be a scalar INTEGER "
12372 0 : "expression", &code->expr4->where);
12373 : }
12374 : }
12375 :
12376 : static void
12377 363 : resolve_team_argument (gfc_expr *team)
12378 : {
12379 363 : gfc_resolve_expr (team);
12380 363 : if (team->rank != 0 || team->ts.type != BT_DERIVED
12381 356 : || team->ts.u.derived->from_intmod != INTMOD_ISO_FORTRAN_ENV
12382 356 : || team->ts.u.derived->intmod_sym_id != ISOFORTRAN_TEAM_TYPE)
12383 : {
12384 7 : gfc_error ("TEAM argument at %L must be a scalar expression "
12385 : "of type TEAM_TYPE from the intrinsic module ISO_FORTRAN_ENV",
12386 : &team->where);
12387 : }
12388 363 : }
12389 :
12390 : static void
12391 1720 : resolve_scalar_variable_as_arg (const char *name, bt exp_type, int exp_kind,
12392 : gfc_expr *e)
12393 : {
12394 1720 : gfc_resolve_expr (e);
12395 1720 : if (e
12396 167 : && (e->ts.type != exp_type || e->ts.kind < exp_kind || e->rank != 0
12397 152 : || e->expr_type != EXPR_VARIABLE))
12398 15 : gfc_error ("%s argument at %L must be a scalar %s variable of at least "
12399 : "kind %d", name, &e->where, gfc_basic_typename (exp_type),
12400 : exp_kind);
12401 1720 : }
12402 :
12403 : void
12404 860 : gfc_resolve_sync_stat (struct sync_stat *sync_stat)
12405 : {
12406 860 : resolve_scalar_variable_as_arg ("STAT=", BT_INTEGER, 2, sync_stat->stat);
12407 860 : resolve_scalar_variable_as_arg ("ERRMSG=", BT_CHARACTER,
12408 : gfc_default_character_kind,
12409 : sync_stat->errmsg);
12410 860 : }
12411 :
12412 : static void
12413 368 : resolve_scalar_argument (const char *name, bt exp_type, int exp_kind,
12414 : gfc_expr *e)
12415 : {
12416 368 : gfc_resolve_expr (e);
12417 368 : if (e
12418 217 : && (e->ts.type != exp_type || e->ts.kind < exp_kind || e->rank != 0))
12419 3 : gfc_error ("%s argument at %L must be a scalar %s of at least kind %d",
12420 : name, &e->where, gfc_basic_typename (exp_type), exp_kind);
12421 368 : }
12422 :
12423 : static void
12424 184 : resolve_form_team (gfc_code *code)
12425 : {
12426 184 : resolve_scalar_argument ("TEAM NUMBER", BT_INTEGER, gfc_default_integer_kind,
12427 : code->expr1);
12428 184 : resolve_team_argument (code->expr2);
12429 184 : resolve_scalar_argument ("NEW_INDEX=", BT_INTEGER, gfc_default_integer_kind,
12430 : code->expr3);
12431 184 : gfc_resolve_sync_stat (&code->ext.sync_stat);
12432 184 : }
12433 :
12434 : static void resolve_block_construct (gfc_code *);
12435 :
12436 : static void
12437 131 : resolve_change_team (gfc_code *code)
12438 : {
12439 131 : resolve_team_argument (code->expr1);
12440 131 : gfc_resolve_sync_stat (&code->ext.block.sync_stat);
12441 262 : resolve_block_construct (code);
12442 : /* Map the coarray bounds as selected. */
12443 134 : for (gfc_association_list *a = code->ext.block.assoc; a; a = a->next)
12444 3 : if (a->ar)
12445 : {
12446 3 : gfc_array_spec *src = a->ar->as, *dst;
12447 3 : if (a->st->n.sym->ts.type == BT_CLASS)
12448 0 : dst = CLASS_DATA (a->st->n.sym)->as;
12449 : else
12450 3 : dst = a->st->n.sym->as;
12451 3 : dst->corank = src->corank;
12452 3 : dst->cotype = src->cotype;
12453 6 : for (int i = 0; i < src->corank; ++i)
12454 : {
12455 3 : dst->lower[dst->rank + i] = src->lower[i];
12456 3 : dst->upper[dst->rank + i] = src->upper[i];
12457 3 : src->lower[i] = src->upper[i] = nullptr;
12458 : }
12459 3 : gfc_free_array_spec (src);
12460 3 : free (a->ar);
12461 3 : a->ar = nullptr;
12462 3 : dst->resolved = false;
12463 3 : gfc_resolve_array_spec (dst, 0);
12464 : }
12465 131 : }
12466 :
12467 : static void
12468 48 : resolve_sync_team (gfc_code *code)
12469 : {
12470 48 : resolve_team_argument (code->expr1);
12471 48 : gfc_resolve_sync_stat (&code->ext.sync_stat);
12472 48 : }
12473 :
12474 : static void
12475 129 : resolve_end_team (gfc_code *code)
12476 : {
12477 129 : gfc_resolve_sync_stat (&code->ext.sync_stat);
12478 129 : }
12479 :
12480 : static void
12481 54 : resolve_critical (gfc_code *code)
12482 : {
12483 54 : gfc_symtree *symtree;
12484 54 : gfc_symbol *lock_type;
12485 54 : char name[GFC_MAX_SYMBOL_LEN];
12486 54 : static int serial = 0;
12487 :
12488 54 : gfc_resolve_sync_stat (&code->ext.sync_stat);
12489 :
12490 54 : if (flag_coarray != GFC_FCOARRAY_LIB)
12491 30 : return;
12492 :
12493 24 : symtree = gfc_find_symtree (gfc_current_ns->sym_root,
12494 : GFC_PREFIX ("lock_type"));
12495 24 : if (symtree)
12496 12 : lock_type = symtree->n.sym;
12497 : else
12498 : {
12499 12 : if (gfc_get_sym_tree (GFC_PREFIX ("lock_type"), gfc_current_ns, &symtree,
12500 : false) != 0)
12501 0 : gcc_unreachable ();
12502 12 : lock_type = symtree->n.sym;
12503 12 : lock_type->attr.flavor = FL_DERIVED;
12504 12 : lock_type->attr.zero_comp = 1;
12505 12 : lock_type->from_intmod = INTMOD_ISO_FORTRAN_ENV;
12506 12 : lock_type->intmod_sym_id = ISOFORTRAN_LOCK_TYPE;
12507 : }
12508 :
12509 24 : sprintf(name, GFC_PREFIX ("lock_var") "%d",serial++);
12510 24 : if (gfc_get_sym_tree (name, gfc_current_ns, &symtree, false) != 0)
12511 0 : gcc_unreachable ();
12512 :
12513 24 : code->resolved_sym = symtree->n.sym;
12514 24 : symtree->n.sym->attr.flavor = FL_VARIABLE;
12515 24 : symtree->n.sym->attr.referenced = 1;
12516 24 : symtree->n.sym->attr.artificial = 1;
12517 24 : symtree->n.sym->attr.codimension = 1;
12518 24 : symtree->n.sym->ts.type = BT_DERIVED;
12519 24 : symtree->n.sym->ts.u.derived = lock_type;
12520 24 : symtree->n.sym->as = gfc_get_array_spec ();
12521 24 : symtree->n.sym->as->corank = 1;
12522 24 : symtree->n.sym->as->type = AS_EXPLICIT;
12523 24 : symtree->n.sym->as->cotype = AS_EXPLICIT;
12524 24 : symtree->n.sym->as->lower[0] = gfc_get_int_expr (gfc_default_integer_kind,
12525 : NULL, 1);
12526 24 : gfc_commit_symbols();
12527 : }
12528 :
12529 :
12530 : static void
12531 1450 : resolve_sync (gfc_code *code)
12532 : {
12533 : /* Check imageset. The * case matches expr1 == NULL. */
12534 1450 : if (code->expr1)
12535 : {
12536 107 : if (code->expr1->ts.type != BT_INTEGER || code->expr1->rank > 1)
12537 1 : gfc_error ("Imageset argument at %L must be a scalar or rank-1 "
12538 : "INTEGER expression", &code->expr1->where);
12539 107 : if (code->expr1->expr_type == EXPR_CONSTANT && code->expr1->rank == 0
12540 48 : && mpz_cmp_si (code->expr1->value.integer, 1) < 0)
12541 1 : gfc_error ("Imageset argument at %L must between 1 and num_images()",
12542 : &code->expr1->where);
12543 106 : else if (code->expr1->expr_type == EXPR_ARRAY
12544 106 : && gfc_simplify_expr (code->expr1, 0))
12545 : {
12546 35 : gfc_constructor *cons;
12547 35 : cons = gfc_constructor_first (code->expr1->value.constructor);
12548 120 : for (; cons; cons = gfc_constructor_next (cons))
12549 50 : if (cons->expr->expr_type == EXPR_CONSTANT
12550 50 : && mpz_cmp_si (cons->expr->value.integer, 1) < 0)
12551 0 : gfc_error ("Imageset argument at %L must between 1 and "
12552 : "num_images()", &cons->expr->where);
12553 : }
12554 : }
12555 :
12556 : /* Check STAT. */
12557 1450 : gfc_resolve_expr (code->expr2);
12558 1450 : if (code->expr2)
12559 : {
12560 161 : if (code->expr2->ts.type != BT_INTEGER || code->expr2->rank != 0)
12561 1 : gfc_error ("STAT= argument at %L must be a scalar INTEGER variable",
12562 : &code->expr2->where);
12563 : else
12564 160 : gfc_check_vardef_context (code->expr2, false, false, false,
12565 160 : _("STAT variable"));
12566 : }
12567 :
12568 : /* Check ERRMSG. */
12569 1450 : gfc_resolve_expr (code->expr3);
12570 1450 : if (code->expr3)
12571 : {
12572 90 : if (code->expr3->ts.type != BT_CHARACTER || code->expr3->rank != 0)
12573 4 : gfc_error ("ERRMSG= argument at %L must be a scalar CHARACTER variable",
12574 : &code->expr3->where);
12575 : else
12576 86 : gfc_check_vardef_context (code->expr3, false, false, false,
12577 86 : _("ERRMSG variable"));
12578 : }
12579 1450 : }
12580 :
12581 :
12582 : /* Given a branch to a label, see if the branch is conforming.
12583 : The code node describes where the branch is located. */
12584 :
12585 : static void
12586 112999 : resolve_branch (gfc_st_label *label, gfc_code *code)
12587 : {
12588 112999 : code_stack *stack;
12589 :
12590 112999 : if (label == NULL)
12591 : return;
12592 :
12593 : /* Step one: is this a valid branching target? */
12594 :
12595 2514 : if (label->defined == ST_LABEL_UNKNOWN)
12596 : {
12597 4 : gfc_error ("Label %d referenced at %L is never defined", label->value,
12598 : &code->loc);
12599 4 : return;
12600 : }
12601 :
12602 2510 : if (label->defined != ST_LABEL_TARGET && label->defined != ST_LABEL_DO_TARGET)
12603 : {
12604 4 : gfc_error ("Statement at %L is not a valid branch target statement "
12605 : "for the branch statement at %L", &label->where, &code->loc);
12606 4 : return;
12607 : }
12608 :
12609 : /* Step two: make sure this branch is not a branch to itself ;-) */
12610 :
12611 2506 : if (code->here == label)
12612 : {
12613 0 : gfc_warning (0, "Branch at %L may result in an infinite loop",
12614 : &code->loc);
12615 0 : return;
12616 : }
12617 :
12618 : /* Step three: See if the label is in the same block as the
12619 : branching statement. The hard work has been done by setting up
12620 : the bitmap reachable_labels. */
12621 :
12622 2506 : if (bitmap_bit_p (cs_base->reachable_labels, label->value))
12623 : {
12624 : /* Check now whether there is a CRITICAL construct; if so, check
12625 : whether the label is still visible outside of the CRITICAL block,
12626 : which is invalid. */
12627 6375 : for (stack = cs_base; stack; stack = stack->prev)
12628 : {
12629 3937 : if (stack->current->op == EXEC_CRITICAL
12630 3937 : && bitmap_bit_p (stack->reachable_labels, label->value))
12631 2 : gfc_error ("GOTO statement at %L leaves CRITICAL construct for "
12632 : "label at %L", &code->loc, &label->where);
12633 3935 : else if (stack->current->op == EXEC_DO_CONCURRENT
12634 3935 : && bitmap_bit_p (stack->reachable_labels, label->value))
12635 0 : gfc_error ("GOTO statement at %L leaves DO CONCURRENT construct "
12636 : "for label at %L", &code->loc, &label->where);
12637 3935 : else if (stack->current->op == EXEC_CHANGE_TEAM
12638 3935 : && bitmap_bit_p (stack->reachable_labels, label->value))
12639 1 : gfc_error ("GOTO statement at %L leaves CHANGE TEAM construct "
12640 : "for label at %L", &code->loc, &label->where);
12641 : }
12642 :
12643 : return;
12644 : }
12645 :
12646 : /* Step four: If we haven't found the label in the bitmap, it may
12647 : still be the label of the END of the enclosing block, in which
12648 : case we find it by going up the code_stack. */
12649 :
12650 167 : for (stack = cs_base; stack; stack = stack->prev)
12651 : {
12652 131 : if (stack->current->next && stack->current->next->here == label)
12653 : break;
12654 101 : if (stack->current->op == EXEC_CRITICAL)
12655 : {
12656 : /* Note: A label at END CRITICAL does not leave the CRITICAL
12657 : construct as END CRITICAL is still part of it. */
12658 2 : gfc_error ("GOTO statement at %L leaves CRITICAL construct for label"
12659 : " at %L", &code->loc, &label->where);
12660 2 : return;
12661 : }
12662 99 : else if (stack->current->op == EXEC_DO_CONCURRENT)
12663 : {
12664 0 : gfc_error ("GOTO statement at %L leaves DO CONCURRENT construct for "
12665 : "label at %L", &code->loc, &label->where);
12666 0 : return;
12667 : }
12668 : }
12669 :
12670 66 : if (stack)
12671 : {
12672 30 : gcc_assert (stack->current->next->op == EXEC_END_NESTED_BLOCK);
12673 : return;
12674 : }
12675 :
12676 : /* The label is not in an enclosing block, so illegal. This was
12677 : allowed in Fortran 66, so we allow it as extension. No
12678 : further checks are necessary in this case. */
12679 36 : gfc_notify_std (GFC_STD_LEGACY, "Label at %L is not in the same block "
12680 : "as the GOTO statement at %L", &label->where,
12681 : &code->loc);
12682 36 : return;
12683 : }
12684 :
12685 :
12686 : /* Check whether EXPR1 has the same shape as EXPR2. */
12687 :
12688 : static bool
12689 1479 : resolve_where_shape (gfc_expr *expr1, gfc_expr *expr2)
12690 : {
12691 1479 : mpz_t shape[GFC_MAX_DIMENSIONS];
12692 1479 : mpz_t shape2[GFC_MAX_DIMENSIONS];
12693 1479 : bool result = false;
12694 1479 : int i;
12695 :
12696 : /* Compare the rank. */
12697 1479 : if (expr1->rank != expr2->rank)
12698 : return result;
12699 :
12700 : /* Compare the size of each dimension. */
12701 2835 : for (i=0; i<expr1->rank; i++)
12702 : {
12703 1507 : if (!gfc_array_dimen_size (expr1, i, &shape[i]))
12704 151 : goto ignore;
12705 :
12706 1356 : if (!gfc_array_dimen_size (expr2, i, &shape2[i]))
12707 0 : goto ignore;
12708 :
12709 1356 : if (mpz_cmp (shape[i], shape2[i]))
12710 0 : goto over;
12711 : }
12712 :
12713 : /* When either of the two expression is an assumed size array, we
12714 : ignore the comparison of dimension sizes. */
12715 1328 : ignore:
12716 : result = true;
12717 :
12718 1479 : over:
12719 1479 : gfc_clear_shape (shape, i);
12720 1479 : gfc_clear_shape (shape2, i);
12721 1479 : return result;
12722 : }
12723 :
12724 :
12725 : /* Check whether a WHERE assignment target or a WHERE mask expression
12726 : has the same shape as the outermost WHERE mask expression. */
12727 :
12728 : static void
12729 515 : resolve_where (gfc_code *code, gfc_expr *mask)
12730 : {
12731 515 : gfc_code *cblock;
12732 515 : gfc_code *cnext;
12733 515 : gfc_expr *e = NULL;
12734 :
12735 515 : cblock = code->block;
12736 :
12737 : /* Store the first WHERE mask-expr of the WHERE statement or construct.
12738 : In case of nested WHERE, only the outermost one is stored. */
12739 515 : if (mask == NULL) /* outermost WHERE */
12740 459 : e = cblock->expr1;
12741 : else /* inner WHERE */
12742 515 : e = mask;
12743 :
12744 1399 : while (cblock)
12745 : {
12746 884 : if (cblock->expr1)
12747 : {
12748 : /* Check if the mask-expr has a consistent shape with the
12749 : outermost WHERE mask-expr. */
12750 720 : if (!resolve_where_shape (cblock->expr1, e))
12751 0 : gfc_error ("WHERE mask at %L has inconsistent shape",
12752 0 : &cblock->expr1->where);
12753 : }
12754 :
12755 : /* the assignment statement of a WHERE statement, or the first
12756 : statement in where-body-construct of a WHERE construct */
12757 884 : cnext = cblock->next;
12758 1745 : while (cnext)
12759 : {
12760 861 : switch (cnext->op)
12761 : {
12762 : /* WHERE assignment statement */
12763 759 : case EXEC_ASSIGN:
12764 :
12765 : /* Check shape consistent for WHERE assignment target. */
12766 759 : if (e && !resolve_where_shape (cnext->expr1, e))
12767 0 : gfc_error ("WHERE assignment target at %L has "
12768 0 : "inconsistent shape", &cnext->expr1->where);
12769 :
12770 759 : if (cnext->op == EXEC_ASSIGN
12771 759 : && gfc_may_be_finalized (cnext->expr1->ts))
12772 0 : cnext->expr1->must_finalize = 1;
12773 :
12774 : break;
12775 :
12776 :
12777 46 : case EXEC_ASSIGN_CALL:
12778 46 : resolve_call (cnext);
12779 46 : if (!cnext->resolved_sym->attr.elemental)
12780 2 : gfc_error("Non-ELEMENTAL user-defined assignment in WHERE at %L",
12781 2 : &cnext->ext.actual->expr->where);
12782 : break;
12783 :
12784 : /* WHERE or WHERE construct is part of a where-body-construct */
12785 56 : case EXEC_WHERE:
12786 56 : resolve_where (cnext, e);
12787 56 : break;
12788 :
12789 0 : default:
12790 0 : gfc_error ("Unsupported statement inside WHERE at %L",
12791 : &cnext->loc);
12792 : }
12793 : /* the next statement within the same where-body-construct */
12794 861 : cnext = cnext->next;
12795 : }
12796 : /* the next masked-elsewhere-stmt, elsewhere-stmt, or end-where-stmt */
12797 884 : cblock = cblock->block;
12798 : }
12799 515 : }
12800 :
12801 :
12802 : /* Resolve assignment in FORALL construct.
12803 : NVAR is the number of FORALL index variables, and VAR_EXPR records the
12804 : FORALL index variables. */
12805 :
12806 : static void
12807 2450 : gfc_resolve_assign_in_forall (gfc_code *code, int nvar, gfc_expr **var_expr)
12808 : {
12809 2450 : int n;
12810 2450 : gfc_symbol *forall_index;
12811 :
12812 6952 : for (n = 0; n < nvar; n++)
12813 : {
12814 4502 : forall_index = var_expr[n]->symtree->n.sym;
12815 :
12816 : /* Check whether the assignment target is one of the FORALL index
12817 : variable. */
12818 4502 : if ((code->expr1->expr_type == EXPR_VARIABLE)
12819 4502 : && (code->expr1->symtree->n.sym == forall_index))
12820 0 : gfc_error ("Assignment to a FORALL index variable at %L",
12821 : &code->expr1->where);
12822 : else
12823 : {
12824 : /* If one of the FORALL index variables doesn't appear in the
12825 : assignment variable, then there could be a many-to-one
12826 : assignment. Emit a warning rather than an error because the
12827 : mask could be resolving this problem.
12828 : DO NOT emit this warning for DO CONCURRENT - reduction-like
12829 : many-to-one assignments are semantically valid (formalized with
12830 : the REDUCE locality-spec in Fortran 2023). */
12831 4502 : if (!find_forall_index (code->expr1, forall_index, 0)
12832 4502 : && !gfc_do_concurrent_flag)
12833 0 : gfc_warning (0, "The FORALL with index %qs is not used on the "
12834 : "left side of the assignment at %L and so might "
12835 : "cause multiple assignment to this object",
12836 0 : var_expr[n]->symtree->name, &code->expr1->where);
12837 : }
12838 : }
12839 2450 : }
12840 :
12841 :
12842 : /* Resolve WHERE statement in FORALL construct. */
12843 :
12844 : static void
12845 53 : gfc_resolve_where_code_in_forall (gfc_code *code, int nvar,
12846 : gfc_expr **var_expr)
12847 : {
12848 53 : gfc_code *cblock;
12849 53 : gfc_code *cnext;
12850 :
12851 53 : cblock = code->block;
12852 125 : while (cblock)
12853 : {
12854 : /* the assignment statement of a WHERE statement, or the first
12855 : statement in where-body-construct of a WHERE construct */
12856 72 : cnext = cblock->next;
12857 144 : while (cnext)
12858 : {
12859 72 : switch (cnext->op)
12860 : {
12861 : /* WHERE assignment statement */
12862 72 : case EXEC_ASSIGN:
12863 72 : gfc_resolve_assign_in_forall (cnext, nvar, var_expr);
12864 :
12865 72 : if (cnext->op == EXEC_ASSIGN
12866 72 : && gfc_may_be_finalized (cnext->expr1->ts))
12867 0 : cnext->expr1->must_finalize = 1;
12868 :
12869 : break;
12870 :
12871 : /* WHERE operator assignment statement */
12872 0 : case EXEC_ASSIGN_CALL:
12873 0 : resolve_call (cnext);
12874 0 : if (!cnext->resolved_sym->attr.elemental)
12875 0 : gfc_error("Non-ELEMENTAL user-defined assignment in WHERE at %L",
12876 0 : &cnext->ext.actual->expr->where);
12877 : break;
12878 :
12879 : /* WHERE or WHERE construct is part of a where-body-construct */
12880 0 : case EXEC_WHERE:
12881 0 : gfc_resolve_where_code_in_forall (cnext, nvar, var_expr);
12882 0 : break;
12883 :
12884 0 : default:
12885 0 : gfc_error ("Unsupported statement inside WHERE at %L",
12886 : &cnext->loc);
12887 : }
12888 : /* the next statement within the same where-body-construct */
12889 72 : cnext = cnext->next;
12890 : }
12891 : /* the next masked-elsewhere-stmt, elsewhere-stmt, or end-where-stmt */
12892 72 : cblock = cblock->block;
12893 : }
12894 53 : }
12895 :
12896 :
12897 : /* Traverse the FORALL body to check whether the following errors exist:
12898 : 1. For assignment, check if a many-to-one assignment happens.
12899 : 2. For WHERE statement, check the WHERE body to see if there is any
12900 : many-to-one assignment. */
12901 :
12902 : static void
12903 2345 : gfc_resolve_forall_body (gfc_code *code, int nvar, gfc_expr **var_expr)
12904 : {
12905 2345 : gfc_code *c;
12906 :
12907 2345 : c = code->block->next;
12908 5118 : while (c)
12909 : {
12910 2773 : switch (c->op)
12911 : {
12912 2378 : case EXEC_ASSIGN:
12913 2378 : case EXEC_POINTER_ASSIGN:
12914 2378 : gfc_resolve_assign_in_forall (c, nvar, var_expr);
12915 :
12916 2378 : if (c->op == EXEC_ASSIGN
12917 2378 : && gfc_may_be_finalized (c->expr1->ts))
12918 0 : c->expr1->must_finalize = 1;
12919 :
12920 : break;
12921 :
12922 0 : case EXEC_ASSIGN_CALL:
12923 0 : resolve_call (c);
12924 0 : break;
12925 :
12926 : /* Because the gfc_resolve_blocks() will handle the nested FORALL,
12927 : there is no need to handle it here. */
12928 : case EXEC_FORALL:
12929 : break;
12930 53 : case EXEC_WHERE:
12931 53 : gfc_resolve_where_code_in_forall(c, nvar, var_expr);
12932 53 : break;
12933 : default:
12934 : break;
12935 : }
12936 : /* The next statement in the FORALL body. */
12937 2773 : c = c->next;
12938 : }
12939 2345 : }
12940 :
12941 :
12942 : /* Counts the number of iterators needed inside a forall construct, including
12943 : nested forall constructs. This is used to allocate the needed memory
12944 : in gfc_resolve_forall. */
12945 :
12946 : static int gfc_count_forall_iterators (gfc_code *code);
12947 :
12948 : /* Return the deepest nested FORALL/DO CONCURRENT iterator count in CODE's
12949 : next-chain, descending into block arms such as IF/ELSE branches. */
12950 :
12951 : static int
12952 2585 : gfc_max_forall_iterators_in_chain (gfc_code *code)
12953 : {
12954 2585 : int max_iters = 0;
12955 :
12956 5633 : for (gfc_code *c = code; c; c = c->next)
12957 : {
12958 3048 : int sub_iters = 0;
12959 :
12960 3048 : if (c->op == EXEC_FORALL || c->op == EXEC_DO_CONCURRENT)
12961 124 : sub_iters = gfc_count_forall_iterators (c);
12962 2924 : else if (c->op == EXEC_BLOCK)
12963 : {
12964 : /* BLOCK/ASSOCIATE bodies live in the block namespace code chain,
12965 : not in the generic c->block arm list used by IF/SELECT. */
12966 40 : if (c->ext.block.ns && c->ext.block.ns->code)
12967 40 : sub_iters = gfc_max_forall_iterators_in_chain (c->ext.block.ns->code);
12968 : }
12969 2884 : else if (c->block)
12970 367 : for (gfc_code *b = c->block; b; b = b->block)
12971 : {
12972 200 : int arm_iters = gfc_max_forall_iterators_in_chain (b->next);
12973 200 : if (arm_iters > sub_iters)
12974 : sub_iters = arm_iters;
12975 : }
12976 :
12977 3048 : if (sub_iters > max_iters)
12978 : max_iters = sub_iters;
12979 : }
12980 :
12981 2585 : return max_iters;
12982 : }
12983 :
12984 :
12985 : static int
12986 2345 : gfc_count_forall_iterators (gfc_code *code)
12987 : {
12988 2345 : int current_iters = 0;
12989 2345 : gfc_forall_iterator *fa;
12990 :
12991 2345 : gcc_assert (code->op == EXEC_FORALL || code->op == EXEC_DO_CONCURRENT);
12992 :
12993 6608 : for (fa = code->ext.concur.forall_iterator; fa; fa = fa->next)
12994 4263 : current_iters++;
12995 :
12996 2345 : return current_iters + gfc_max_forall_iterators_in_chain (code->block->next);
12997 : }
12998 :
12999 :
13000 : /* Given a FORALL construct.
13001 : 1) Resolve the FORALL iterator.
13002 : 2) Check for shadow index-name(s) and update code block.
13003 : 3) call gfc_resolve_forall_body to resolve the FORALL body. */
13004 :
13005 : /* Shadow variable that replace_forall_var substitutes in; set by
13006 : replace_in_expr_recursive before each traversal. */
13007 :
13008 : static gfc_symtree *forall_shadow_st;
13009 :
13010 : /* gfc_traverse_expr callback: point a reference to OLD_SYM at the
13011 : construct-scoped shadow variable. */
13012 :
13013 : static bool
13014 872 : replace_forall_var (gfc_expr *expr, gfc_symbol *old_sym,
13015 : int *f ATTRIBUTE_UNUSED)
13016 : {
13017 872 : if (expr->expr_type == EXPR_VARIABLE && expr->symtree->n.sym == old_sym)
13018 : {
13019 198 : expr->symtree = forall_shadow_st;
13020 198 : expr->ts = forall_shadow_st->n.sym->ts;
13021 : }
13022 :
13023 872 : return false;
13024 : }
13025 :
13026 :
13027 : /* Replace every reference to OLD_SYM in EXPR with NEW_ST. Traversal is
13028 : left to gfc_traverse_expr so that all expression forms are covered;
13029 : character length type parameters are skipped since those belong to
13030 : declarations that may be shared outside the construct. */
13031 :
13032 : static void
13033 974 : replace_in_expr_recursive (gfc_expr *expr, gfc_symbol *old_sym,
13034 : gfc_symtree *new_st)
13035 : {
13036 974 : if (!expr)
13037 : return;
13038 :
13039 412 : forall_shadow_st = new_st;
13040 412 : gfc_traverse_expr (expr, old_sym, replace_forall_var, -1);
13041 : }
13042 :
13043 :
13044 : /* Walk code tree and replace all variable references */
13045 :
13046 : static void
13047 200 : replace_in_code_recursive (gfc_code *code, gfc_symbol *old_sym, gfc_symtree *new_st)
13048 : {
13049 200 : if (!code)
13050 : return;
13051 :
13052 412 : for (gfc_code *c = code; c; c = c->next)
13053 : {
13054 : /* Replace in expressions associated with this code node */
13055 212 : replace_in_expr_recursive (c->expr1, old_sym, new_st);
13056 212 : replace_in_expr_recursive (c->expr2, old_sym, new_st);
13057 212 : replace_in_expr_recursive (c->expr3, old_sym, new_st);
13058 212 : replace_in_expr_recursive (c->expr4, old_sym, new_st);
13059 :
13060 : /* Handle special code types with additional expressions */
13061 212 : switch (c->op)
13062 : {
13063 0 : case EXEC_DO:
13064 0 : if (c->ext.iterator)
13065 : {
13066 0 : replace_in_expr_recursive (c->ext.iterator->start, old_sym, new_st);
13067 0 : replace_in_expr_recursive (c->ext.iterator->end, old_sym, new_st);
13068 0 : replace_in_expr_recursive (c->ext.iterator->step, old_sym, new_st);
13069 : }
13070 : break;
13071 :
13072 0 : case EXEC_CALL:
13073 0 : case EXEC_ASSIGN_CALL:
13074 0 : for (gfc_actual_arglist *a = c->ext.actual; a; a = a->next)
13075 0 : replace_in_expr_recursive (a->expr, old_sym, new_st);
13076 : break;
13077 :
13078 6 : case EXEC_SELECT:
13079 6 : case EXEC_SELECT_TYPE:
13080 6 : case EXEC_SELECT_RANK:
13081 12 : for (gfc_code *b = c->block; b; b = b->block)
13082 : {
13083 12 : for (gfc_case *cp = b->ext.block.case_list; cp; cp = cp->next)
13084 : {
13085 6 : replace_in_expr_recursive (cp->low, old_sym, new_st);
13086 6 : replace_in_expr_recursive (cp->high, old_sym, new_st);
13087 : }
13088 6 : replace_in_code_recursive (b->next, old_sym, new_st);
13089 : }
13090 : break;
13091 :
13092 18 : case EXEC_IF:
13093 18 : case EXEC_WHERE:
13094 : /* Each block in the chain holds its condition or mask in EXPR1
13095 : and its body in NEXT; the trailing ELSE/ELSEWHERE has no
13096 : condition. The generic recursion below only reaches the first
13097 : branch, so walk the whole chain here. */
13098 48 : for (gfc_code *b = c->block; b; b = b->block)
13099 : {
13100 30 : replace_in_expr_recursive (b->expr1, old_sym, new_st);
13101 30 : replace_in_code_recursive (b->next, old_sym, new_st);
13102 : }
13103 : break;
13104 :
13105 6 : case EXEC_ALLOCATE:
13106 6 : case EXEC_DEALLOCATE:
13107 : /* Bounds and lengths of the allocate-objects. */
13108 12 : for (gfc_alloc *al = c->ext.alloc.list; al; al = al->next)
13109 6 : replace_in_expr_recursive (al->expr, old_sym, new_st);
13110 : break;
13111 :
13112 24 : case EXEC_FORALL:
13113 24 : case EXEC_DO_CONCURRENT:
13114 48 : for (gfc_forall_iterator *fa = c->ext.concur.forall_iterator; fa; fa = fa->next)
13115 : {
13116 24 : replace_in_expr_recursive (fa->start, old_sym, new_st);
13117 24 : replace_in_expr_recursive (fa->end, old_sym, new_st);
13118 24 : replace_in_expr_recursive (fa->stride, old_sym, new_st);
13119 : }
13120 : /* Don't recurse into nested FORALL/DO CONCURRENT bodies here,
13121 : they'll be handled separately */
13122 : break;
13123 :
13124 12 : case EXEC_BLOCK:
13125 : /* Replace in ASSOCIATE selector expressions and the body.
13126 : The body of an EXEC_BLOCK lives in c->ext.block.ns->code, not
13127 : c->block->next, so without this case both selectors and body
13128 : are silently skipped, leaving shadow iterator references unreplaced
13129 : and producing wrong values at runtime. */
13130 12 : for (gfc_association_list *alist = c->ext.block.assoc;
13131 18 : alist; alist = alist->next)
13132 6 : replace_in_expr_recursive (alist->target, old_sym, new_st);
13133 12 : if (c->ext.block.ns)
13134 12 : replace_in_code_recursive (c->ext.block.ns->code, old_sym, new_st);
13135 : break;
13136 :
13137 : default:
13138 : break;
13139 : }
13140 :
13141 : /* Recurse into blocks, except a nested FORALL/DO CONCURRENT that
13142 : shadows OLD_SYM itself. */
13143 212 : bool skip_nested_shadow = false;
13144 212 : if (c->op == EXEC_FORALL || c->op == EXEC_DO_CONCURRENT)
13145 24 : for (gfc_forall_iterator *fa = c->ext.concur.forall_iterator;
13146 24 : fa; fa = fa->next)
13147 24 : if (fa->shadow && fa->shadow_outer_sym == old_sym)
13148 : {
13149 : skip_nested_shadow = true;
13150 : break;
13151 : }
13152 :
13153 212 : if (c->block && !skip_nested_shadow)
13154 24 : replace_in_code_recursive (c->block->next, old_sym, new_st);
13155 : }
13156 : }
13157 :
13158 :
13159 : /* Replace all references to outer_sym with shadow_st in the given code. */
13160 :
13161 : static void
13162 128 : gfc_replace_forall_variable (gfc_code **code_ptr, gfc_symbol *outer_sym,
13163 : gfc_symtree *shadow_st)
13164 : {
13165 : /* Use custom recursive walker to ensure we visit ALL expressions */
13166 0 : replace_in_code_recursive (*code_ptr, outer_sym, shadow_st);
13167 0 : }
13168 :
13169 :
13170 : static void
13171 2345 : gfc_resolve_forall (gfc_code *code, gfc_namespace *ns, int forall_save)
13172 : {
13173 2345 : static gfc_expr **var_expr;
13174 2345 : static int total_var = 0;
13175 2345 : static int nvar = 0;
13176 2345 : int i, old_nvar, tmp;
13177 2345 : gfc_forall_iterator *fa;
13178 2345 : bool shadow = false;
13179 :
13180 2345 : old_nvar = nvar;
13181 :
13182 : /* Only warn about obsolescent FORALL, not DO CONCURRENT */
13183 2345 : if (code->op == EXEC_FORALL
13184 2345 : && !gfc_notify_std (GFC_STD_F2018_OBS, "FORALL construct at %L", &code->loc))
13185 : return;
13186 :
13187 : /* Start to resolve a FORALL construct */
13188 : /* Allocate var_expr only at the truly outermost FORALL/DO CONCURRENT level.
13189 : forall_save==0 means we're not nested in a FORALL in the current scope,
13190 : but nvar==0 ensures we're not nested in a parent scope either (prevents
13191 : double allocation when FORALL is nested inside DO CONCURRENT). */
13192 2345 : if (forall_save == 0 && nvar == 0)
13193 : {
13194 : /* Count the total number of FORALL indices in the nested FORALL
13195 : construct in order to allocate the VAR_EXPR with proper size. */
13196 2221 : total_var = gfc_count_forall_iterators (code);
13197 :
13198 : /* Allocate VAR_EXPR with NUMBER_OF_FORALL_INDEX elements. */
13199 2221 : var_expr = XCNEWVEC (gfc_expr *, total_var);
13200 : }
13201 :
13202 : /* The information about FORALL iterator, including FORALL indices start,
13203 : end and stride. An outer FORALL indice cannot appear in start, end or
13204 : stride. Check for a shadow index-name. */
13205 6608 : for (fa = code->ext.concur.forall_iterator; fa; fa = fa->next)
13206 : {
13207 : /* Fortran 2008: C738 (R753). */
13208 4263 : if (fa->var->ref && fa->var->ref->type == REF_ARRAY)
13209 : {
13210 2 : gfc_error ("FORALL index-name at %L must be a scalar variable "
13211 : "of type integer", &fa->var->where);
13212 2 : continue;
13213 : }
13214 :
13215 : /* Check if any outer FORALL index name is the same as the current
13216 : one. Skip this check if the iterator is a shadow variable (from
13217 : DO CONCURRENT type spec) which may not have a symtree yet. */
13218 7314 : for (i = 0; i < nvar; i++)
13219 : {
13220 3053 : if (fa->var && fa->var->symtree && var_expr[i] && var_expr[i]->symtree
13221 3053 : && fa->var->symtree->n.sym == var_expr[i]->symtree->n.sym)
13222 0 : gfc_error ("An outer FORALL construct already has an index "
13223 : "with this name %L", &fa->var->where);
13224 : }
13225 :
13226 4261 : if (fa->shadow)
13227 128 : shadow = true;
13228 :
13229 : /* Record the current FORALL index. */
13230 4261 : var_expr[nvar] = gfc_copy_expr (fa->var);
13231 :
13232 4261 : nvar++;
13233 :
13234 : /* No memory leak. */
13235 4261 : gcc_assert (nvar <= total_var);
13236 : }
13237 :
13238 : /* Need to walk the code and replace references to the index-name with
13239 : references to the shadow index-name. This must be done BEFORE resolving
13240 : the body so that resolution uses the correct shadow variables. */
13241 2345 : if (shadow)
13242 : {
13243 : /* Walk the FORALL/DO CONCURRENT body and replace references to shadowed variables. */
13244 262 : for (fa = code->ext.concur.forall_iterator; fa; fa = fa->next)
13245 : {
13246 134 : if (fa->shadow)
13247 : {
13248 128 : gfc_symtree *shadow_st = fa->var->symtree;
13249 :
13250 128 : gfc_symbol *iter_sym = fa->shadow_outer_sym;
13251 :
13252 : /* Walk the FORALL/DO CONCURRENT body and replace all references. */
13253 128 : if (code->block && code->block->next)
13254 128 : gfc_replace_forall_variable (&code->block->next, iter_sym, shadow_st);
13255 : }
13256 : }
13257 : }
13258 :
13259 : /* Resolve the FORALL body. */
13260 2345 : gfc_resolve_forall_body (code, nvar, var_expr);
13261 :
13262 : /* May call gfc_resolve_forall to resolve the inner FORALL loop. */
13263 2345 : gfc_resolve_blocks (code->block, ns);
13264 :
13265 2345 : tmp = nvar;
13266 2345 : nvar = old_nvar;
13267 : /* Free only the VAR_EXPRs allocated in this frame. */
13268 6606 : for (i = nvar; i < tmp; i++)
13269 4261 : gfc_free_expr (var_expr[i]);
13270 :
13271 2345 : if (nvar == 0)
13272 : {
13273 : /* We are in the outermost FORALL construct. */
13274 2221 : gcc_assert (forall_save == 0);
13275 :
13276 : /* VAR_EXPR is not needed any more. */
13277 2221 : free (var_expr);
13278 2221 : total_var = 0;
13279 : }
13280 : }
13281 :
13282 :
13283 : /* Resolve a BLOCK construct statement. */
13284 :
13285 : static void
13286 8852 : resolve_block_construct (gfc_code* code)
13287 : {
13288 8852 : gfc_namespace *ns = code->ext.block.ns;
13289 :
13290 : /* For an ASSOCIATE block, the associations (and their targets) will be
13291 : resolved by gfc_resolve_symbol, during resolution of the BLOCK's
13292 : namespace. However, marking variables as used ans defined requires
13293 : passing ext.block.assoc. */
13294 8852 : gfc_resolve (ns, code->ext.block.assoc);
13295 8721 : }
13296 :
13297 : /* Mark everything in an association list as used and set if applicable,
13298 : respectively. */
13299 :
13300 : static void
13301 322228 : mark_assoc_used (gfc_association_list *a)
13302 : {
13303 329584 : while (a != NULL)
13304 : {
13305 7356 : gfc_symbol *n_sym = a->st->n.sym;
13306 7356 : if (n_sym->attr.value_used != VALUE_UNUSED)
13307 5259 : gfc_value_used_expr (a->target, n_sym->attr.value_used);
13308 :
13309 7356 : if (a->variable && n_sym->attr.value_set != VALUE_UNSET)
13310 1390 : gfc_expr_set_at (a->target, &n_sym->other_loc, n_sym->attr.value_set);
13311 :
13312 7356 : a = a->next;
13313 : }
13314 322228 : }
13315 :
13316 : /* Resolve lists of blocks found in IF, SELECT CASE, WHERE, FORALL, GOTO and
13317 : DO code nodes. */
13318 :
13319 : void
13320 340980 : gfc_resolve_blocks (gfc_code *b, gfc_namespace *ns)
13321 : {
13322 340980 : bool t;
13323 :
13324 693696 : for (; b; b = b->block)
13325 : {
13326 352716 : t = gfc_resolve_expr (b->expr1);
13327 352716 : if (!gfc_resolve_expr (b->expr2))
13328 0 : t = false;
13329 :
13330 352716 : switch (b->op)
13331 : {
13332 243877 : case EXEC_IF:
13333 243877 : if (t && b->expr1 != NULL
13334 239527 : && (b->expr1->ts.type != BT_LOGICAL || b->expr1->rank != 0))
13335 0 : gfc_error ("IF clause at %L requires a scalar LOGICAL expression",
13336 : &b->expr1->where);
13337 : break;
13338 :
13339 770 : case EXEC_WHERE:
13340 770 : if (t
13341 770 : && b->expr1 != NULL
13342 637 : && (b->expr1->ts.type != BT_LOGICAL || b->expr1->rank == 0))
13343 0 : gfc_error ("WHERE/ELSEWHERE clause at %L requires a LOGICAL array",
13344 : &b->expr1->where);
13345 : break;
13346 :
13347 76 : case EXEC_GOTO:
13348 76 : resolve_branch (b->label1, b);
13349 76 : break;
13350 :
13351 0 : case EXEC_BLOCK:
13352 0 : resolve_block_construct (b);
13353 0 : break;
13354 :
13355 : case EXEC_SELECT:
13356 : case EXEC_SELECT_TYPE:
13357 : case EXEC_SELECT_RANK:
13358 : case EXEC_FORALL:
13359 : case EXEC_DO:
13360 : case EXEC_DO_WHILE:
13361 : case EXEC_DO_CONCURRENT:
13362 : case EXEC_CRITICAL:
13363 : case EXEC_READ:
13364 : case EXEC_WRITE:
13365 : case EXEC_IOLENGTH:
13366 : case EXEC_WAIT:
13367 : break;
13368 :
13369 2710 : case EXEC_OMP_ATOMIC:
13370 2710 : case EXEC_OACC_ATOMIC:
13371 2710 : {
13372 : /* Verify this before calling gfc_resolve_code, which might
13373 : change it. */
13374 2710 : gcc_assert (b->op == EXEC_OMP_ATOMIC
13375 : || (b->next && b->next->op == EXEC_ASSIGN));
13376 : }
13377 : break;
13378 :
13379 : case EXEC_OACC_PARALLEL_LOOP:
13380 : case EXEC_OACC_PARALLEL:
13381 : case EXEC_OACC_KERNELS_LOOP:
13382 : case EXEC_OACC_KERNELS:
13383 : case EXEC_OACC_SERIAL_LOOP:
13384 : case EXEC_OACC_SERIAL:
13385 : case EXEC_OACC_DATA:
13386 : case EXEC_OACC_HOST_DATA:
13387 : case EXEC_OACC_LOOP:
13388 : case EXEC_OACC_UPDATE:
13389 : case EXEC_OACC_WAIT:
13390 : case EXEC_OACC_CACHE:
13391 : case EXEC_OACC_ENTER_DATA:
13392 : case EXEC_OACC_EXIT_DATA:
13393 : case EXEC_OACC_ROUTINE:
13394 : case EXEC_OACC_INIT:
13395 : case EXEC_OACC_SHUTDOWN:
13396 : case EXEC_OACC_SET:
13397 : case EXEC_OMP_ALLOCATE:
13398 : case EXEC_OMP_ALLOCATORS:
13399 : case EXEC_OMP_ASSUME:
13400 : case EXEC_OMP_CRITICAL:
13401 : case EXEC_OMP_DISPATCH:
13402 : case EXEC_OMP_DISTRIBUTE:
13403 : case EXEC_OMP_DISTRIBUTE_PARALLEL_DO:
13404 : case EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD:
13405 : case EXEC_OMP_DISTRIBUTE_SIMD:
13406 : case EXEC_OMP_DO:
13407 : case EXEC_OMP_DO_SIMD:
13408 : case EXEC_OMP_ERROR:
13409 : case EXEC_OMP_LOOP:
13410 : case EXEC_OMP_MASKED:
13411 : case EXEC_OMP_MASKED_TASKLOOP:
13412 : case EXEC_OMP_MASKED_TASKLOOP_SIMD:
13413 : case EXEC_OMP_MASTER:
13414 : case EXEC_OMP_MASTER_TASKLOOP:
13415 : case EXEC_OMP_MASTER_TASKLOOP_SIMD:
13416 : case EXEC_OMP_ORDERED:
13417 : case EXEC_OMP_PARALLEL:
13418 : case EXEC_OMP_PARALLEL_DO:
13419 : case EXEC_OMP_PARALLEL_DO_SIMD:
13420 : case EXEC_OMP_PARALLEL_LOOP:
13421 : case EXEC_OMP_PARALLEL_MASKED:
13422 : case EXEC_OMP_PARALLEL_MASKED_TASKLOOP:
13423 : case EXEC_OMP_PARALLEL_MASKED_TASKLOOP_SIMD:
13424 : case EXEC_OMP_PARALLEL_MASTER:
13425 : case EXEC_OMP_PARALLEL_MASTER_TASKLOOP:
13426 : case EXEC_OMP_PARALLEL_MASTER_TASKLOOP_SIMD:
13427 : case EXEC_OMP_PARALLEL_SECTIONS:
13428 : case EXEC_OMP_PARALLEL_WORKSHARE:
13429 : case EXEC_OMP_SECTIONS:
13430 : case EXEC_OMP_SIMD:
13431 : case EXEC_OMP_SCOPE:
13432 : case EXEC_OMP_SINGLE:
13433 : case EXEC_OMP_TARGET:
13434 : case EXEC_OMP_TARGET_DATA:
13435 : case EXEC_OMP_TARGET_ENTER_DATA:
13436 : case EXEC_OMP_TARGET_EXIT_DATA:
13437 : case EXEC_OMP_TARGET_PARALLEL:
13438 : case EXEC_OMP_TARGET_PARALLEL_DO:
13439 : case EXEC_OMP_TARGET_PARALLEL_DO_SIMD:
13440 : case EXEC_OMP_TARGET_PARALLEL_LOOP:
13441 : case EXEC_OMP_TARGET_SIMD:
13442 : case EXEC_OMP_TARGET_TEAMS:
13443 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE:
13444 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO:
13445 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
13446 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD:
13447 : case EXEC_OMP_TARGET_TEAMS_LOOP:
13448 : case EXEC_OMP_TARGET_UPDATE:
13449 : case EXEC_OMP_TASK:
13450 : case EXEC_OMP_TASKGROUP:
13451 : case EXEC_OMP_TASKLOOP:
13452 : case EXEC_OMP_TASKLOOP_SIMD:
13453 : case EXEC_OMP_TASKWAIT:
13454 : case EXEC_OMP_TASKYIELD:
13455 : case EXEC_OMP_TEAMS:
13456 : case EXEC_OMP_TEAMS_DISTRIBUTE:
13457 : case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO:
13458 : case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
13459 : case EXEC_OMP_TEAMS_LOOP:
13460 : case EXEC_OMP_TEAMS_DISTRIBUTE_SIMD:
13461 : case EXEC_OMP_TILE:
13462 : case EXEC_OMP_UNROLL:
13463 : case EXEC_OMP_WORKSHARE:
13464 : break;
13465 :
13466 0 : default:
13467 0 : gfc_internal_error ("gfc_resolve_blocks(): Bad block type");
13468 : }
13469 352716 : gfc_value_used_expr (b->expr1, VALUE_USED);
13470 352716 : gfc_value_used_expr (b->expr2, VALUE_USED);
13471 352716 : gfc_resolve_code (b->next, ns);
13472 : }
13473 340980 : }
13474 :
13475 : bool
13476 0 : caf_possible_reallocate (gfc_expr *e)
13477 : {
13478 0 : symbol_attribute caf_attr;
13479 0 : gfc_ref *last_arr_ref = nullptr;
13480 :
13481 0 : caf_attr = gfc_caf_attr (e);
13482 0 : if (!caf_attr.codimension || !caf_attr.allocatable || !caf_attr.dimension)
13483 : return false;
13484 :
13485 : /* Only full array refs can indicate a needed reallocation. */
13486 0 : for (gfc_ref *ref = e->ref; ref; ref = ref->next)
13487 0 : if (ref->type == REF_ARRAY && ref->u.ar.dimen)
13488 0 : last_arr_ref = ref;
13489 :
13490 0 : return last_arr_ref && last_arr_ref->u.ar.type == AR_FULL;
13491 : }
13492 :
13493 : /* Does everything to resolve an ordinary assignment. Returns true
13494 : if this is an interface assignment. */
13495 : static bool
13496 291109 : resolve_ordinary_assign (gfc_code *code, gfc_namespace *ns)
13497 : {
13498 291109 : bool rval = false;
13499 291109 : gfc_expr *lhs;
13500 291109 : gfc_expr *rhs;
13501 291109 : int n;
13502 291109 : gfc_ref *ref;
13503 291109 : symbol_attribute attr;
13504 :
13505 291109 : if (gfc_extend_assign (code, ns))
13506 : {
13507 924 : gfc_expr** rhsptr;
13508 :
13509 924 : if (code->op == EXEC_ASSIGN_CALL)
13510 : {
13511 469 : lhs = code->ext.actual->expr;
13512 469 : rhsptr = &code->ext.actual->next->expr;
13513 : }
13514 : else
13515 : {
13516 455 : gfc_actual_arglist* args;
13517 455 : gfc_typebound_proc* tbp;
13518 :
13519 455 : gcc_assert (code->op == EXEC_COMPCALL);
13520 :
13521 455 : args = code->expr1->value.compcall.actual;
13522 455 : lhs = args->expr;
13523 455 : rhsptr = &args->next->expr;
13524 :
13525 455 : tbp = code->expr1->value.compcall.tbp;
13526 455 : gcc_assert (!tbp->is_generic);
13527 : }
13528 :
13529 : /* Make a temporary rhs when there is a default initializer
13530 : and rhs is the same symbol as the lhs. */
13531 924 : if ((*rhsptr)->expr_type == EXPR_VARIABLE
13532 513 : && (*rhsptr)->symtree->n.sym->ts.type == BT_DERIVED
13533 442 : && gfc_has_default_initializer ((*rhsptr)->symtree->n.sym->ts.u.derived)
13534 1218 : && (lhs->symtree->n.sym == (*rhsptr)->symtree->n.sym))
13535 60 : *rhsptr = gfc_get_parentheses (*rhsptr);
13536 :
13537 : return true;
13538 : }
13539 :
13540 290185 : lhs = code->expr1;
13541 290185 : rhs = code->expr2;
13542 :
13543 290185 : if ((lhs->symtree->n.sym->ts.type == BT_DERIVED
13544 268729 : || lhs->symtree->n.sym->ts.type == BT_CLASS)
13545 24333 : && !lhs->symtree->n.sym->attr.proc_pointer
13546 314518 : && gfc_expr_attr (lhs).proc_pointer)
13547 : {
13548 1 : gfc_error ("Variable in the ordinary assignment at %L is a procedure "
13549 : "pointer component",
13550 : &lhs->where);
13551 1 : return false;
13552 : }
13553 :
13554 342427 : if ((gfc_numeric_ts (&lhs->ts) || lhs->ts.type == BT_LOGICAL)
13555 253474 : && rhs->ts.type == BT_CHARACTER
13556 290577 : && (rhs->expr_type != EXPR_CONSTANT || !flag_dec_char_conversions))
13557 : {
13558 : /* Use of -fdec-char-conversions allows assignment of character data
13559 : to non-character variables. This not permitted for nonconstant
13560 : strings. */
13561 29 : gfc_error ("Cannot convert %s to %s at %L", gfc_typename (rhs),
13562 : gfc_typename (lhs), &rhs->where);
13563 29 : return false;
13564 : }
13565 :
13566 290155 : if (flag_unsigned && gfc_invalid_unsigned_ops (lhs, rhs))
13567 : {
13568 0 : gfc_error ("Cannot assign %s to %s at %L", gfc_typename (rhs),
13569 : gfc_typename (lhs), &rhs->where);
13570 0 : return false;
13571 : }
13572 :
13573 : /* Handle the case of a BOZ literal on the RHS. */
13574 290155 : if (rhs->ts.type == BT_BOZ)
13575 : {
13576 3 : if (gfc_invalid_boz ("BOZ literal constant at %L is neither a DATA "
13577 : "statement value nor an actual argument of "
13578 : "INT/REAL/DBLE/CMPLX intrinsic subprogram",
13579 : &rhs->where))
13580 : return false;
13581 :
13582 1 : switch (lhs->ts.type)
13583 : {
13584 0 : case BT_INTEGER:
13585 0 : if (!gfc_boz2int (rhs, lhs->ts.kind))
13586 : return false;
13587 : break;
13588 1 : case BT_REAL:
13589 1 : if (!gfc_boz2real (rhs, lhs->ts.kind))
13590 : return false;
13591 : break;
13592 0 : default:
13593 0 : gfc_error ("Invalid use of BOZ literal constant at %L", &rhs->where);
13594 0 : return false;
13595 : }
13596 : }
13597 :
13598 290153 : if (lhs->ts.type == BT_CHARACTER && warn_character_truncation)
13599 : {
13600 67 : HOST_WIDE_INT llen = 0, rlen = 0;
13601 67 : if (lhs->ts.u.cl != NULL
13602 67 : && lhs->ts.u.cl->length != NULL
13603 61 : && lhs->ts.u.cl->length->expr_type == EXPR_CONSTANT)
13604 61 : llen = gfc_mpz_get_hwi (lhs->ts.u.cl->length->value.integer);
13605 :
13606 67 : if (rhs->expr_type == EXPR_CONSTANT)
13607 29 : rlen = rhs->value.character.length;
13608 :
13609 38 : else if (rhs->ts.u.cl != NULL
13610 38 : && rhs->ts.u.cl->length != NULL
13611 36 : && rhs->ts.u.cl->length->expr_type == EXPR_CONSTANT)
13612 35 : rlen = gfc_mpz_get_hwi (rhs->ts.u.cl->length->value.integer);
13613 :
13614 67 : if (rlen && llen && rlen > llen)
13615 28 : gfc_warning_now (OPT_Wcharacter_truncation,
13616 : "CHARACTER expression will be truncated "
13617 : "in assignment (%wd/%wd) at %L",
13618 : llen, rlen, &code->loc);
13619 : }
13620 :
13621 : /* Ensure that a vector index expression for the lvalue is evaluated
13622 : to a temporary if the lvalue symbol is referenced in it. */
13623 290153 : if (lhs->rank)
13624 : {
13625 116425 : for (ref = lhs->ref; ref; ref= ref->next)
13626 62484 : if (ref->type == REF_ARRAY)
13627 : {
13628 136234 : for (n = 0; n < ref->u.ar.dimen; n++)
13629 80359 : if (ref->u.ar.dimen_type[n] == DIMEN_VECTOR
13630 80589 : && gfc_find_sym_in_expr (lhs->symtree->n.sym,
13631 230 : ref->u.ar.start[n]))
13632 14 : ref->u.ar.start[n]
13633 14 : = gfc_get_parentheses (ref->u.ar.start[n]);
13634 : }
13635 : }
13636 :
13637 290153 : if (gfc_pure (NULL))
13638 : {
13639 3627 : if (lhs->ts.type == BT_DERIVED
13640 136 : && lhs->expr_type == EXPR_VARIABLE
13641 136 : && lhs->ts.u.derived->attr.pointer_comp
13642 4 : && rhs->expr_type == EXPR_VARIABLE
13643 3630 : && (gfc_impure_variable (rhs->symtree->n.sym)
13644 2 : || gfc_is_coindexed (rhs)))
13645 : {
13646 : /* F2008, C1283. */
13647 2 : if (gfc_is_coindexed (rhs))
13648 1 : gfc_error ("Coindexed expression at %L is assigned to "
13649 : "a derived type variable with a POINTER "
13650 : "component in a PURE procedure",
13651 : &rhs->where);
13652 : else
13653 : /* F2008, C1283 (4). */
13654 1 : gfc_error ("In a pure subprogram an INTENT(IN) dummy argument "
13655 : "shall not be used as the expr at %L of an intrinsic "
13656 : "assignment statement in which the variable is of a "
13657 : "derived type if the derived type has a pointer "
13658 : "component at any level of component selection.",
13659 : &rhs->where);
13660 : return rval;
13661 : }
13662 :
13663 : /* Fortran 2008, C1283. */
13664 3625 : if (gfc_is_coindexed (lhs))
13665 : {
13666 1 : gfc_error ("Assignment to coindexed variable at %L in a PURE "
13667 : "procedure", &rhs->where);
13668 1 : return rval;
13669 : }
13670 : }
13671 :
13672 290150 : if (gfc_implicit_pure (NULL))
13673 : {
13674 7847 : if (lhs->expr_type == EXPR_VARIABLE
13675 7847 : && lhs->symtree->n.sym != gfc_current_ns->proc_name
13676 5605 : && lhs->symtree->n.sym->ns != gfc_current_ns)
13677 268 : gfc_unset_implicit_pure (NULL);
13678 :
13679 7847 : if (lhs->ts.type == BT_DERIVED
13680 385 : && lhs->expr_type == EXPR_VARIABLE
13681 385 : && lhs->ts.u.derived->attr.pointer_comp
13682 7 : && rhs->expr_type == EXPR_VARIABLE
13683 7854 : && (gfc_impure_variable (rhs->symtree->n.sym)
13684 7 : || gfc_is_coindexed (rhs)))
13685 0 : gfc_unset_implicit_pure (NULL);
13686 :
13687 : /* Fortran 2008, C1283. */
13688 7847 : if (gfc_is_coindexed (lhs))
13689 0 : gfc_unset_implicit_pure (NULL);
13690 : }
13691 :
13692 : /* F2008, 7.2.1.2. */
13693 290150 : attr = gfc_expr_attr (lhs);
13694 290150 : if (lhs->ts.type == BT_CLASS && attr.allocatable)
13695 : {
13696 1042 : if (attr.codimension)
13697 : {
13698 1 : gfc_error ("Assignment to polymorphic coarray at %L is not "
13699 : "permitted", &lhs->where);
13700 1 : return false;
13701 : }
13702 1041 : if (!gfc_notify_std (GFC_STD_F2008, "Assignment to an allocatable "
13703 : "polymorphic variable at %L", &lhs->where))
13704 : return false;
13705 1040 : if (!flag_realloc_lhs)
13706 : {
13707 1 : gfc_error ("Assignment to an allocatable polymorphic variable at %L "
13708 : "requires %<-frealloc-lhs%>", &lhs->where);
13709 1 : return false;
13710 : }
13711 : }
13712 289108 : else if (lhs->ts.type == BT_CLASS)
13713 : {
13714 9 : gfc_error ("Nonallocatable variable must not be polymorphic in intrinsic "
13715 : "assignment at %L - check that there is a matching specific "
13716 : "subroutine for %<=%> operator", &lhs->where);
13717 9 : return false;
13718 : }
13719 :
13720 290138 : bool lhs_coindexed = gfc_is_coindexed (lhs);
13721 :
13722 : /* F2008, Section 7.2.1.2. */
13723 290138 : if (lhs_coindexed && gfc_has_ultimate_allocatable (lhs))
13724 : {
13725 1 : gfc_error ("Coindexed variable must not have an allocatable ultimate "
13726 : "component in assignment at %L", &lhs->where);
13727 1 : return false;
13728 : }
13729 :
13730 : /* Assign the 'data' of a class object to a derived type. */
13731 290137 : if (lhs->ts.type == BT_DERIVED
13732 7695 : && rhs->ts.type == BT_CLASS
13733 180 : && (rhs->expr_type != EXPR_ARRAY
13734 174 : && rhs->expr_type != EXPR_OP))
13735 168 : gfc_add_data_component (rhs);
13736 :
13737 : /* Make sure there is a vtable and, in particular, a _copy for the
13738 : rhs type. */
13739 290137 : if (lhs->ts.type == BT_CLASS && rhs->ts.type != BT_CLASS)
13740 628 : gfc_find_vtab (&rhs->ts);
13741 :
13742 290137 : gfc_check_assign (lhs, rhs, 1);
13743 :
13744 290137 : return false;
13745 : }
13746 :
13747 :
13748 : /* Add a component reference onto an expression. */
13749 :
13750 : static void
13751 647 : add_comp_ref (gfc_expr *e, gfc_component *c)
13752 : {
13753 647 : gfc_ref **ref;
13754 647 : ref = &(e->ref);
13755 871 : while (*ref)
13756 224 : ref = &((*ref)->next);
13757 647 : *ref = gfc_get_ref ();
13758 647 : (*ref)->type = REF_COMPONENT;
13759 647 : (*ref)->u.c.sym = e->ts.u.derived;
13760 647 : (*ref)->u.c.component = c;
13761 647 : e->ts = c->ts;
13762 :
13763 : /* Add a full array ref, as necessary. */
13764 647 : if (c->as)
13765 : {
13766 84 : gfc_add_full_array_ref (e, c->as);
13767 84 : e->rank = c->as->rank;
13768 84 : e->corank = c->as->corank;
13769 : }
13770 647 : }
13771 :
13772 :
13773 : /* Build an assignment. Keep the argument 'op' for future use, so that
13774 : pointer assignments can be made. */
13775 :
13776 : static gfc_code *
13777 982 : build_assignment (gfc_exec_op op, gfc_expr *expr1, gfc_expr *expr2,
13778 : gfc_component *comp1, gfc_component *comp2, locus loc)
13779 : {
13780 982 : gfc_code *this_code;
13781 :
13782 982 : this_code = gfc_get_code (op);
13783 982 : this_code->next = NULL;
13784 982 : this_code->expr1 = gfc_copy_expr (expr1);
13785 982 : this_code->expr2 = gfc_copy_expr (expr2);
13786 982 : this_code->loc = loc;
13787 982 : if (comp1 && comp2)
13788 : {
13789 288 : add_comp_ref (this_code->expr1, comp1);
13790 288 : add_comp_ref (this_code->expr2, comp2);
13791 : }
13792 :
13793 982 : return this_code;
13794 : }
13795 :
13796 :
13797 : /* Makes a temporary variable expression based on the characteristics of
13798 : a given variable expression. If allocatable is set, the temporary is
13799 : unconditionally allocatable*/
13800 :
13801 : static gfc_expr*
13802 500 : get_temp_from_expr (gfc_expr *e, gfc_namespace *ns,
13803 : bool allocatable = false)
13804 : {
13805 500 : static int serial = 0;
13806 500 : char name[GFC_MAX_SYMBOL_LEN];
13807 500 : gfc_symtree *tmp;
13808 500 : gfc_array_spec *as;
13809 500 : gfc_array_ref *aref;
13810 500 : gfc_ref *ref;
13811 :
13812 500 : sprintf (name, GFC_PREFIX("DA%d"), serial++);
13813 500 : gfc_get_sym_tree (name, ns, &tmp, false);
13814 500 : gfc_add_type (tmp->n.sym, &e->ts, NULL);
13815 :
13816 500 : if (e->expr_type == EXPR_CONSTANT && e->ts.type == BT_CHARACTER)
13817 0 : tmp->n.sym->ts.u.cl->length = gfc_get_int_expr (gfc_charlen_int_kind,
13818 : NULL,
13819 0 : e->value.character.length);
13820 :
13821 500 : as = NULL;
13822 500 : ref = NULL;
13823 500 : aref = NULL;
13824 :
13825 : /* Obtain the arrayspec for the temporary. */
13826 500 : if (e->rank && e->expr_type != EXPR_ARRAY
13827 : && e->expr_type != EXPR_FUNCTION
13828 : && e->expr_type != EXPR_OP)
13829 : {
13830 52 : aref = gfc_find_array_ref (e);
13831 52 : if (e->expr_type == EXPR_VARIABLE
13832 52 : && e->symtree->n.sym->as == aref->as)
13833 : as = aref->as;
13834 : else
13835 : {
13836 0 : for (ref = e->ref; ref; ref = ref->next)
13837 0 : if (ref->type == REF_COMPONENT
13838 0 : && ref->u.c.component->as == aref->as)
13839 : {
13840 : as = aref->as;
13841 : break;
13842 : }
13843 : }
13844 : }
13845 :
13846 : /* Add the attributes and the arrayspec to the temporary. */
13847 500 : tmp->n.sym->attr = gfc_expr_attr (e);
13848 500 : tmp->n.sym->attr.function = 0;
13849 500 : tmp->n.sym->attr.proc_pointer = 0;
13850 500 : tmp->n.sym->attr.result = 0;
13851 500 : tmp->n.sym->attr.flavor = FL_VARIABLE;
13852 500 : tmp->n.sym->attr.dummy = 0;
13853 500 : tmp->n.sym->attr.use_assoc = 0;
13854 500 : tmp->n.sym->attr.intent = INTENT_UNKNOWN;
13855 :
13856 :
13857 500 : if (as && !allocatable)
13858 : {
13859 52 : tmp->n.sym->as = gfc_copy_array_spec (as);
13860 52 : if (!ref)
13861 52 : ref = e->ref;
13862 52 : if (as->type == AS_DEFERRED)
13863 46 : tmp->n.sym->attr.allocatable = 1;
13864 : }
13865 448 : else if ((e->rank || e->corank)
13866 136 : && (e->expr_type == EXPR_ARRAY || e->expr_type == EXPR_FUNCTION
13867 24 : || e->expr_type == EXPR_OP || allocatable))
13868 : {
13869 136 : tmp->n.sym->as = gfc_get_array_spec ();
13870 136 : tmp->n.sym->as->type = AS_DEFERRED;
13871 136 : tmp->n.sym->as->rank = e->rank;
13872 136 : tmp->n.sym->as->corank = e->corank;
13873 136 : tmp->n.sym->attr.allocatable = 1;
13874 136 : tmp->n.sym->attr.dimension = e->rank ? 1 : 0;
13875 272 : tmp->n.sym->attr.codimension = e->corank ? 1 : 0;
13876 : }
13877 : else
13878 312 : tmp->n.sym->attr.dimension = 0;
13879 :
13880 500 : gfc_set_sym_referenced (tmp->n.sym);
13881 500 : gfc_commit_symbol (tmp->n.sym);
13882 500 : e = gfc_lval_expr_from_sym (tmp->n.sym);
13883 :
13884 : /* Should the lhs be a section, use its array ref for the
13885 : temporary expression. */
13886 500 : if (aref && aref->type != AR_FULL && !allocatable)
13887 : {
13888 6 : gfc_free_ref_list (e->ref);
13889 6 : e->ref = gfc_copy_ref (ref);
13890 : }
13891 500 : return e;
13892 : }
13893 :
13894 :
13895 : gfc_expr*
13896 30 : gfc_get_temp_from_expr (gfc_expr *e, gfc_namespace *ns,
13897 : bool allocatable = false)
13898 : {
13899 30 : return get_temp_from_expr (e, ns, allocatable);
13900 : }
13901 :
13902 :
13903 : /* Helper function to take an argument in a subroutine call with a dependency
13904 : on another argument, copy it to an allocatable temporary and use the
13905 : temporary in the call expression. The new code is embedded in a block to
13906 : ensure local, automatic deallocation. */
13907 :
13908 : static void
13909 36 : add_temp_assign_before_call (gfc_code *code, gfc_namespace *ns,
13910 : gfc_expr **rhsptr)
13911 : {
13912 36 : gfc_namespace *block_ns;
13913 36 : gfc_expr *tmp_var;
13914 :
13915 : /* Wrap the new code in a block so that the temporary is deallocated. */
13916 36 : block_ns = gfc_build_block_ns (ns);
13917 :
13918 : /* As it stands, the block_ns does not not stand up to resolution because the
13919 : the assignment would be converted to a call and, in any case, the modified
13920 : call fails in gfc_check_conformance. */
13921 36 : block_ns->resolved = 1;
13922 :
13923 : /* Assign the original expression to the temporary. */
13924 36 : tmp_var = get_temp_from_expr (*rhsptr, block_ns, true);
13925 72 : block_ns->code = build_assignment (EXEC_ASSIGN, tmp_var, *rhsptr,
13926 36 : NULL, NULL, (*rhsptr)->where);
13927 :
13928 : /* Transfer the call to the block and terminate block code. */
13929 36 : *rhsptr = gfc_copy_expr (tmp_var);
13930 36 : block_ns->code->next = gfc_get_code (EXEC_NOP);
13931 36 : *(block_ns->code->next) = *code;
13932 36 : block_ns->code->next->next = NULL;
13933 :
13934 : /* Convert the original code to execute the block. */
13935 36 : code->op = EXEC_BLOCK;
13936 36 : code->ext.block.ns = block_ns;
13937 36 : code->ext.block.assoc = NULL;
13938 36 : code->expr1 = code->expr2 = NULL;
13939 36 : }
13940 :
13941 :
13942 : /* Add one line of code to the code chain, making sure that 'head' and
13943 : 'tail' are appropriately updated. */
13944 :
13945 : static void
13946 650 : add_code_to_chain (gfc_code **this_code, gfc_code **head, gfc_code **tail)
13947 : {
13948 650 : gcc_assert (this_code);
13949 650 : if (*head == NULL)
13950 302 : *head = *tail = *this_code;
13951 : else
13952 348 : *tail = gfc_append_code (*tail, *this_code);
13953 650 : *this_code = NULL;
13954 650 : }
13955 :
13956 :
13957 : /* Generate a final call from a variable expression */
13958 :
13959 : static void
13960 81 : generate_final_call (gfc_expr *tmp_expr, gfc_code **head, gfc_code **tail)
13961 : {
13962 81 : gfc_code *this_code;
13963 81 : gfc_expr *final_expr = NULL;
13964 81 : gfc_expr *size_expr;
13965 81 : gfc_expr *fini_coarray;
13966 :
13967 81 : gcc_assert (tmp_expr->expr_type == EXPR_VARIABLE);
13968 81 : if (!gfc_is_finalizable (tmp_expr->ts.u.derived, &final_expr) || !final_expr)
13969 75 : return;
13970 :
13971 : /* Now generate the finalizer call. */
13972 6 : this_code = gfc_get_code (EXEC_CALL);
13973 6 : this_code->symtree = final_expr->symtree;
13974 6 : this_code->resolved_sym = final_expr->symtree->n.sym;
13975 :
13976 : //* Expression to be finalized */
13977 6 : this_code->ext.actual = gfc_get_actual_arglist ();
13978 6 : this_code->ext.actual->expr = gfc_copy_expr (tmp_expr);
13979 :
13980 : /* size_expr = STORAGE_SIZE (...) / NUMERIC_STORAGE_SIZE. */
13981 6 : this_code->ext.actual->next = gfc_get_actual_arglist ();
13982 6 : size_expr = gfc_get_expr ();
13983 6 : size_expr->where = gfc_current_locus;
13984 6 : size_expr->expr_type = EXPR_OP;
13985 6 : size_expr->value.op.op = INTRINSIC_DIVIDE;
13986 6 : size_expr->value.op.op1
13987 12 : = gfc_build_intrinsic_call (gfc_current_ns, GFC_ISYM_STORAGE_SIZE,
13988 : "storage_size", gfc_current_locus, 2,
13989 6 : gfc_lval_expr_from_sym (tmp_expr->symtree->n.sym),
13990 : gfc_get_int_expr (gfc_index_integer_kind,
13991 : NULL, 0));
13992 6 : size_expr->value.op.op2 = gfc_get_int_expr (gfc_index_integer_kind, NULL,
13993 : gfc_character_storage_size);
13994 6 : size_expr->value.op.op1->ts = size_expr->value.op.op2->ts;
13995 6 : size_expr->ts = size_expr->value.op.op1->ts;
13996 6 : this_code->ext.actual->next->expr = size_expr;
13997 :
13998 : /* fini_coarray */
13999 6 : this_code->ext.actual->next->next = gfc_get_actual_arglist ();
14000 6 : fini_coarray = gfc_get_constant_expr (BT_LOGICAL, gfc_default_logical_kind,
14001 : &tmp_expr->where);
14002 6 : fini_coarray->value.logical = (int)gfc_expr_attr (tmp_expr).codimension;
14003 6 : this_code->ext.actual->next->next->expr = fini_coarray;
14004 :
14005 6 : add_code_to_chain (&this_code, head, tail);
14006 :
14007 : }
14008 :
14009 : /* Counts the potential number of part array references that would
14010 : result from resolution of typebound defined assignments. */
14011 :
14012 :
14013 : static int
14014 249 : nonscalar_typebound_assign (gfc_symbol *derived, int depth)
14015 : {
14016 249 : gfc_component *c;
14017 249 : int c_depth = 0, t_depth;
14018 :
14019 596 : for (c= derived->components; c; c = c->next)
14020 : {
14021 347 : if ((!gfc_bt_struct (c->ts.type)
14022 267 : || c->attr.pointer
14023 267 : || c->attr.allocatable
14024 266 : || c->attr.proc_pointer_comp
14025 266 : || c->attr.class_pointer
14026 266 : || c->attr.proc_pointer)
14027 81 : && !c->attr.defined_assign_comp)
14028 81 : continue;
14029 :
14030 266 : if (c->as && c_depth == 0)
14031 266 : c_depth = 1;
14032 :
14033 266 : if (c->ts.u.derived->attr.defined_assign_comp)
14034 110 : t_depth = nonscalar_typebound_assign (c->ts.u.derived,
14035 : c->as ? 1 : 0);
14036 : else
14037 : t_depth = 0;
14038 :
14039 266 : c_depth = t_depth > c_depth ? t_depth : c_depth;
14040 : }
14041 249 : return depth + c_depth;
14042 : }
14043 :
14044 :
14045 : /* Implement 10.2.1.3 paragraph 13 of the F18 standard:
14046 : "An intrinsic assignment where the variable is of derived type is performed
14047 : as if each component of the variable were assigned from the corresponding
14048 : component of expr using pointer assignment (10.2.2) for each pointer
14049 : component, defined assignment for each nonpointer nonallocatable component
14050 : of a type that has a type-bound defined assignment consistent with the
14051 : component, intrinsic assignment for each other nonpointer nonallocatable
14052 : component, and intrinsic assignment for each allocated coarray component.
14053 : For unallocated coarray components, the corresponding component of the
14054 : variable shall be unallocated. For a noncoarray allocatable component the
14055 : following sequence of operations is applied.
14056 : (1) If the component of the variable is allocated, it is deallocated.
14057 : (2) If the component of the value of expr is allocated, the
14058 : corresponding component of the variable is allocated with the same
14059 : dynamic type and type parameters as the component of the value of
14060 : expr. If it is an array, it is allocated with the same bounds. The
14061 : value of the component of the value of expr is then assigned to the
14062 : corresponding component of the variable using defined assignment if
14063 : the declared type of the component has a type-bound defined
14064 : assignment consistent with the component, and intrinsic assignment
14065 : for the dynamic type of that component otherwise."
14066 :
14067 : The pointer assignments are taken care of by the intrinsic assignment of the
14068 : structure itself. This function recursively adds defined assignments where
14069 : required. The recursion is accomplished by calling gfc_resolve_code.
14070 :
14071 : When the lhs in a defined assignment has intent INOUT or is intent OUT
14072 : and the component of 'var' is finalizable, we need a temporary for the
14073 : lhs. In pseudo-code for an assignment var = expr:
14074 :
14075 : ! Confine finalization of temporaries, as far as possible.
14076 : Enclose the code for the assignment in a block
14077 : ! Only call function 'expr' once.
14078 : #if ('expr is not a constant or an variable)
14079 : temp_expr = expr
14080 : expr = temp_x
14081 : ! Do the intrinsic assignment
14082 : #if typeof ('var') has a typebound final subroutine
14083 : finalize (var)
14084 : var = expr
14085 : ! Now do the component assignments
14086 : #do over derived type components [%cmp]
14087 : #if (cmp is a pointer of any kind)
14088 : continue
14089 : build the assignment
14090 : resolve the code
14091 : #if the code is a typebound assignment
14092 : #if (arg1 is INOUT or finalizable OUT && !t1)
14093 : t1 = var
14094 : arg1 = t1
14095 : deal with allocatation or not of var and this component
14096 : #elseif the code is an assignment by itself
14097 : #if this component does not need finalization
14098 : delete code and continue
14099 : #else
14100 : remove the leading assignment
14101 : #endif
14102 : commit the code
14103 : #if (t1 and (arg1 is INOUT or finalizable OUT))
14104 : var%cmp = t1%cmp
14105 : #enddo
14106 : put all code chunks involving t1 to the top of the generated code
14107 : insert the generated block in place of the original code
14108 : */
14109 :
14110 : static bool
14111 393 : is_finalizable_type (gfc_typespec ts)
14112 : {
14113 393 : gfc_component *c;
14114 :
14115 393 : if (ts.type != BT_DERIVED)
14116 : return false;
14117 :
14118 : /* (1) Check for FINAL subroutines. */
14119 393 : if (ts.u.derived->f2k_derived && ts.u.derived->f2k_derived->finalizers)
14120 : return true;
14121 :
14122 : /* (2) Check for components of finalizable type. */
14123 815 : for (c = ts.u.derived->components; c; c = c->next)
14124 476 : if (c->ts.type == BT_DERIVED
14125 249 : && !c->attr.pointer && !c->attr.proc_pointer && !c->attr.allocatable
14126 248 : && c->ts.u.derived->f2k_derived
14127 248 : && c->ts.u.derived->f2k_derived->finalizers)
14128 : return true;
14129 :
14130 : return false;
14131 : }
14132 :
14133 : /* The temporary assignments have to be put on top of the additional
14134 : code to avoid the result being changed by the intrinsic assignment.
14135 : */
14136 : static int component_assignment_level = 0;
14137 : static gfc_code *tmp_head = NULL, *tmp_tail = NULL;
14138 : static bool finalizable_comp;
14139 :
14140 : static void
14141 194 : generate_component_assignments (gfc_code **code, gfc_namespace *ns)
14142 : {
14143 194 : gfc_component *comp1, *comp2;
14144 194 : gfc_code *this_code = NULL, *head = NULL, *tail = NULL;
14145 194 : gfc_code *tmp_code = NULL;
14146 194 : gfc_expr *t1 = NULL;
14147 194 : gfc_expr *tmp_expr = NULL;
14148 194 : int error_count, depth;
14149 194 : bool finalizable_lhs;
14150 194 : bool use_finalize_only;
14151 :
14152 194 : gfc_get_errors (NULL, &error_count);
14153 :
14154 : /* Filter out continuing processing after an error. */
14155 194 : if (error_count
14156 194 : || (*code)->expr1->ts.type != BT_DERIVED
14157 194 : || (*code)->expr2->ts.type != BT_DERIVED)
14158 146 : return;
14159 :
14160 : /* TODO: Handle more than one part array reference in assignments. */
14161 194 : depth = nonscalar_typebound_assign ((*code)->expr1->ts.u.derived,
14162 194 : (*code)->expr1->rank ? 1 : 0);
14163 194 : if (depth > 1)
14164 : {
14165 6 : gfc_warning (0, "TODO: type-bound defined assignment(s) at %L not "
14166 : "done because multiple part array references would "
14167 : "occur in intermediate expressions.", &(*code)->loc);
14168 6 : return;
14169 : }
14170 :
14171 188 : if (!component_assignment_level)
14172 140 : finalizable_comp = true;
14173 :
14174 : /* Build a block so that function result temporaries are finalized
14175 : locally on exiting the rather than enclosing scope. */
14176 188 : if (!component_assignment_level)
14177 : {
14178 140 : ns = gfc_build_block_ns (ns);
14179 140 : tmp_code = gfc_get_code (EXEC_NOP);
14180 140 : *tmp_code = **code;
14181 140 : tmp_code->next = NULL;
14182 140 : (*code)->op = EXEC_BLOCK;
14183 140 : (*code)->ext.block.ns = ns;
14184 140 : (*code)->ext.block.assoc = NULL;
14185 140 : (*code)->expr1 = (*code)->expr2 = NULL;
14186 140 : ns->code = tmp_code;
14187 140 : code = &ns->code;
14188 : }
14189 :
14190 188 : component_assignment_level++;
14191 :
14192 188 : finalizable_lhs = is_finalizable_type ((*code)->expr1->ts);
14193 :
14194 : /* When the lhs is finalized as a whole and none of its components needs the
14195 : structure copy to handle it (no pointer or allocatable components), the
14196 : copy can be done component by component. The whole-derived-type assignment
14197 : then only finalizes the lhs and a component with a defined assignment keeps
14198 : its post-finalization value for the INTENT (OUT) finalization in that
14199 : defined assignment. */
14200 188 : use_finalize_only = finalizable_lhs;
14201 188 : if (use_finalize_only)
14202 66 : for (comp1 = (*code)->expr1->ts.u.derived->components; comp1;
14203 42 : comp1 = comp1->next)
14204 42 : if (comp1->attr.pointer || comp1->attr.allocatable
14205 42 : || comp1->attr.proc_pointer_comp || comp1->attr.class_pointer
14206 42 : || comp1->attr.proc_pointer)
14207 : {
14208 : use_finalize_only = false;
14209 : break;
14210 : }
14211 :
14212 : /* Create a temporary so that functions get called only once. */
14213 188 : if ((*code)->expr2->expr_type != EXPR_VARIABLE
14214 188 : && (*code)->expr2->expr_type != EXPR_CONSTANT)
14215 : {
14216 : /* Assign the rhs to the temporary. */
14217 81 : tmp_expr = get_temp_from_expr ((*code)->expr1, ns);
14218 81 : if (tmp_expr->symtree->n.sym->attr.pointer)
14219 : {
14220 : /* Use allocate on assignment for the sake of simplicity. The
14221 : temporary must not take on the optional attribute. Assume
14222 : that the assignment is guarded by a PRESENT condition if the
14223 : lhs is optional. */
14224 25 : tmp_expr->symtree->n.sym->attr.pointer = 0;
14225 25 : tmp_expr->symtree->n.sym->attr.optional = 0;
14226 25 : tmp_expr->symtree->n.sym->attr.allocatable = 1;
14227 : }
14228 162 : this_code = build_assignment (EXEC_ASSIGN,
14229 : tmp_expr, (*code)->expr2,
14230 81 : NULL, NULL, (*code)->loc);
14231 81 : this_code->expr2->must_finalize = 1;
14232 : /* Add the code and substitute the rhs expression. */
14233 81 : add_code_to_chain (&this_code, &tmp_head, &tmp_tail);
14234 81 : gfc_free_expr ((*code)->expr2);
14235 81 : (*code)->expr2 = tmp_expr;
14236 : }
14237 :
14238 : /* Do the intrinsic assignment. This is not needed if the lhs is one
14239 : of the temporaries generated here, since the intrinsic assignment
14240 : to the final result already does this. */
14241 188 : if ((*code)->expr1->symtree->n.sym->name[2] != '.')
14242 : {
14243 188 : if (finalizable_lhs)
14244 24 : (*code)->expr1->must_finalize = 1;
14245 188 : this_code = build_assignment (EXEC_ASSIGN,
14246 : (*code)->expr1, (*code)->expr2,
14247 : NULL, NULL, (*code)->loc);
14248 188 : if (use_finalize_only)
14249 24 : this_code->expr1->finalize_only = 1;
14250 188 : add_code_to_chain (&this_code, &head, &tail);
14251 : }
14252 :
14253 188 : comp1 = (*code)->expr1->ts.u.derived->components;
14254 188 : comp2 = (*code)->expr2->ts.u.derived->components;
14255 :
14256 461 : for (; comp1; comp1 = comp1->next, comp2 = comp2->next)
14257 : {
14258 273 : bool inout = false;
14259 273 : bool finalizable_out = false;
14260 :
14261 : /* The intrinsic assignment does the right thing for pointers
14262 : of all kinds and allocatable components. */
14263 273 : if (!gfc_bt_struct (comp1->ts.type)
14264 206 : || comp1->attr.pointer
14265 206 : || comp1->attr.allocatable
14266 205 : || comp1->attr.proc_pointer_comp
14267 205 : || comp1->attr.class_pointer
14268 205 : || comp1->attr.proc_pointer)
14269 : {
14270 : /* With finalize_only the whole-derived-type assignment does not copy
14271 : the components, so emit the copy for this one here. Only plain
14272 : components reach this point, since use_finalize_only excludes
14273 : pointer and allocatable components. */
14274 68 : if (use_finalize_only)
14275 : {
14276 24 : this_code = build_assignment (EXEC_ASSIGN,
14277 : (*code)->expr1, (*code)->expr2,
14278 12 : comp1, comp2, (*code)->loc);
14279 12 : add_code_to_chain (&this_code, &head, &tail);
14280 : }
14281 68 : continue;
14282 : }
14283 :
14284 410 : finalizable_comp = is_finalizable_type (comp1->ts)
14285 205 : && !finalizable_lhs;
14286 :
14287 : /* Make an assignment for this component. */
14288 410 : this_code = build_assignment (EXEC_ASSIGN,
14289 : (*code)->expr1, (*code)->expr2,
14290 205 : comp1, comp2, (*code)->loc);
14291 :
14292 : /* Convert the assignment if there is a defined assignment for
14293 : this type. Otherwise, using the call from gfc_resolve_code,
14294 : recurse into its components. */
14295 205 : gfc_resolve_code (this_code, ns);
14296 :
14297 205 : if (this_code->op == EXEC_ASSIGN_CALL)
14298 : {
14299 150 : gfc_formal_arglist *dummy_args;
14300 150 : gfc_symbol *rsym;
14301 : /* Check that there is a typebound defined assignment. If not,
14302 : then this must be a module defined assignment. We cannot
14303 : use the defined_assign_comp attribute here because it must
14304 : be this derived type that has the defined assignment and not
14305 : a parent type. */
14306 150 : if (!(comp1->ts.u.derived->f2k_derived
14307 : && comp1->ts.u.derived->f2k_derived
14308 150 : ->tb_op[INTRINSIC_ASSIGN]))
14309 : {
14310 1 : gfc_free_statements (this_code);
14311 1 : this_code = NULL;
14312 1 : continue;
14313 : }
14314 :
14315 : /* If the first argument of the subroutine has intent INOUT
14316 : a temporary must be generated and used instead. */
14317 149 : rsym = this_code->resolved_sym;
14318 149 : dummy_args = gfc_sym_get_dummy_args (rsym);
14319 274 : finalizable_out = gfc_may_be_finalized (comp1->ts)
14320 24 : && dummy_args
14321 173 : && dummy_args->sym->attr.intent == INTENT_OUT;
14322 274 : inout = dummy_args
14323 274 : && dummy_args->sym->attr.intent == INTENT_INOUT;
14324 : /* With finalize_only the lhs component keeps its post-finalization
14325 : value, so the defined assignment can finalize it directly through
14326 : its INTENT (OUT) argument and no temporary is needed. */
14327 78 : if ((inout || (finalizable_out && !use_finalize_only))
14328 71 : && !comp1->attr.allocatable)
14329 : {
14330 71 : gfc_code *temp_code;
14331 71 : inout = true;
14332 :
14333 : /* Build the temporary required for the assignment and put
14334 : it at the head of the generated code. */
14335 71 : if (!t1)
14336 : {
14337 71 : gfc_namespace *tmp_ns = ns;
14338 71 : if (ns->parent && gfc_may_be_finalized (comp1->ts))
14339 0 : tmp_ns = (*code)->expr1->symtree->n.sym->ns;
14340 71 : t1 = get_temp_from_expr ((*code)->expr1, tmp_ns);
14341 71 : t1->symtree->n.sym->attr.artificial = 1;
14342 142 : temp_code = build_assignment (EXEC_ASSIGN,
14343 : t1, (*code)->expr1,
14344 71 : NULL, NULL, (*code)->loc);
14345 :
14346 : /* For allocatable LHS, check whether it is allocated. Note
14347 : that allocatable components with defined assignment are
14348 : not yet support. See PR 57696. */
14349 71 : if ((*code)->expr1->symtree->n.sym->attr.allocatable)
14350 : {
14351 24 : gfc_code *block;
14352 24 : gfc_expr *e =
14353 24 : gfc_lval_expr_from_sym ((*code)->expr1->symtree->n.sym);
14354 24 : block = gfc_get_code (EXEC_IF);
14355 24 : block->block = gfc_get_code (EXEC_IF);
14356 24 : block->block->expr1
14357 48 : = gfc_build_intrinsic_call (ns,
14358 : GFC_ISYM_ALLOCATED, "allocated",
14359 24 : (*code)->loc, 1, e);
14360 24 : block->block->next = temp_code;
14361 24 : temp_code = block;
14362 : }
14363 71 : add_code_to_chain (&temp_code, &tmp_head, &tmp_tail);
14364 : }
14365 :
14366 : /* Replace the first actual arg with the component of the
14367 : temporary. */
14368 71 : gfc_free_expr (this_code->ext.actual->expr);
14369 71 : this_code->ext.actual->expr = gfc_copy_expr (t1);
14370 71 : add_comp_ref (this_code->ext.actual->expr, comp1);
14371 :
14372 : /* If the LHS variable is allocatable and wasn't allocated and
14373 : the temporary is allocatable, pointer assign the address of
14374 : the freshly allocated LHS to the temporary. */
14375 71 : if ((*code)->expr1->symtree->n.sym->attr.allocatable
14376 71 : && gfc_expr_attr ((*code)->expr1).allocatable)
14377 : {
14378 18 : gfc_code *block;
14379 18 : gfc_expr *cond;
14380 :
14381 18 : cond = gfc_get_expr ();
14382 18 : cond->ts.type = BT_LOGICAL;
14383 18 : cond->ts.kind = gfc_default_logical_kind;
14384 18 : cond->expr_type = EXPR_OP;
14385 18 : cond->where = (*code)->loc;
14386 18 : cond->value.op.op = INTRINSIC_NOT;
14387 18 : cond->value.op.op1 = gfc_build_intrinsic_call (ns,
14388 : GFC_ISYM_ALLOCATED, "allocated",
14389 18 : (*code)->loc, 1, gfc_copy_expr (t1));
14390 18 : block = gfc_get_code (EXEC_IF);
14391 18 : block->block = gfc_get_code (EXEC_IF);
14392 18 : block->block->expr1 = cond;
14393 36 : block->block->next = build_assignment (EXEC_POINTER_ASSIGN,
14394 : t1, (*code)->expr1,
14395 18 : NULL, NULL, (*code)->loc);
14396 18 : add_code_to_chain (&block, &head, &tail);
14397 : }
14398 : }
14399 : }
14400 55 : else if (this_code->op == EXEC_ASSIGN && !this_code->next)
14401 : {
14402 : /* Don't add intrinsic assignments since they are already
14403 : effected by the intrinsic assignment of the structure, unless
14404 : finalization is required or, with finalize_only, the structure
14405 : assignment does not copy the components. */
14406 7 : if (finalizable_comp)
14407 0 : this_code->expr1->must_finalize = 1;
14408 7 : else if (!use_finalize_only)
14409 : {
14410 1 : gfc_free_statements (this_code);
14411 1 : this_code = NULL;
14412 1 : continue;
14413 : }
14414 : }
14415 : else
14416 : {
14417 : /* Resolution has expanded an assignment of a derived type with
14418 : defined assigned components. Remove the redundant, leading
14419 : assignment. */
14420 48 : gcc_assert (this_code->op == EXEC_ASSIGN);
14421 48 : gfc_code *tmp = this_code;
14422 48 : this_code = this_code->next;
14423 48 : tmp->next = NULL;
14424 48 : gfc_free_statements (tmp);
14425 : }
14426 :
14427 203 : add_code_to_chain (&this_code, &head, &tail);
14428 :
14429 203 : if (t1 && (inout || (finalizable_out && !use_finalize_only)))
14430 : {
14431 : /* Transfer the value to the final result. */
14432 142 : this_code = build_assignment (EXEC_ASSIGN,
14433 : (*code)->expr1, t1,
14434 71 : comp1, comp2, (*code)->loc);
14435 71 : this_code->expr1->must_finalize = 0;
14436 71 : add_code_to_chain (&this_code, &head, &tail);
14437 : }
14438 : }
14439 :
14440 : /* Put the temporary assignments at the top of the generated code. */
14441 188 : if (tmp_head && component_assignment_level == 1)
14442 : {
14443 114 : gfc_append_code (tmp_head, head);
14444 114 : head = tmp_head;
14445 114 : tmp_head = tmp_tail = NULL;
14446 : }
14447 :
14448 : /* If we did a pointer assignment - thus, we need to ensure that the LHS is
14449 : not accidentally deallocated. Hence, nullify t1. */
14450 71 : if (t1 && (*code)->expr1->symtree->n.sym->attr.allocatable
14451 259 : && gfc_expr_attr ((*code)->expr1).allocatable)
14452 : {
14453 18 : gfc_code *block;
14454 18 : gfc_expr *cond;
14455 18 : gfc_expr *e;
14456 :
14457 18 : e = gfc_lval_expr_from_sym ((*code)->expr1->symtree->n.sym);
14458 18 : cond = gfc_build_intrinsic_call (ns, GFC_ISYM_ASSOCIATED, "associated",
14459 18 : (*code)->loc, 2, gfc_copy_expr (t1), e);
14460 18 : block = gfc_get_code (EXEC_IF);
14461 18 : block->block = gfc_get_code (EXEC_IF);
14462 18 : block->block->expr1 = cond;
14463 18 : block->block->next = build_assignment (EXEC_POINTER_ASSIGN,
14464 : t1, gfc_get_null_expr (&(*code)->loc),
14465 18 : NULL, NULL, (*code)->loc);
14466 18 : gfc_append_code (tail, block);
14467 18 : tail = block;
14468 : }
14469 :
14470 188 : component_assignment_level--;
14471 :
14472 : /* Make an explicit final call for the function result. */
14473 188 : if (tmp_expr)
14474 81 : generate_final_call (tmp_expr, &head, &tail);
14475 :
14476 188 : if (tmp_code)
14477 : {
14478 140 : ns->code = head;
14479 140 : return;
14480 : }
14481 :
14482 : /* Now attach the remaining code chain to the input code. Step on
14483 : to the end of the new code since resolution is complete. */
14484 48 : gcc_assert ((*code)->op == EXEC_ASSIGN);
14485 48 : tail->next = (*code)->next;
14486 : /* Overwrite 'code' because this would place the intrinsic assignment
14487 : before the temporary for the lhs is created. */
14488 48 : gfc_free_expr ((*code)->expr1);
14489 48 : gfc_free_expr ((*code)->expr2);
14490 48 : **code = *head;
14491 48 : if (head != tail)
14492 48 : free (head);
14493 48 : *code = tail;
14494 : }
14495 :
14496 :
14497 : /* F2008: Pointer function assignments are of the form:
14498 : ptr_fcn (args) = expr
14499 : This function breaks these assignments into two statements:
14500 : temporary_pointer => ptr_fcn(args)
14501 : temporary_pointer = expr */
14502 :
14503 : static bool
14504 291363 : resolve_ptr_fcn_assign (gfc_code **code, gfc_namespace *ns)
14505 : {
14506 291363 : gfc_expr *tmp_ptr_expr;
14507 291363 : gfc_code *this_code;
14508 291363 : gfc_component *comp;
14509 291363 : gfc_symbol *s;
14510 :
14511 291363 : if ((*code)->expr1->expr_type != EXPR_FUNCTION)
14512 : return false;
14513 :
14514 : /* Even if standard does not support this feature, continue to build
14515 : the two statements to avoid upsetting frontend_passes.c. */
14516 211 : gfc_notify_std (GFC_STD_F2008, "Pointer procedure assignment at "
14517 : "%L", &(*code)->loc);
14518 :
14519 211 : comp = gfc_get_proc_ptr_comp ((*code)->expr1);
14520 :
14521 211 : if (comp)
14522 6 : s = comp->ts.interface;
14523 : else
14524 205 : s = (*code)->expr1->symtree->n.sym;
14525 :
14526 211 : if (s == NULL || !s->result->attr.pointer)
14527 : {
14528 5 : gfc_error ("The function result on the lhs of the assignment at "
14529 : "%L must have the pointer attribute.",
14530 5 : &(*code)->expr1->where);
14531 5 : (*code)->op = EXEC_NOP;
14532 5 : return false;
14533 : }
14534 :
14535 206 : tmp_ptr_expr = get_temp_from_expr ((*code)->expr1, ns);
14536 :
14537 : /* get_temp_from_expression is set up for ordinary assignments. To that
14538 : end, where array bounds are not known, arrays are made allocatable.
14539 : Change the temporary to a pointer here. */
14540 206 : tmp_ptr_expr->symtree->n.sym->attr.pointer = 1;
14541 206 : tmp_ptr_expr->symtree->n.sym->attr.allocatable = 0;
14542 206 : tmp_ptr_expr->where = (*code)->loc;
14543 :
14544 : /* A new charlen is required to ensure that the variable string length
14545 : is different to that of the original lhs for deferred results. */
14546 206 : if (s->result->ts.deferred && tmp_ptr_expr->ts.type == BT_CHARACTER)
14547 : {
14548 60 : tmp_ptr_expr->ts.u.cl = gfc_get_charlen();
14549 60 : tmp_ptr_expr->ts.deferred = 1;
14550 60 : tmp_ptr_expr->ts.u.cl->next = gfc_current_ns->cl_list;
14551 60 : gfc_current_ns->cl_list = tmp_ptr_expr->ts.u.cl;
14552 60 : tmp_ptr_expr->symtree->n.sym->ts.u.cl = tmp_ptr_expr->ts.u.cl;
14553 : }
14554 :
14555 412 : this_code = build_assignment (EXEC_ASSIGN,
14556 : tmp_ptr_expr, (*code)->expr2,
14557 206 : NULL, NULL, (*code)->loc);
14558 206 : this_code->next = (*code)->next;
14559 206 : (*code)->next = this_code;
14560 206 : (*code)->op = EXEC_POINTER_ASSIGN;
14561 206 : (*code)->expr2 = (*code)->expr1;
14562 206 : (*code)->expr1 = tmp_ptr_expr;
14563 :
14564 206 : return true;
14565 : }
14566 :
14567 :
14568 : /* Deferred character length assignments from an operator expression
14569 : require a temporary because the character length of the lhs can
14570 : change in the course of the assignment. */
14571 :
14572 : static bool
14573 290185 : deferred_op_assign (gfc_code **code, gfc_namespace *ns)
14574 : {
14575 290185 : gfc_expr *tmp_expr;
14576 290185 : gfc_code *this_code;
14577 :
14578 290185 : if (!((*code)->expr1->ts.type == BT_CHARACTER
14579 27962 : && (*code)->expr1->ts.deferred && (*code)->expr1->rank
14580 860 : && (*code)->expr2->ts.type == BT_CHARACTER
14581 859 : && (*code)->expr2->expr_type == EXPR_OP))
14582 : return false;
14583 :
14584 34 : if (!gfc_check_dependency ((*code)->expr1, (*code)->expr2, 1))
14585 : return false;
14586 :
14587 28 : if (gfc_expr_attr ((*code)->expr1).pointer)
14588 : return false;
14589 :
14590 22 : tmp_expr = get_temp_from_expr ((*code)->expr1, ns);
14591 22 : tmp_expr->where = (*code)->loc;
14592 :
14593 : /* A new charlen is required to ensure that the variable string
14594 : length is different to that of the original lhs. */
14595 22 : tmp_expr->ts.u.cl = gfc_get_charlen();
14596 22 : tmp_expr->symtree->n.sym->ts.u.cl = tmp_expr->ts.u.cl;
14597 22 : tmp_expr->ts.u.cl->next = (*code)->expr2->ts.u.cl->next;
14598 22 : (*code)->expr2->ts.u.cl->next = tmp_expr->ts.u.cl;
14599 :
14600 22 : tmp_expr->symtree->n.sym->ts.deferred = 1;
14601 :
14602 22 : this_code = build_assignment (EXEC_ASSIGN,
14603 22 : (*code)->expr1,
14604 : gfc_copy_expr (tmp_expr),
14605 : NULL, NULL, (*code)->loc);
14606 :
14607 22 : (*code)->expr1 = tmp_expr;
14608 :
14609 22 : this_code->next = (*code)->next;
14610 22 : (*code)->next = this_code;
14611 :
14612 22 : return true;
14613 : }
14614 :
14615 : static void mark_lhs_assignments_set (gfc_code *code);
14616 :
14617 : /* Given a block of code, recursively resolve everything pointed to by this
14618 : code block. */
14619 :
14620 : void
14621 712427 : gfc_resolve_code (gfc_code *code, gfc_namespace *ns)
14622 : {
14623 712427 : int omp_workshare_save;
14624 712427 : int forall_save, do_concurrent_save;
14625 712427 : code_stack frame;
14626 712427 : bool t;
14627 712427 : gfc_code *orig_code = code;
14628 :
14629 712427 : frame.prev = cs_base;
14630 712427 : frame.head = code;
14631 712427 : cs_base = &frame;
14632 :
14633 712427 : find_reachable_labels (code);
14634 :
14635 2591604 : for (; code; code = code->next)
14636 : {
14637 1166751 : frame.current = code;
14638 1166751 : forall_save = forall_flag;
14639 1166751 : do_concurrent_save = gfc_do_concurrent_flag;
14640 :
14641 1166751 : if (code->op == EXEC_FORALL || code->op == EXEC_DO_CONCURRENT)
14642 : {
14643 2345 : if (code->op == EXEC_FORALL)
14644 1993 : forall_flag = 1;
14645 352 : else if (code->op == EXEC_DO_CONCURRENT)
14646 352 : gfc_do_concurrent_flag = 1;
14647 2345 : gfc_resolve_forall (code, ns, forall_save);
14648 2345 : if (code->op == EXEC_FORALL)
14649 1993 : forall_flag = 2;
14650 352 : else if (code->op == EXEC_DO_CONCURRENT)
14651 352 : gfc_do_concurrent_flag = 2;
14652 : }
14653 1164406 : else if (code->op == EXEC_OMP_METADIRECTIVE)
14654 146 : for (gfc_omp_variant *variant
14655 : = code->ext.omp_variants;
14656 473 : variant; variant = variant->next)
14657 327 : gfc_resolve_code (variant->code, ns);
14658 1164260 : else if (code->block)
14659 : {
14660 338638 : omp_workshare_save = -1;
14661 338638 : switch (code->op)
14662 : {
14663 10119 : case EXEC_OACC_PARALLEL_LOOP:
14664 10119 : case EXEC_OACC_PARALLEL:
14665 10119 : case EXEC_OACC_KERNELS_LOOP:
14666 10119 : case EXEC_OACC_KERNELS:
14667 10119 : case EXEC_OACC_SERIAL_LOOP:
14668 10119 : case EXEC_OACC_SERIAL:
14669 10119 : case EXEC_OACC_DATA:
14670 10119 : case EXEC_OACC_HOST_DATA:
14671 10119 : case EXEC_OACC_LOOP:
14672 10119 : gfc_resolve_oacc_blocks (code, ns);
14673 10119 : break;
14674 54 : case EXEC_OMP_PARALLEL_WORKSHARE:
14675 54 : omp_workshare_save = omp_workshare_flag;
14676 54 : omp_workshare_flag = 1;
14677 54 : gfc_resolve_omp_parallel_blocks (code, ns);
14678 54 : break;
14679 6123 : case EXEC_OMP_DISTRIBUTE_PARALLEL_DO:
14680 6123 : case EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD:
14681 6123 : case EXEC_OMP_MASKED_TASKLOOP:
14682 6123 : case EXEC_OMP_MASKED_TASKLOOP_SIMD:
14683 6123 : case EXEC_OMP_MASTER_TASKLOOP:
14684 6123 : case EXEC_OMP_MASTER_TASKLOOP_SIMD:
14685 6123 : case EXEC_OMP_PARALLEL:
14686 6123 : case EXEC_OMP_PARALLEL_DO:
14687 6123 : case EXEC_OMP_PARALLEL_DO_SIMD:
14688 6123 : case EXEC_OMP_PARALLEL_LOOP:
14689 6123 : case EXEC_OMP_PARALLEL_MASKED:
14690 6123 : case EXEC_OMP_PARALLEL_MASKED_TASKLOOP:
14691 6123 : case EXEC_OMP_PARALLEL_MASKED_TASKLOOP_SIMD:
14692 6123 : case EXEC_OMP_PARALLEL_MASTER:
14693 6123 : case EXEC_OMP_PARALLEL_MASTER_TASKLOOP:
14694 6123 : case EXEC_OMP_PARALLEL_MASTER_TASKLOOP_SIMD:
14695 6123 : case EXEC_OMP_PARALLEL_SECTIONS:
14696 6123 : case EXEC_OMP_TARGET_PARALLEL:
14697 6123 : case EXEC_OMP_TARGET_PARALLEL_DO:
14698 6123 : case EXEC_OMP_TARGET_PARALLEL_DO_SIMD:
14699 6123 : case EXEC_OMP_TARGET_PARALLEL_LOOP:
14700 6123 : case EXEC_OMP_TARGET_TEAMS:
14701 6123 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE:
14702 6123 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO:
14703 6123 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
14704 6123 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD:
14705 6123 : case EXEC_OMP_TARGET_TEAMS_LOOP:
14706 6123 : case EXEC_OMP_TASK:
14707 6123 : case EXEC_OMP_TASKLOOP:
14708 6123 : case EXEC_OMP_TASKLOOP_SIMD:
14709 6123 : case EXEC_OMP_TEAMS:
14710 6123 : case EXEC_OMP_TEAMS_DISTRIBUTE:
14711 6123 : case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO:
14712 6123 : case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
14713 6123 : case EXEC_OMP_TEAMS_DISTRIBUTE_SIMD:
14714 6123 : case EXEC_OMP_TEAMS_LOOP:
14715 6123 : omp_workshare_save = omp_workshare_flag;
14716 6123 : omp_workshare_flag = 0;
14717 6123 : gfc_resolve_omp_parallel_blocks (code, ns);
14718 6123 : break;
14719 3089 : case EXEC_OMP_DISTRIBUTE:
14720 3089 : case EXEC_OMP_DISTRIBUTE_SIMD:
14721 3089 : case EXEC_OMP_DO:
14722 3089 : case EXEC_OMP_DO_SIMD:
14723 3089 : case EXEC_OMP_LOOP:
14724 3089 : case EXEC_OMP_SIMD:
14725 3089 : case EXEC_OMP_TARGET_SIMD:
14726 3089 : case EXEC_OMP_TILE:
14727 3089 : case EXEC_OMP_UNROLL:
14728 3089 : gfc_resolve_omp_do_blocks (code, ns);
14729 3089 : break;
14730 : case EXEC_SELECT_TYPE:
14731 : case EXEC_SELECT_RANK:
14732 : /* Blocks are handled in resolve_select_type/rank because we
14733 : have to transform the SELECT TYPE into ASSOCIATE first. */
14734 : break;
14735 : case EXEC_DO_CONCURRENT:
14736 : gfc_do_concurrent_flag = 1;
14737 : gfc_resolve_blocks (code->block, ns);
14738 : gfc_do_concurrent_flag = 2;
14739 : break;
14740 39 : case EXEC_OMP_WORKSHARE:
14741 39 : omp_workshare_save = omp_workshare_flag;
14742 39 : omp_workshare_flag = 1;
14743 : /* FALL THROUGH */
14744 314976 : default:
14745 314976 : gfc_resolve_blocks (code->block, ns);
14746 314976 : break;
14747 : }
14748 :
14749 334361 : if (omp_workshare_save != -1)
14750 6216 : omp_workshare_flag = omp_workshare_save;
14751 : }
14752 1166751 : start:
14753 1166962 : t = true;
14754 1166962 : if (code->op != EXEC_COMPCALL && code->op != EXEC_CALL_PPC)
14755 1165513 : t = gfc_resolve_expr (code->expr1);
14756 :
14757 1166962 : forall_flag = forall_save;
14758 1166962 : gfc_do_concurrent_flag = do_concurrent_save;
14759 :
14760 1166962 : if (!gfc_resolve_expr (code->expr2))
14761 647 : t = false;
14762 :
14763 1166962 : if (code->op == EXEC_ALLOCATE
14764 1166962 : && !gfc_resolve_expr (code->expr3))
14765 : t = false;
14766 :
14767 1166962 : switch (code->op)
14768 : {
14769 : case EXEC_NOP:
14770 : case EXEC_END_BLOCK:
14771 : case EXEC_END_NESTED_BLOCK:
14772 : case EXEC_CYCLE:
14773 : break;
14774 :
14775 223766 : case EXEC_STOP:
14776 223766 : case EXEC_ERROR_STOP:
14777 223766 : if (code->expr1 != NULL && t)
14778 : {
14779 203244 : if (!(code->expr1->ts.type == BT_CHARACTER
14780 : || code->expr1->ts.type == BT_INTEGER))
14781 1 : gfc_error ("STOP code at %L must be either INTEGER or CHARACTER "
14782 : "type", &code->expr1->where);
14783 203243 : else if (code->expr1->rank != 0)
14784 0 : gfc_error ("STOP code at %L must be scalar",
14785 : &code->expr1->where);
14786 203243 : else if (code->expr1->ts.type == BT_CHARACTER
14787 498 : && code->expr1->ts.kind != gfc_default_character_kind)
14788 0 : gfc_error ("STOP code at %L must be default character KIND=%d",
14789 : &code->expr1->where, (int) gfc_default_character_kind);
14790 203243 : else if (code->expr1->ts.type == BT_INTEGER
14791 202745 : && code->expr1->ts.kind != gfc_default_integer_kind)
14792 8 : gfc_notify_std (GFC_STD_F2018, "STOP code at %L must be default "
14793 : "integer KIND=%d", &code->expr1->where,
14794 : (int) gfc_default_integer_kind);
14795 : }
14796 223766 : if (code->expr2 != NULL
14797 37 : && (code->expr2->ts.type != BT_LOGICAL
14798 37 : || code->expr2->rank != 0))
14799 0 : gfc_error ("QUIET specifier at %L must be a scalar LOGICAL",
14800 : &code->expr2->where);
14801 :
14802 : /* Fall through. */
14803 223796 : case EXEC_PAUSE:
14804 223796 : gfc_value_used_expr (code->expr1, VALUE_USED);
14805 223796 : break;
14806 :
14807 : case EXEC_EXIT:
14808 : case EXEC_CONTINUE:
14809 : case EXEC_DT_END:
14810 : case EXEC_ASSIGN_CALL:
14811 : break;
14812 :
14813 54 : case EXEC_CRITICAL:
14814 54 : resolve_critical (code);
14815 54 : break;
14816 :
14817 1450 : case EXEC_SYNC_ALL:
14818 1450 : case EXEC_SYNC_IMAGES:
14819 1450 : case EXEC_SYNC_MEMORY:
14820 1450 : resolve_sync (code);
14821 1450 : break;
14822 :
14823 197 : case EXEC_LOCK:
14824 197 : case EXEC_UNLOCK:
14825 197 : case EXEC_EVENT_POST:
14826 197 : case EXEC_EVENT_WAIT:
14827 197 : resolve_lock_unlock_event (code);
14828 197 : break;
14829 :
14830 : case EXEC_FAIL_IMAGE:
14831 : break;
14832 :
14833 184 : case EXEC_FORM_TEAM:
14834 184 : resolve_form_team (code);
14835 184 : break;
14836 :
14837 131 : case EXEC_CHANGE_TEAM:
14838 131 : resolve_change_team (code);
14839 131 : break;
14840 :
14841 129 : case EXEC_END_TEAM:
14842 129 : resolve_end_team (code);
14843 129 : break;
14844 :
14845 48 : case EXEC_SYNC_TEAM:
14846 48 : resolve_sync_team (code);
14847 48 : break;
14848 :
14849 1491 : case EXEC_ENTRY:
14850 : /* Keep track of which entry we are up to. */
14851 1491 : current_entry_id = code->ext.entry->id;
14852 1491 : break;
14853 :
14854 459 : case EXEC_WHERE:
14855 459 : resolve_where (code, NULL);
14856 459 : break;
14857 :
14858 1304 : case EXEC_GOTO:
14859 1304 : if (code->expr1 != NULL)
14860 : {
14861 78 : if (code->expr1->expr_type != EXPR_VARIABLE
14862 76 : || code->expr1->ts.type != BT_INTEGER
14863 76 : || (code->expr1->ref
14864 1 : && code->expr1->ref->type == REF_ARRAY)
14865 75 : || code->expr1->symtree == NULL
14866 75 : || (code->expr1->symtree->n.sym
14867 75 : && (code->expr1->symtree->n.sym->attr.flavor
14868 75 : == FL_PARAMETER)))
14869 4 : gfc_error ("ASSIGNED GOTO statement at %L requires a "
14870 : "scalar INTEGER variable", &code->expr1->where);
14871 74 : else if (code->expr1->symtree->n.sym
14872 74 : && code->expr1->symtree->n.sym->attr.assign != 1)
14873 1 : gfc_error ("Variable %qs has not been assigned a target "
14874 : "label at %L", code->expr1->symtree->n.sym->name,
14875 : &code->expr1->where);
14876 : }
14877 : else
14878 1226 : resolve_branch (code->label1, code);
14879 : break;
14880 :
14881 3275 : case EXEC_RETURN:
14882 3275 : if (code->expr1 != NULL
14883 53 : && (code->expr1->ts.type != BT_INTEGER || code->expr1->rank))
14884 1 : gfc_error ("Alternate RETURN statement at %L requires a SCALAR-"
14885 : "INTEGER return specifier", &code->expr1->where);
14886 : break;
14887 :
14888 : case EXEC_INIT_ASSIGN:
14889 : case EXEC_END_PROCEDURE:
14890 : break;
14891 :
14892 292548 : case EXEC_ASSIGN:
14893 292548 : if (!t)
14894 : break;
14895 :
14896 291863 : if (flag_coarray == GFC_FCOARRAY_LIB
14897 291863 : && gfc_is_coindexed (code->expr1))
14898 : {
14899 : /* Insert a GFC_ISYM_CAF_SEND intrinsic, when the LHS is a
14900 : coindexed variable. */
14901 500 : code->op = EXEC_CALL;
14902 500 : gfc_get_sym_tree (GFC_PREFIX ("caf_send"), ns, &code->symtree,
14903 : true);
14904 500 : code->resolved_sym = code->symtree->n.sym;
14905 500 : code->resolved_sym->attr.flavor = FL_PROCEDURE;
14906 500 : code->resolved_sym->attr.intrinsic = 1;
14907 500 : code->resolved_sym->attr.subroutine = 1;
14908 500 : code->resolved_isym
14909 500 : = gfc_intrinsic_subroutine_by_id (GFC_ISYM_CAF_SEND);
14910 500 : gfc_commit_symbol (code->resolved_sym);
14911 500 : code->ext.actual = gfc_get_actual_arglist ();
14912 500 : code->ext.actual->expr = code->expr1;
14913 500 : code->ext.actual->next = gfc_get_actual_arglist ();
14914 500 : if (code->expr2->expr_type != EXPR_VARIABLE
14915 500 : && code->expr2->expr_type != EXPR_CONSTANT)
14916 : {
14917 : /* Convert assignments of expr1[...] = expr2 into
14918 : tvar = expr2
14919 : expr1[...] = tvar
14920 : when expr2 is not trivial. */
14921 54 : gfc_expr *tvar = get_temp_from_expr (code->expr2, ns);
14922 54 : gfc_code next_code = *code;
14923 54 : gfc_code *rhs_code
14924 108 : = build_assignment (EXEC_ASSIGN, tvar, code->expr2, NULL,
14925 54 : NULL, code->expr2->where);
14926 54 : *code = *rhs_code;
14927 54 : code->next = rhs_code;
14928 54 : *rhs_code = next_code;
14929 :
14930 54 : rhs_code->ext.actual->next->expr = tvar;
14931 54 : rhs_code->expr1 = NULL;
14932 54 : rhs_code->expr2 = NULL;
14933 : }
14934 : else
14935 : {
14936 446 : code->ext.actual->next->expr = code->expr2;
14937 :
14938 446 : code->expr1 = NULL;
14939 446 : code->expr2 = NULL;
14940 : }
14941 : break;
14942 : }
14943 :
14944 291363 : if (code->expr1->ts.type == BT_CLASS)
14945 1169 : gfc_find_vtab (&code->expr2->ts);
14946 :
14947 : /* If this is a pointer function in an lvalue variable context,
14948 : the new code will have to be resolved afresh. This is also the
14949 : case with an error, where the code is transformed into NOP to
14950 : prevent ICEs downstream. */
14951 291363 : if (resolve_ptr_fcn_assign (&code, ns)
14952 291363 : || code->op == EXEC_NOP)
14953 211 : goto start;
14954 :
14955 291152 : if (!gfc_check_vardef_context (code->expr1, false, false, false,
14956 291152 : _("assignment")))
14957 : break;
14958 :
14959 291109 : if (resolve_ordinary_assign (code, ns))
14960 : {
14961 924 : if (omp_workshare_flag)
14962 : {
14963 1 : gfc_error ("Expected intrinsic assignment in OMP WORKSHARE "
14964 1 : "at %L", &code->loc);
14965 1 : break;
14966 : }
14967 923 : if (code->op == EXEC_COMPCALL)
14968 455 : goto compcall;
14969 : else
14970 468 : goto call;
14971 : }
14972 :
14973 : /* Check for dependencies in deferred character length array
14974 : assignments and generate a temporary, if necessary. */
14975 290185 : if (code->op == EXEC_ASSIGN && deferred_op_assign (&code, ns))
14976 : break;
14977 :
14978 : /* F03 7.4.1.3 for non-allocatable, non-pointer components. */
14979 290163 : if (code->op != EXEC_CALL && code->expr1->ts.type == BT_DERIVED
14980 7698 : && code->expr1->ts.u.derived
14981 7698 : && code->expr1->ts.u.derived->attr.defined_assign_comp)
14982 194 : generate_component_assignments (&code, ns);
14983 289969 : else if (code->op == EXEC_ASSIGN)
14984 : {
14985 289969 : if (gfc_may_be_finalized (code->expr1->ts))
14986 1368 : code->expr1->must_finalize = 1;
14987 289969 : if (code->expr2->expr_type == EXPR_ARRAY
14988 289969 : && gfc_may_be_finalized (code->expr2->ts))
14989 79 : code->expr2->must_finalize = 1;
14990 : }
14991 :
14992 : break;
14993 :
14994 126 : case EXEC_LABEL_ASSIGN:
14995 126 : if (code->label1->defined == ST_LABEL_UNKNOWN)
14996 0 : gfc_error ("Label %d referenced at %L is never defined",
14997 : code->label1->value, &code->label1->where);
14998 126 : if (t
14999 126 : && (code->expr1->expr_type != EXPR_VARIABLE
15000 126 : || code->expr1->symtree->n.sym->ts.type != BT_INTEGER
15001 126 : || code->expr1->symtree->n.sym->ts.kind
15002 126 : != gfc_default_integer_kind
15003 126 : || code->expr1->symtree->n.sym->attr.flavor == FL_PARAMETER
15004 125 : || code->expr1->symtree->n.sym->as != NULL))
15005 2 : gfc_error ("ASSIGN statement at %L requires a scalar "
15006 : "default INTEGER variable", &code->expr1->where);
15007 : break;
15008 :
15009 10778 : case EXEC_POINTER_ASSIGN:
15010 10778 : {
15011 10778 : gfc_expr* e;
15012 :
15013 10778 : if (!t)
15014 : break;
15015 :
15016 : /* This is both a variable definition and pointer assignment
15017 : context, so check both of them. For rank remapping, a final
15018 : array ref may be present on the LHS and fool gfc_expr_attr
15019 : used in gfc_check_vardef_context. Remove it. */
15020 10773 : e = remove_last_array_ref (code->expr1);
15021 21546 : t = gfc_check_vardef_context (e, true, false, false,
15022 10773 : _("pointer assignment"));
15023 10773 : if (t)
15024 10744 : t = gfc_check_vardef_context (e, false, false, false,
15025 10744 : _("pointer assignment"));
15026 10773 : gfc_free_expr (e);
15027 :
15028 10773 : t = gfc_check_pointer_assign (code->expr1, code->expr2, !t) && t;
15029 :
15030 10628 : if (!t)
15031 : break;
15032 :
15033 : /* Assigning a class object always is a regular assign. */
15034 10628 : if (code->expr2->ts.type == BT_CLASS
15035 617 : && code->expr1->ts.type == BT_CLASS
15036 520 : && CLASS_DATA (code->expr2)
15037 519 : && !CLASS_DATA (code->expr2)->attr.dimension
15038 11300 : && !(gfc_expr_attr (code->expr1).proc_pointer
15039 55 : && code->expr2->expr_type == EXPR_VARIABLE
15040 43 : && code->expr2->symtree->n.sym->attr.flavor
15041 43 : == FL_PROCEDURE))
15042 340 : code->op = EXEC_ASSIGN;
15043 : break;
15044 : }
15045 :
15046 72 : case EXEC_ARITHMETIC_IF:
15047 72 : {
15048 72 : gfc_expr *e = code->expr1;
15049 :
15050 72 : gfc_resolve_expr (e);
15051 72 : if (e->expr_type == EXPR_NULL)
15052 1 : gfc_error ("Invalid NULL at %L", &e->where);
15053 :
15054 72 : if (t && (e->rank > 0
15055 68 : || !(e->ts.type == BT_REAL || e->ts.type == BT_INTEGER)))
15056 5 : gfc_error ("Arithmetic IF statement at %L requires a scalar "
15057 : "REAL or INTEGER expression", &e->where);
15058 :
15059 72 : resolve_branch (code->label1, code);
15060 72 : resolve_branch (code->label2, code);
15061 72 : resolve_branch (code->label3, code);
15062 : }
15063 72 : break;
15064 :
15065 237624 : case EXEC_IF:
15066 237624 : if (t && code->expr1 != NULL
15067 0 : && (code->expr1->ts.type != BT_LOGICAL
15068 0 : || code->expr1->rank != 0))
15069 0 : gfc_error ("IF clause at %L requires a scalar LOGICAL expression",
15070 : &code->expr1->where);
15071 : break;
15072 :
15073 81982 : case EXEC_CALL:
15074 81982 : call:
15075 81982 : resolve_call (code);
15076 81982 : break;
15077 :
15078 1780 : case EXEC_COMPCALL:
15079 1780 : compcall:
15080 1780 : resolve_typebound_subroutine (code);
15081 1780 : break;
15082 :
15083 124 : case EXEC_CALL_PPC:
15084 124 : resolve_ppc_call (code);
15085 124 : break;
15086 :
15087 707 : case EXEC_SELECT:
15088 : /* Select is complicated. Also, a SELECT construct could be
15089 : a transformed computed GOTO. */
15090 707 : resolve_select (code, false);
15091 707 : break;
15092 :
15093 3255 : case EXEC_SELECT_TYPE:
15094 3255 : resolve_select_type (code, ns);
15095 3255 : break;
15096 :
15097 1048 : case EXEC_SELECT_RANK:
15098 1048 : resolve_select_rank (code, ns);
15099 1048 : break;
15100 :
15101 8721 : case EXEC_BLOCK:
15102 8721 : resolve_block_construct (code);
15103 8721 : break;
15104 :
15105 33549 : case EXEC_DO:
15106 33549 : if (code->ext.iterator != NULL)
15107 : {
15108 33549 : gfc_iterator *iter = code->ext.iterator;
15109 33549 : if (gfc_resolve_iterator (iter, true, false))
15110 33535 : gfc_resolve_do_iterator (code, iter->var->symtree->n.sym,
15111 : true);
15112 : }
15113 : break;
15114 :
15115 561 : case EXEC_DO_WHILE:
15116 561 : if (code->expr1 == NULL)
15117 0 : gfc_internal_error ("gfc_resolve_code(): No expression on "
15118 : "DO WHILE");
15119 561 : if (t
15120 561 : && (code->expr1->rank != 0
15121 561 : || code->expr1->ts.type != BT_LOGICAL))
15122 0 : gfc_error ("Exit condition of DO WHILE loop at %L must be "
15123 : "a scalar LOGICAL expression", &code->expr1->where);
15124 : break;
15125 :
15126 15083 : case EXEC_ALLOCATE:
15127 15083 : if (t)
15128 15081 : resolve_allocate_deallocate (code, "ALLOCATE");
15129 :
15130 : break;
15131 :
15132 6378 : case EXEC_DEALLOCATE:
15133 6378 : if (t)
15134 6378 : resolve_allocate_deallocate (code, "DEALLOCATE");
15135 :
15136 : break;
15137 :
15138 3991 : case EXEC_OPEN:
15139 3991 : if (!gfc_resolve_open (code->ext.open, &code->loc))
15140 : break;
15141 :
15142 3764 : resolve_branch (code->ext.open->err, code);
15143 3764 : break;
15144 :
15145 3184 : case EXEC_CLOSE:
15146 3184 : if (!gfc_resolve_close (code->ext.close, &code->loc))
15147 : break;
15148 :
15149 3150 : resolve_branch (code->ext.close->err, code);
15150 3150 : break;
15151 :
15152 2887 : case EXEC_BACKSPACE:
15153 2887 : case EXEC_ENDFILE:
15154 2887 : case EXEC_REWIND:
15155 2887 : case EXEC_FLUSH:
15156 2887 : if (!gfc_resolve_filepos (code->ext.filepos, &code->loc))
15157 : break;
15158 :
15159 2821 : resolve_branch (code->ext.filepos->err, code);
15160 2821 : break;
15161 :
15162 844 : case EXEC_INQUIRE:
15163 844 : if (!gfc_resolve_inquire (code->ext.inquire))
15164 : break;
15165 :
15166 796 : resolve_branch (code->ext.inquire->err, code);
15167 796 : break;
15168 :
15169 92 : case EXEC_IOLENGTH:
15170 92 : gcc_assert (code->ext.inquire != NULL);
15171 92 : if (!gfc_resolve_inquire (code->ext.inquire))
15172 : break;
15173 :
15174 90 : resolve_branch (code->ext.inquire->err, code);
15175 90 : break;
15176 :
15177 89 : case EXEC_WAIT:
15178 89 : if (!gfc_resolve_wait (code->ext.wait))
15179 : break;
15180 :
15181 74 : resolve_branch (code->ext.wait->err, code);
15182 74 : resolve_branch (code->ext.wait->end, code);
15183 74 : resolve_branch (code->ext.wait->eor, code);
15184 74 : break;
15185 :
15186 33854 : case EXEC_READ:
15187 33854 : case EXEC_WRITE:
15188 33854 : if (!gfc_resolve_dt (code, code->ext.dt, &code->loc))
15189 : break;
15190 :
15191 33546 : resolve_branch (code->ext.dt->err, code);
15192 33546 : resolve_branch (code->ext.dt->end, code);
15193 33546 : resolve_branch (code->ext.dt->eor, code);
15194 33546 : break;
15195 :
15196 48047 : case EXEC_TRANSFER:
15197 48047 : resolve_transfer (code);
15198 48047 : break;
15199 :
15200 2345 : case EXEC_DO_CONCURRENT:
15201 2345 : case EXEC_FORALL:
15202 2345 : resolve_forall_iterators (code->ext.concur.forall_iterator);
15203 :
15204 2345 : if (code->expr1 != NULL
15205 732 : && (code->expr1->ts.type != BT_LOGICAL || code->expr1->rank))
15206 2 : gfc_error ("FORALL mask clause at %L requires a scalar LOGICAL "
15207 : "expression", &code->expr1->where);
15208 :
15209 2345 : if (code->op == EXEC_DO_CONCURRENT)
15210 352 : resolve_locality_spec (code, ns);
15211 : break;
15212 :
15213 13538 : case EXEC_OACC_PARALLEL_LOOP:
15214 13538 : case EXEC_OACC_PARALLEL:
15215 13538 : case EXEC_OACC_KERNELS_LOOP:
15216 13538 : case EXEC_OACC_KERNELS:
15217 13538 : case EXEC_OACC_SERIAL_LOOP:
15218 13538 : case EXEC_OACC_SERIAL:
15219 13538 : case EXEC_OACC_DATA:
15220 13538 : case EXEC_OACC_HOST_DATA:
15221 13538 : case EXEC_OACC_LOOP:
15222 13538 : case EXEC_OACC_UPDATE:
15223 13538 : case EXEC_OACC_WAIT:
15224 13538 : case EXEC_OACC_CACHE:
15225 13538 : case EXEC_OACC_ENTER_DATA:
15226 13538 : case EXEC_OACC_EXIT_DATA:
15227 13538 : case EXEC_OACC_ATOMIC:
15228 13538 : case EXEC_OACC_DECLARE:
15229 13538 : case EXEC_OACC_INIT:
15230 13538 : case EXEC_OACC_SHUTDOWN:
15231 13538 : case EXEC_OACC_SET:
15232 13538 : gfc_resolve_oacc_directive (code, ns);
15233 13538 : break;
15234 :
15235 17506 : case EXEC_OMP_ALLOCATE:
15236 17506 : case EXEC_OMP_ALLOCATORS:
15237 17506 : case EXEC_OMP_ASSUME:
15238 17506 : case EXEC_OMP_ATOMIC:
15239 17506 : case EXEC_OMP_BARRIER:
15240 17506 : case EXEC_OMP_CANCEL:
15241 17506 : case EXEC_OMP_CANCELLATION_POINT:
15242 17506 : case EXEC_OMP_CRITICAL:
15243 17506 : case EXEC_OMP_FLUSH:
15244 17506 : case EXEC_OMP_DEPOBJ:
15245 17506 : case EXEC_OMP_DISPATCH:
15246 17506 : case EXEC_OMP_DISTRIBUTE:
15247 17506 : case EXEC_OMP_DISTRIBUTE_PARALLEL_DO:
15248 17506 : case EXEC_OMP_DISTRIBUTE_PARALLEL_DO_SIMD:
15249 17506 : case EXEC_OMP_DISTRIBUTE_SIMD:
15250 17506 : case EXEC_OMP_DO:
15251 17506 : case EXEC_OMP_DO_SIMD:
15252 17506 : case EXEC_OMP_ERROR:
15253 17506 : case EXEC_OMP_INTEROP:
15254 17506 : case EXEC_OMP_LOOP:
15255 17506 : case EXEC_OMP_MASTER:
15256 17506 : case EXEC_OMP_MASTER_TASKLOOP:
15257 17506 : case EXEC_OMP_MASTER_TASKLOOP_SIMD:
15258 17506 : case EXEC_OMP_MASKED:
15259 17506 : case EXEC_OMP_MASKED_TASKLOOP:
15260 17506 : case EXEC_OMP_MASKED_TASKLOOP_SIMD:
15261 17506 : case EXEC_OMP_METADIRECTIVE:
15262 17506 : case EXEC_OMP_ORDERED:
15263 17506 : case EXEC_OMP_SCAN:
15264 17506 : case EXEC_OMP_SCOPE:
15265 17506 : case EXEC_OMP_SECTIONS:
15266 17506 : case EXEC_OMP_SIMD:
15267 17506 : case EXEC_OMP_SINGLE:
15268 17506 : case EXEC_OMP_TARGET:
15269 17506 : case EXEC_OMP_TARGET_DATA:
15270 17506 : case EXEC_OMP_TARGET_ENTER_DATA:
15271 17506 : case EXEC_OMP_TARGET_EXIT_DATA:
15272 17506 : case EXEC_OMP_TARGET_PARALLEL:
15273 17506 : case EXEC_OMP_TARGET_PARALLEL_DO:
15274 17506 : case EXEC_OMP_TARGET_PARALLEL_DO_SIMD:
15275 17506 : case EXEC_OMP_TARGET_PARALLEL_LOOP:
15276 17506 : case EXEC_OMP_TARGET_SIMD:
15277 17506 : case EXEC_OMP_TARGET_TEAMS:
15278 17506 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE:
15279 17506 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO:
15280 17506 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
15281 17506 : case EXEC_OMP_TARGET_TEAMS_DISTRIBUTE_SIMD:
15282 17506 : case EXEC_OMP_TARGET_TEAMS_LOOP:
15283 17506 : case EXEC_OMP_TARGET_UPDATE:
15284 17506 : case EXEC_OMP_TASK:
15285 17506 : case EXEC_OMP_TASKGROUP:
15286 17506 : case EXEC_OMP_TASKLOOP:
15287 17506 : case EXEC_OMP_TASKLOOP_SIMD:
15288 17506 : case EXEC_OMP_TASKWAIT:
15289 17506 : case EXEC_OMP_TASKYIELD:
15290 17506 : case EXEC_OMP_TEAMS:
15291 17506 : case EXEC_OMP_TEAMS_DISTRIBUTE:
15292 17506 : case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO:
15293 17506 : case EXEC_OMP_TEAMS_DISTRIBUTE_PARALLEL_DO_SIMD:
15294 17506 : case EXEC_OMP_TEAMS_DISTRIBUTE_SIMD:
15295 17506 : case EXEC_OMP_TEAMS_LOOP:
15296 17506 : case EXEC_OMP_TILE:
15297 17506 : case EXEC_OMP_UNROLL:
15298 17506 : case EXEC_OMP_WORKSHARE:
15299 17506 : gfc_resolve_omp_directive (code, ns);
15300 17506 : break;
15301 :
15302 3945 : case EXEC_OMP_PARALLEL:
15303 3945 : case EXEC_OMP_PARALLEL_DO:
15304 3945 : case EXEC_OMP_PARALLEL_DO_SIMD:
15305 3945 : case EXEC_OMP_PARALLEL_LOOP:
15306 3945 : case EXEC_OMP_PARALLEL_MASKED:
15307 3945 : case EXEC_OMP_PARALLEL_MASKED_TASKLOOP:
15308 3945 : case EXEC_OMP_PARALLEL_MASKED_TASKLOOP_SIMD:
15309 3945 : case EXEC_OMP_PARALLEL_MASTER:
15310 3945 : case EXEC_OMP_PARALLEL_MASTER_TASKLOOP:
15311 3945 : case EXEC_OMP_PARALLEL_MASTER_TASKLOOP_SIMD:
15312 3945 : case EXEC_OMP_PARALLEL_SECTIONS:
15313 3945 : case EXEC_OMP_PARALLEL_WORKSHARE:
15314 3945 : omp_workshare_save = omp_workshare_flag;
15315 3945 : omp_workshare_flag = 0;
15316 3945 : gfc_resolve_omp_directive (code, ns);
15317 3945 : omp_workshare_flag = omp_workshare_save;
15318 3945 : break;
15319 :
15320 0 : default:
15321 0 : gfc_internal_error ("gfc_resolve_code(): Bad statement code");
15322 : }
15323 1166750 : gfc_value_used_expr (code->expr2, VALUE_USED);
15324 1166750 : gfc_value_used_expr (code->expr3, VALUE_USED);
15325 1166750 : gfc_value_used_expr (code->expr4, VALUE_USED);
15326 : }
15327 :
15328 712426 : mark_lhs_assignments_set (orig_code);
15329 :
15330 712426 : cs_base = frame.prev;
15331 712426 : }
15332 :
15333 :
15334 : /* Resolve initial values and make sure they are compatible with
15335 : the variable. */
15336 :
15337 : static void
15338 1991512 : resolve_values (gfc_symbol *sym)
15339 : {
15340 1991512 : bool t;
15341 :
15342 1991512 : if (sym->value == NULL)
15343 : return;
15344 :
15345 455575 : if (sym->attr.ext_attr & (1 << EXT_ATTR_DEPRECATED) && sym->attr.referenced)
15346 14 : gfc_warning (OPT_Wdeprecated_declarations,
15347 : "Using parameter %qs declared at %L is deprecated",
15348 : sym->name, &sym->declared_at);
15349 :
15350 455575 : if (sym->value->expr_type == EXPR_STRUCTURE)
15351 42491 : t= resolve_structure_cons (sym->value, 1);
15352 : else
15353 413084 : t = gfc_resolve_expr (sym->value);
15354 :
15355 455575 : if (!t)
15356 : return;
15357 :
15358 455573 : gfc_check_assign_symbol (sym, NULL, sym->value);
15359 : }
15360 :
15361 :
15362 : /* Verify any BIND(C) derived types in the namespace so we can report errors
15363 : for them once, rather than for each variable declared of that type. */
15364 :
15365 : static void
15366 1959446 : resolve_bind_c_derived_types (gfc_symbol *derived_sym)
15367 : {
15368 1959446 : if (derived_sym != NULL && derived_sym->attr.flavor == FL_DERIVED
15369 89249 : && derived_sym->attr.is_bind_c == 1)
15370 28071 : verify_bind_c_derived_type (derived_sym);
15371 :
15372 1959446 : return;
15373 : }
15374 :
15375 :
15376 : /* Check the interfaces of DTIO procedures associated with derived
15377 : type 'sym'. These procedures can either have typebound bindings or
15378 : can appear in DTIO generic interfaces. */
15379 :
15380 : static void
15381 1992483 : gfc_verify_DTIO_procedures (gfc_symbol *sym)
15382 : {
15383 1992483 : if (!sym || sym->attr.flavor != FL_DERIVED)
15384 : return;
15385 :
15386 99409 : gfc_check_dtio_interfaces (sym);
15387 :
15388 99409 : return;
15389 : }
15390 :
15391 : /* Auxiliary function, checks if an argument decays to a pointer. */
15392 :
15393 : static bool
15394 72752 : decays_to_pointer (gfc_symbol *sym)
15395 : {
15396 72752 : if (!sym->as)
15397 : return true;
15398 :
15399 19633 : if (sym->as->type == AS_ASSUMED_SHAPE)
15400 : return false;
15401 :
15402 15876 : if (sym->as->type == AS_ASSUMED_RANK)
15403 : return false;
15404 :
15405 10778 : if (sym->as->type == AS_DEFERRED && sym->attr.dummy)
15406 968 : return false;
15407 :
15408 : return true;
15409 : }
15410 :
15411 : /* Helper function, returns true if the types conform according to the C
15412 : standard, when they are not equal on the Fortran side. If we decide to
15413 : include or exclude any types from this, this is the place to change. */
15414 :
15415 : static bool
15416 390 : c_types_conform (gfc_typespec *ts1, gfc_typespec *ts2)
15417 : {
15418 390 : if (ts1->type == BT_ASSUMED || ts2->type == BT_ASSUMED)
15419 : return true;
15420 :
15421 384 : if (ts1->kind == ts2->kind
15422 : && (ts1->type == BT_CHARACTER || ts1->type == BT_INTEGER
15423 : || ts1->type == BT_UNSIGNED)
15424 : && (ts2->type == BT_CHARACTER || ts2->type == BT_INTEGER
15425 : || ts2->type == BT_UNSIGNED))
15426 384 : return true;
15427 :
15428 : return false;
15429 :
15430 : }
15431 :
15432 : /* Check argument lists of BIND(C) procedures against each other, return
15433 : false if they do not. */
15434 :
15435 : static bool
15436 13618 : compare_c_binding_arglists (gfc_symbol *osym, gfc_symbol *nsym)
15437 : {
15438 13618 : gfc_formal_arglist *oarg, *narg;
15439 13618 : bool ret = true;
15440 13618 : locus *oloc, *nloc;
15441 :
15442 13618 : oarg = osym->formal;
15443 13618 : narg = nsym->formal;
15444 13618 : oloc = &osym->declared_at;
15445 13618 : nloc = &nsym->declared_at;
15446 50004 : for ( ; oarg && narg ; oarg = oarg->next, narg = narg->next)
15447 : {
15448 36386 : oloc = &oarg->sym->declared_at;
15449 36386 : nloc = &narg->sym->declared_at;
15450 :
15451 36386 : if (!gfc_compare_types (&oarg->sym->ts, &narg->sym->ts)
15452 36386 : && (pedantic || !c_types_conform (&oarg->sym->ts, &narg->sym->ts)))
15453 : {
15454 24 : gfc_error ("Type mismatch in argument %qs at %L (%s/%s) "
15455 8 : "originally declared at %L", narg->sym->name,
15456 8 : nloc, gfc_typename (&narg->sym->ts),
15457 8 : gfc_typename (&oarg->sym->ts), oloc);
15458 8 : ret = false;
15459 8 : continue;
15460 : }
15461 36378 : if (oarg->sym->attr.value != narg->sym->attr.value)
15462 : {
15463 1 : gfc_error ("VALUE attribute mismatch in argument %qs at %L "
15464 : "originally declared at %L",narg->sym->name,
15465 : nloc, oloc);
15466 1 : ret = false;
15467 1 : continue;
15468 : }
15469 :
15470 : /* According to the Fortran standard, ranks have to match for arguments.
15471 : In this case, this makes little sense because both decay to C
15472 : pointers. Only issue an error if -pedantic or if the argument does
15473 : not decay to a pointer. Same thing for CFI_desc arrays, which include
15474 : assumed rank. */
15475 :
15476 36377 : int orank = gfc_symbol_rank (oarg->sym);
15477 36377 : int nrank = gfc_symbol_rank (narg->sym);
15478 36377 : if (orank != nrank && pedantic)
15479 : {
15480 1 : gfc_error ("Rank mismatch in argument %qs (%d/%d) at %L originally "
15481 1 : "declared at %L", narg->sym->name, nrank, orank, nloc,
15482 : oloc);
15483 1 : ret = false;
15484 1 : continue;
15485 : }
15486 :
15487 : /* Confusion between CFI_desc and "normal" arrays. */
15488 :
15489 36376 : if (decays_to_pointer (oarg->sym) != decays_to_pointer (narg->sym))
15490 : {
15491 1 : gfc_error ("Array specification mismatch in argument %qs at %L "
15492 : "originally declared at %L", narg->sym->name,
15493 : nloc, oloc);
15494 1 : ret = false;
15495 1 : continue;
15496 : }
15497 : }
15498 :
15499 13618 : if (oarg && !narg)
15500 : {
15501 0 : gfc_error ("Not enough arguments for procedure %qs with binding label "
15502 : "%qs after %L, originally declared at %L", nsym->name,
15503 0 : nsym->binding_label, nloc, &oarg->sym->declared_at);
15504 0 : ret = false;
15505 : }
15506 :
15507 13618 : if (!oarg && narg)
15508 : {
15509 2 : gfc_error ("Too many arguments for procedure %qs with binding label "
15510 : "%qs at %L, originally declared at %L", nsym->name,
15511 2 : nsym->binding_label, &narg->sym->declared_at, oloc);
15512 2 : ret = false;
15513 : }
15514 :
15515 13618 : return ret;
15516 : }
15517 :
15518 :
15519 : /* Verify that any binding labels used in a given namespace do not collide
15520 : with the names or binding labels of any global symbols. Multiple INTERFACE
15521 : for the same procedure are permitted. Abstract interfaces and dummy
15522 : arguments are not checked. */
15523 :
15524 : static void
15525 1992483 : gfc_verify_binding_labels (gfc_symbol *sym)
15526 : {
15527 1992483 : gfc_gsymbol *gsym;
15528 1992483 : const char *module;
15529 :
15530 1992483 : if (!sym || !sym->attr.is_bind_c || sym->attr.is_iso_c
15531 74538 : || sym->attr.flavor == FL_DERIVED || !sym->binding_label
15532 45526 : || sym->attr.abstract || sym->attr.dummy)
15533 : return;
15534 :
15535 : /* Avoid double error reporting. */
15536 45390 : if (sym->error)
15537 : return;
15538 :
15539 : /* TODO: Check the names of reserved external C identifiers here, see
15540 : PR 125251. */
15541 :
15542 : /* According to the Fortran standard, global identifiers are case
15543 : insensitive, which also holds for C identifiers. This was probably done
15544 : for systems which had case-insensitive linkers. Such systems could not
15545 : accommodate the C standards referenced, so this restriction makes little
15546 : sense for modern systems. Therefore, check case-sensitive labels unless
15547 : -pedantic is in force. */
15548 :
15549 45390 : if (pedantic)
15550 4681 : gsym = gfc_find_case_gsymbol (gfc_gsym_root, sym->binding_label);
15551 : else
15552 40709 : gsym = gfc_find_gsymbol (gfc_gsym_root, sym->binding_label);
15553 :
15554 45390 : if (sym->module)
15555 : module = sym->module;
15556 13601 : else if (sym->ns && sym->ns->proc_name
15557 13601 : && sym->ns->proc_name->attr.flavor == FL_MODULE)
15558 4619 : module = sym->ns->proc_name->name;
15559 8982 : else if (sym->ns && sym->ns->parent
15560 358 : && sym->ns && sym->ns->parent->proc_name
15561 358 : && sym->ns->parent->proc_name->attr.flavor == FL_MODULE)
15562 272 : module = sym->ns->parent->proc_name->name;
15563 : else
15564 : module = NULL;
15565 :
15566 45390 : if (gsym)
15567 : {
15568 13662 : if (gsym->type == GSYM_FUNCTION || gsym->type == GSYM_SUBROUTINE)
15569 : {
15570 13621 : gfc_symbol *global_sym;
15571 13621 : gfc_find_symbol (gsym->sym_name, gsym->ns, 0, &global_sym);
15572 :
15573 : /* For when the symtree does not match the symbol name, which can happen
15574 : in modules with PRIVATE. */
15575 :
15576 13621 : if (global_sym == NULL)
15577 1 : gfc_find_symbol_by_name (gsym->sym_name, gsym->ns, &global_sym);
15578 :
15579 13621 : gcc_assert (global_sym);
15580 :
15581 : /* If subroutines and functions are conflated, there is little point
15582 : in continuing checks. */
15583 13621 : if ((sym->attr.function && gsym->type == GSYM_SUBROUTINE)
15584 13621 : || (sym->attr.subroutine && gsym->type == GSYM_FUNCTION))
15585 : {
15586 1 : gfc_global_used (gsym, &sym->declared_at);
15587 1 : sym->binding_label = NULL;
15588 1 : sym->error = 1;
15589 13 : return;
15590 : }
15591 :
15592 7631 : if (gsym->type == GSYM_FUNCTION && sym->attr.function
15593 21251 : && !gfc_compare_types (&sym->ts, &global_sym->ts))
15594 : {
15595 2 : gfc_error ("Return type mismatch of function %qs with binding "
15596 : "label %qs at %L (%s/%s), originally declared at %L",
15597 : sym->name, sym->binding_label,
15598 : &sym->declared_at,
15599 : gfc_typename (&sym->ts),
15600 2 : gfc_typename (&global_sym->ts),
15601 : &gsym->where);
15602 2 : sym->binding_label = NULL;
15603 2 : sym->error = 1;
15604 2 : return;
15605 : }
15606 13618 : if (!compare_c_binding_arglists (global_sym, sym))
15607 : {
15608 10 : sym->binding_label = NULL;
15609 10 : sym->error = 1;
15610 10 : return;
15611 : }
15612 : }
15613 : }
15614 :
15615 13608 : if (!gsym
15616 13649 : || (!gsym->defined
15617 10697 : && (gsym->type == GSYM_FUNCTION || gsym->type == GSYM_SUBROUTINE)))
15618 : {
15619 31728 : if (!gsym)
15620 31728 : gsym = gfc_get_gsymbol (sym->binding_label, true);
15621 42425 : gsym->where = sym->declared_at;
15622 42425 : gsym->sym_name = sym->name;
15623 42425 : gsym->binding_label = sym->binding_label;
15624 42425 : gsym->ns = sym->ns;
15625 42425 : gsym->mod_name = module;
15626 42425 : if (sym->attr.function)
15627 28279 : gsym->type = GSYM_FUNCTION;
15628 14146 : else if (sym->attr.subroutine)
15629 14006 : gsym->type = GSYM_SUBROUTINE;
15630 : /* Mark as variable/procedure as defined, unless its an INTERFACE. */
15631 42425 : gsym->defined = sym->attr.if_source != IFSRC_IFBODY;
15632 42425 : return;
15633 : }
15634 :
15635 2952 : if (sym->attr.flavor == FL_VARIABLE && gsym->type != GSYM_UNKNOWN)
15636 : {
15637 1 : gfc_error ("Variable %qs with binding label %qs at %L uses the same global "
15638 : "identifier as entity at %L", sym->name,
15639 : sym->binding_label, &sym->declared_at, &gsym->where);
15640 : /* Clear the binding label to prevent checking multiple times. */
15641 1 : sym->binding_label = NULL;
15642 1 : return;
15643 : }
15644 :
15645 2951 : if (sym->attr.flavor == FL_VARIABLE && module
15646 37 : && (strcmp (module, gsym->mod_name) != 0
15647 35 : || strcmp (sym->name, gsym->sym_name) != 0))
15648 : {
15649 : /* This can only happen if the variable is defined in a module - if it
15650 : isn't the same module, reject it. */
15651 3 : gfc_error ("Variable %qs from module %qs with binding label %qs at %L "
15652 : "uses the same global identifier as entity at %L from module %qs",
15653 : sym->name, module, sym->binding_label,
15654 : &sym->declared_at, &gsym->where, gsym->mod_name);
15655 3 : sym->binding_label = NULL;
15656 3 : return;
15657 : }
15658 :
15659 2948 : if ((sym->attr.function || sym->attr.subroutine)
15660 2912 : && ((gsym->type != GSYM_SUBROUTINE && gsym->type != GSYM_FUNCTION)
15661 2910 : || (gsym->defined && sym->attr.if_source != IFSRC_IFBODY))
15662 2527 : && (sym != gsym->ns->proc_name && sym->attr.entry == 0)
15663 2095 : && (module != gsym->mod_name
15664 2091 : || strcmp (gsym->sym_name, sym->name) != 0
15665 2091 : || (module && strcmp (module, gsym->mod_name) != 0)))
15666 : {
15667 : /* Print an error if the procedure is defined multiple times; we have to
15668 : exclude references to the same procedure via module association or
15669 : multiple checks for the same procedure. */
15670 4 : gfc_error ("Procedure %qs with binding label %qs at %L uses the same "
15671 : "global identifier as entity at %L", sym->name,
15672 : sym->binding_label, &sym->declared_at, &gsym->where);
15673 4 : sym->binding_label = NULL;
15674 4 : return;
15675 : }
15676 : }
15677 :
15678 :
15679 : /* Resolve an index expression. */
15680 :
15681 : static bool
15682 271557 : resolve_index_expr (gfc_expr *e)
15683 : {
15684 271557 : if (!gfc_resolve_expr (e))
15685 : return false;
15686 :
15687 271547 : if (!gfc_simplify_expr (e, 0))
15688 : return false;
15689 :
15690 271545 : if (!gfc_specification_expr (e))
15691 : return false;
15692 :
15693 : return true;
15694 : }
15695 :
15696 :
15697 : /* Resolve a charlen structure. */
15698 :
15699 : static bool
15700 106582 : resolve_charlen (gfc_charlen *cl)
15701 : {
15702 106582 : int k;
15703 106582 : bool saved_specification_expr;
15704 :
15705 106582 : if (cl->resolved)
15706 : return true;
15707 :
15708 96917 : cl->resolved = 1;
15709 96917 : saved_specification_expr = specification_expr;
15710 96917 : specification_expr = true;
15711 :
15712 96917 : if (cl->length_from_typespec)
15713 : {
15714 1502 : if (!gfc_resolve_expr (cl->length))
15715 : {
15716 1 : specification_expr = saved_specification_expr;
15717 1 : return false;
15718 : }
15719 :
15720 1501 : if (!gfc_simplify_expr (cl->length, 0))
15721 : {
15722 0 : specification_expr = saved_specification_expr;
15723 0 : return false;
15724 : }
15725 :
15726 : /* cl->length has been resolved. It should have an integer type. */
15727 1501 : if (cl->length
15728 1500 : && (cl->length->ts.type != BT_INTEGER || cl->length->rank != 0))
15729 : {
15730 4 : gfc_error ("Scalar INTEGER expression expected at %L",
15731 : &cl->length->where);
15732 4 : return false;
15733 : }
15734 : }
15735 : else
15736 : {
15737 95415 : if (!resolve_index_expr (cl->length))
15738 : {
15739 19 : specification_expr = saved_specification_expr;
15740 19 : return false;
15741 : }
15742 : }
15743 :
15744 : /* F2008, 4.4.3.2: If the character length parameter value evaluates to
15745 : a negative value, the length of character entities declared is zero. */
15746 96893 : if (cl->length && cl->length->expr_type == EXPR_CONSTANT
15747 58113 : && mpz_sgn (cl->length->value.integer) < 0)
15748 0 : gfc_replace_expr (cl->length,
15749 : gfc_get_int_expr (gfc_charlen_int_kind, NULL, 0));
15750 :
15751 : /* Check that the character length is not too large. */
15752 96893 : k = gfc_validate_kind (BT_INTEGER, gfc_charlen_int_kind, false);
15753 96893 : if (cl->length && cl->length->expr_type == EXPR_CONSTANT
15754 58113 : && cl->length->ts.type == BT_INTEGER
15755 58113 : && mpz_cmp (cl->length->value.integer, gfc_integer_kinds[k].huge) > 0)
15756 : {
15757 4 : gfc_error ("String length at %L is too large", &cl->length->where);
15758 4 : specification_expr = saved_specification_expr;
15759 4 : return false;
15760 : }
15761 :
15762 96889 : specification_expr = saved_specification_expr;
15763 96889 : return true;
15764 : }
15765 :
15766 :
15767 : /* Test for non-constant shape arrays. */
15768 :
15769 : static bool
15770 121446 : is_non_constant_shape_array (gfc_symbol *sym)
15771 : {
15772 121446 : gfc_expr *e;
15773 121446 : int i;
15774 121446 : bool not_constant;
15775 :
15776 121446 : not_constant = false;
15777 121446 : if (sym->as != NULL)
15778 : {
15779 : /* Unfortunately, !gfc_is_compile_time_shape hits a legal case that
15780 : has not been simplified; parameter array references. Do the
15781 : simplification now. */
15782 158966 : for (i = 0; i < sym->as->rank + sym->as->corank; i++)
15783 : {
15784 91668 : if (i == GFC_MAX_DIMENSIONS)
15785 : break;
15786 :
15787 91666 : e = sym->as->lower[i];
15788 91666 : if (e && (!resolve_index_expr(e)
15789 88702 : || !gfc_is_constant_expr (e)))
15790 : not_constant = true;
15791 91666 : e = sym->as->upper[i];
15792 91666 : if (e && (!resolve_index_expr(e)
15793 87412 : || !gfc_is_constant_expr (e)))
15794 : not_constant = true;
15795 : }
15796 : }
15797 121446 : return not_constant;
15798 : }
15799 :
15800 : /* Given a symbol and an initialization expression, add code to initialize
15801 : the symbol to the function entry. */
15802 : static void
15803 2297 : build_init_assign (gfc_symbol *sym, gfc_expr *init)
15804 : {
15805 2297 : gfc_expr *lval;
15806 2297 : gfc_code *init_st;
15807 2297 : gfc_namespace *ns = sym->ns;
15808 :
15809 2297 : if (sym->attr.function && sym->result == sym && IS_PDT (sym))
15810 : {
15811 46 : gfc_free_expr (init);
15812 46 : return;
15813 : }
15814 :
15815 : /* Search for the function namespace if this is a contained
15816 : function without an explicit result. */
15817 2251 : if (sym->attr.function && sym == sym->result
15818 299 : && sym->name != sym->ns->proc_name->name)
15819 : {
15820 298 : ns = ns->contained;
15821 1376 : for (;ns; ns = ns->sibling)
15822 1315 : if (strcmp (ns->proc_name->name, sym->name) == 0)
15823 : break;
15824 : }
15825 :
15826 2251 : if (ns == NULL)
15827 : {
15828 61 : gfc_free_expr (init);
15829 61 : return;
15830 : }
15831 :
15832 : /* Build an l-value expression for the result. */
15833 2190 : lval = gfc_lval_expr_from_sym (sym);
15834 :
15835 : /* Add the code at scope entry. */
15836 2190 : init_st = gfc_get_code (EXEC_INIT_ASSIGN);
15837 2190 : init_st->next = ns->code;
15838 2190 : ns->code = init_st;
15839 :
15840 : /* Assign the default initializer to the l-value. */
15841 2190 : init_st->loc = sym->declared_at;
15842 2190 : init_st->expr1 = lval;
15843 2190 : init_st->expr2 = init;
15844 : }
15845 :
15846 :
15847 : /* Whether or not we can generate a default initializer for a symbol. */
15848 :
15849 : static bool
15850 32186 : can_generate_init (gfc_symbol *sym)
15851 : {
15852 32186 : symbol_attribute *a;
15853 32186 : if (!sym)
15854 : return false;
15855 32186 : a = &sym->attr;
15856 :
15857 : /* These symbols should never have a default initialization. */
15858 53065 : return !(
15859 32186 : a->allocatable
15860 32186 : || a->external
15861 31007 : || a->pointer
15862 31007 : || (sym->ts.type == BT_CLASS && CLASS_DATA (sym)
15863 6246 : && (CLASS_DATA (sym)->attr.class_pointer
15864 4104 : || CLASS_DATA (sym)->attr.proc_pointer))
15865 28865 : || a->in_equivalence
15866 28744 : || a->in_common
15867 28697 : || a->data
15868 28519 : || sym->module
15869 24552 : || a->cray_pointee
15870 24490 : || a->cray_pointer
15871 24490 : || sym->assoc
15872 21560 : || (!a->referenced && !a->result)
15873 20879 : || (a->dummy && (a->intent != INTENT_OUT
15874 1183 : || sym->ns->proc_name->attr.if_source == IFSRC_IFBODY))
15875 20879 : || (a->function && sym != sym->result)
15876 : );
15877 : }
15878 :
15879 :
15880 : /* Assign the default initializer to a derived type variable or result. */
15881 :
15882 : static void
15883 12236 : apply_default_init (gfc_symbol *sym)
15884 : {
15885 12236 : gfc_expr *init = NULL;
15886 :
15887 12236 : if (sym->attr.flavor != FL_VARIABLE && !sym->attr.function)
15888 : return;
15889 :
15890 11835 : if (sym->ts.type == BT_DERIVED && sym->ts.u.derived)
15891 10922 : init = gfc_generate_initializer (&sym->ts, can_generate_init (sym));
15892 :
15893 11835 : if (init == NULL && sym->ts.type != BT_CLASS)
15894 : return;
15895 :
15896 1915 : build_init_assign (sym, init);
15897 1915 : sym->attr.referenced = 1;
15898 : }
15899 :
15900 :
15901 : /* Build an initializer for a local. Returns null if the symbol should not have
15902 : a default initialization. */
15903 :
15904 : static gfc_expr *
15905 212556 : build_default_init_expr (gfc_symbol *sym)
15906 : {
15907 : /* These symbols should never have a default initialization. */
15908 212556 : if (sym->attr.allocatable
15909 198266 : || sym->attr.external
15910 198266 : || sym->attr.dummy
15911 130181 : || sym->attr.pointer
15912 121692 : || sym->attr.in_equivalence
15913 119316 : || sym->attr.in_common
15914 116214 : || sym->attr.data
15915 113916 : || sym->module
15916 111191 : || sym->attr.cray_pointee
15917 110890 : || sym->attr.cray_pointer
15918 110588 : || sym->assoc)
15919 : return NULL;
15920 :
15921 : /* Get the appropriate init expression. */
15922 105357 : return gfc_build_default_init_expr (&sym->ts, &sym->declared_at);
15923 : }
15924 :
15925 : /* Add an initialization expression to a local variable. */
15926 : static void
15927 212556 : apply_default_init_local (gfc_symbol *sym)
15928 : {
15929 212556 : gfc_expr *init = NULL;
15930 :
15931 : /* The symbol should be a variable or a function return value. */
15932 212556 : if ((sym->attr.flavor != FL_VARIABLE && !sym->attr.function)
15933 212556 : || (sym->attr.function && sym->result != sym))
15934 : return;
15935 :
15936 : /* Try to build the initializer expression. If we can't initialize
15937 : this symbol, then init will be NULL. */
15938 212556 : init = build_default_init_expr (sym);
15939 212556 : if (init == NULL)
15940 : return;
15941 :
15942 : /* For saved variables, we don't want to add an initializer at function
15943 : entry, so we just add a static initializer. Note that automatic variables
15944 : are stack allocated even with -fno-automatic; we have also to exclude
15945 : result variable, which are also nonstatic. */
15946 419 : if (!sym->attr.automatic
15947 419 : && (sym->attr.save || sym->ns->save_all
15948 377 : || (flag_max_stack_var_size == 0 && !sym->attr.result
15949 27 : && (sym->ns->proc_name && !sym->ns->proc_name->attr.recursive)
15950 14 : && (!sym->attr.dimension || !is_non_constant_shape_array (sym)))))
15951 : {
15952 : /* Don't clobber an existing initializer! */
15953 37 : gcc_assert (sym->value == NULL);
15954 37 : sym->value = init;
15955 37 : return;
15956 : }
15957 :
15958 382 : build_init_assign (sym, init);
15959 : }
15960 :
15961 :
15962 : /* Resolution of common features of flavors variable and procedure. */
15963 :
15964 : static bool
15965 1031315 : resolve_fl_var_and_proc (gfc_symbol *sym, int mp_flag)
15966 : {
15967 1031315 : gfc_array_spec *as;
15968 :
15969 1031315 : if (sym->ts.type == BT_CLASS && sym->attr.class_ok
15970 20621 : && sym->ts.u.derived && CLASS_DATA (sym))
15971 20616 : as = CLASS_DATA (sym)->as;
15972 : else
15973 1010699 : as = sym->as;
15974 :
15975 : /* Constraints on deferred shape variable. */
15976 1031315 : if (as == NULL || as->type != AS_DEFERRED)
15977 : {
15978 1005679 : bool pointer, allocatable, dimension;
15979 :
15980 1005679 : if (sym->ts.type == BT_CLASS && sym->attr.class_ok
15981 17130 : && sym->ts.u.derived && CLASS_DATA (sym))
15982 : {
15983 17125 : pointer = CLASS_DATA (sym)->attr.class_pointer;
15984 17125 : allocatable = CLASS_DATA (sym)->attr.allocatable;
15985 17125 : dimension = CLASS_DATA (sym)->attr.dimension;
15986 : }
15987 : else
15988 : {
15989 988554 : pointer = sym->attr.pointer && !sym->attr.select_type_temporary;
15990 988554 : allocatable = sym->attr.allocatable;
15991 988554 : dimension = sym->attr.dimension;
15992 : }
15993 :
15994 1005679 : if (allocatable)
15995 : {
15996 8538 : if (dimension
15997 8538 : && as
15998 524 : && as->type != AS_ASSUMED_RANK
15999 5 : && !sym->attr.select_rank_temporary)
16000 : {
16001 3 : gfc_error ("Allocatable array %qs at %L must have a deferred "
16002 : "shape or assumed rank", sym->name, &sym->declared_at);
16003 3 : return false;
16004 : }
16005 8535 : else if (!gfc_notify_std (GFC_STD_F2003, "Scalar object "
16006 : "%qs at %L may not be ALLOCATABLE",
16007 : sym->name, &sym->declared_at))
16008 : return false;
16009 : }
16010 :
16011 1005675 : if (pointer && dimension && as->type != AS_ASSUMED_RANK)
16012 : {
16013 4 : gfc_error ("Array pointer %qs at %L must have a deferred shape or "
16014 : "assumed rank", sym->name, &sym->declared_at);
16015 4 : sym->error = 1;
16016 4 : return false;
16017 : }
16018 : }
16019 : else
16020 : {
16021 25636 : if (!mp_flag && !sym->attr.allocatable && !sym->attr.pointer
16022 5071 : && sym->ts.type != BT_CLASS && !sym->assoc)
16023 : {
16024 3 : gfc_error ("Array %qs at %L cannot have a deferred shape",
16025 : sym->name, &sym->declared_at);
16026 3 : return false;
16027 : }
16028 : }
16029 :
16030 : /* Constraints on polymorphic variables. */
16031 1031304 : if (sym->ts.type == BT_CLASS && !(sym->result && sym->result != sym))
16032 : {
16033 : /* F03:C502. */
16034 19904 : if (sym->attr.class_ok
16035 19848 : && sym->ts.u.derived
16036 19843 : && !sym->attr.select_type_temporary
16037 18619 : && !UNLIMITED_POLY (sym)
16038 15893 : && CLASS_DATA (sym)
16039 15893 : && CLASS_DATA (sym)->ts.u.derived
16040 35796 : && !gfc_type_is_extensible (CLASS_DATA (sym)->ts.u.derived))
16041 : {
16042 5 : gfc_error ("Type %qs of CLASS variable %qs at %L is not extensible",
16043 5 : CLASS_DATA (sym)->ts.u.derived->name, sym->name,
16044 : &sym->declared_at);
16045 5 : return false;
16046 : }
16047 :
16048 : /* F03:C509. */
16049 : /* Assume that use associated symbols were checked in the module ns.
16050 : Class-variables that are associate-names are also something special
16051 : and excepted from the test. */
16052 19899 : if (!sym->attr.class_ok && !sym->attr.use_assoc && !sym->assoc
16053 54 : && !sym->attr.select_type_temporary
16054 54 : && !sym->attr.select_rank_temporary)
16055 : {
16056 54 : gfc_error ("CLASS variable %qs at %L must be dummy, allocatable "
16057 : "or pointer", sym->name, &sym->declared_at);
16058 54 : return false;
16059 : }
16060 : }
16061 :
16062 : return true;
16063 : }
16064 :
16065 :
16066 : /* Additional checks for symbols with flavor variable and derived
16067 : type. To be called from resolve_fl_variable. */
16068 :
16069 : static bool
16070 86587 : resolve_fl_variable_derived (gfc_symbol *sym, int no_init_flag)
16071 : {
16072 86587 : gcc_assert (sym->ts.type == BT_DERIVED || sym->ts.type == BT_CLASS);
16073 :
16074 : /* Check to see if a derived type is blocked from being host
16075 : associated by the presence of another class I symbol in the same
16076 : namespace. 14.6.1.3 of the standard and the discussion on
16077 : comp.lang.fortran. */
16078 86587 : if (sym->ts.u.derived
16079 86582 : && sym->ns != sym->ts.u.derived->ns
16080 49638 : && !sym->ts.u.derived->attr.use_assoc
16081 18796 : && sym->ns->proc_name->attr.if_source != IFSRC_IFBODY)
16082 : {
16083 17741 : gfc_symbol *s;
16084 17741 : gfc_find_symbol (sym->ts.u.derived->name, sym->ns, 0, &s);
16085 17741 : if (s && s->attr.generic)
16086 2 : s = gfc_find_dt_in_generic (s);
16087 17741 : if (s && !gfc_fl_struct (s->attr.flavor))
16088 : {
16089 2 : gfc_error ("The type %qs cannot be host associated at %L "
16090 : "because it is blocked by an incompatible object "
16091 : "of the same name declared at %L",
16092 2 : sym->ts.u.derived->name, &sym->declared_at,
16093 : &s->declared_at);
16094 2 : return false;
16095 : }
16096 : }
16097 :
16098 : /* 4th constraint in section 11.3: "If an object of a type for which
16099 : component-initialization is specified (R429) appears in the
16100 : specification-part of a module and does not have the ALLOCATABLE
16101 : or POINTER attribute, the object shall have the SAVE attribute."
16102 :
16103 : The check for initializers is performed with
16104 : gfc_has_default_initializer because gfc_default_initializer generates
16105 : a hidden default for allocatable components. */
16106 85860 : if (!(sym->value || no_init_flag) && sym->ns->proc_name
16107 19919 : && sym->ns->proc_name->attr.flavor == FL_MODULE
16108 441 : && !(sym->ns->save_all && !sym->attr.automatic) && !sym->attr.save
16109 21 : && !sym->attr.pointer && !sym->attr.allocatable
16110 21 : && gfc_has_default_initializer (sym->ts.u.derived)
16111 86594 : && !gfc_notify_std (GFC_STD_F2008, "Implied SAVE for module variable "
16112 : "%qs at %L, needed due to the default "
16113 : "initialization", sym->name, &sym->declared_at))
16114 : return false;
16115 :
16116 : /* Assign default initializer. */
16117 86583 : if (!(sym->value || sym->attr.pointer || sym->attr.allocatable)
16118 79913 : && (!no_init_flag
16119 61904 : || (sym->attr.intent == INTENT_OUT
16120 3429 : && sym->ns->proc_name->attr.if_source != IFSRC_IFBODY)))
16121 21264 : sym->value = gfc_generate_initializer (&sym->ts, can_generate_init (sym));
16122 :
16123 : return true;
16124 : }
16125 :
16126 :
16127 : /* F2008, C402 (R401): A colon shall not be used as a type-param-value
16128 : except in the declaration of an entity or component that has the POINTER
16129 : or ALLOCATABLE attribute. */
16130 :
16131 : static bool
16132 1620955 : deferred_requirements (gfc_symbol *sym)
16133 : {
16134 1620955 : if (sym->ts.deferred
16135 8266 : && !(sym->attr.pointer
16136 2502 : || sym->attr.allocatable
16137 127 : || sym->attr.associate_var
16138 7 : || sym->attr.omp_udr_artificial_var))
16139 : {
16140 : /* If a function has a result variable, only check the variable. */
16141 7 : if (sym->result && sym->name != sym->result->name)
16142 : return true;
16143 :
16144 6 : gfc_error ("Entity %qs at %L has a deferred type parameter and "
16145 : "requires either the POINTER or ALLOCATABLE attribute",
16146 : sym->name, &sym->declared_at);
16147 6 : return false;
16148 : }
16149 : return true;
16150 : }
16151 :
16152 :
16153 : /* Resolve symbols with flavor variable. */
16154 :
16155 : static bool
16156 691100 : resolve_fl_variable (gfc_symbol *sym, int mp_flag)
16157 : {
16158 691100 : const char *auto_save_msg = G_("Automatic object %qs at %L cannot have the "
16159 : "SAVE attribute");
16160 :
16161 691100 : if (!resolve_fl_var_and_proc (sym, mp_flag))
16162 : return false;
16163 :
16164 : /* Set this flag to check that variables are parameters of all entries.
16165 : This check is effected by the call to gfc_resolve_expr through
16166 : is_non_constant_shape_array. */
16167 691040 : bool saved_specification_expr = specification_expr;
16168 691040 : gfc_symbol *saved_specification_expr_symbol = specification_expr_symbol;
16169 691040 : specification_expr = true;
16170 691040 : specification_expr_symbol = sym;
16171 :
16172 691040 : if (sym->ns->proc_name
16173 690945 : && (sym->ns->proc_name->attr.flavor == FL_MODULE
16174 685655 : || sym->ns->proc_name->attr.is_main_program)
16175 85962 : && !sym->attr.use_assoc
16176 82549 : && !sym->attr.allocatable
16177 76428 : && !sym->attr.pointer
16178 763711 : && is_non_constant_shape_array (sym))
16179 : {
16180 : /* F08:C541. The shape of an array defined in a main program or module
16181 : * needs to be constant. */
16182 3 : gfc_error ("The module or main program array %qs at %L must "
16183 : "have constant shape", sym->name, &sym->declared_at);
16184 3 : specification_expr = saved_specification_expr;
16185 3 : specification_expr_symbol = saved_specification_expr_symbol;
16186 3 : return false;
16187 : }
16188 :
16189 : /* Constraints on deferred type parameter. */
16190 691037 : if (!deferred_requirements (sym))
16191 : return false;
16192 :
16193 691033 : if (sym->ts.type == BT_CHARACTER && !sym->attr.associate_var)
16194 : {
16195 : /* Make sure that character string variables with assumed length are
16196 : dummy arguments. */
16197 37092 : gfc_expr *e = NULL;
16198 :
16199 37092 : if (sym->ts.u.cl)
16200 37092 : e = sym->ts.u.cl->length;
16201 : else
16202 : return false;
16203 :
16204 37092 : if (e == NULL && !sym->attr.dummy && !sym->attr.result
16205 2718 : && !sym->ts.deferred && !sym->attr.select_type_temporary
16206 2 : && !sym->attr.omp_udr_artificial_var)
16207 : {
16208 2 : gfc_error ("Entity with assumed character length at %L must be a "
16209 : "dummy argument or a PARAMETER", &sym->declared_at);
16210 2 : specification_expr = saved_specification_expr;
16211 2 : specification_expr_symbol = saved_specification_expr_symbol;
16212 2 : return false;
16213 : }
16214 :
16215 21531 : if (e && sym->attr.save == SAVE_EXPLICIT && !gfc_is_constant_expr (e))
16216 : {
16217 1 : gfc_error (auto_save_msg, sym->name, &sym->declared_at);
16218 1 : specification_expr = saved_specification_expr;
16219 1 : specification_expr_symbol = saved_specification_expr_symbol;
16220 1 : return false;
16221 : }
16222 :
16223 37089 : if (!gfc_is_constant_expr (e)
16224 37089 : && !(e->expr_type == EXPR_VARIABLE
16225 1448 : && e->symtree->n.sym->attr.flavor == FL_PARAMETER))
16226 : {
16227 2262 : if (!sym->attr.use_assoc && sym->ns->proc_name
16228 1740 : && (sym->ns->proc_name->attr.flavor == FL_MODULE
16229 1739 : || sym->ns->proc_name->attr.is_main_program))
16230 : {
16231 3 : gfc_error ("%qs at %L must have constant character length "
16232 : "in this context", sym->name, &sym->declared_at);
16233 3 : specification_expr = saved_specification_expr;
16234 3 : specification_expr_symbol = saved_specification_expr_symbol;
16235 3 : return false;
16236 : }
16237 2259 : if (sym->attr.in_common)
16238 : {
16239 1 : gfc_error ("COMMON variable %qs at %L must have constant "
16240 : "character length", sym->name, &sym->declared_at);
16241 1 : specification_expr = saved_specification_expr;
16242 1 : specification_expr_symbol = saved_specification_expr_symbol;
16243 1 : return false;
16244 : }
16245 : }
16246 : }
16247 :
16248 691026 : if (sym->value == NULL && sym->attr.referenced
16249 214503 : && !(sym->as && sym->as->type == AS_ASSUMED_RANK))
16250 212556 : apply_default_init_local (sym); /* Try to apply a default initialization. */
16251 :
16252 : /* Determine if the symbol may not have an initializer. */
16253 691026 : int no_init_flag = 0, automatic_flag = 0;
16254 691026 : if (sym->attr.allocatable || sym->attr.external || sym->attr.dummy
16255 176455 : || sym->attr.intrinsic || sym->attr.result)
16256 : no_init_flag = 1;
16257 143524 : else if ((sym->attr.dimension || sym->attr.codimension) && !sym->attr.pointer
16258 179118 : && is_non_constant_shape_array (sym))
16259 : {
16260 1355 : no_init_flag = automatic_flag = 1;
16261 :
16262 : /* Also, they must not have the SAVE attribute.
16263 : SAVE_IMPLICIT is checked below. */
16264 1355 : if (sym->as && sym->attr.codimension)
16265 : {
16266 7 : int corank = sym->as->corank;
16267 7 : sym->as->corank = 0;
16268 7 : no_init_flag = automatic_flag = is_non_constant_shape_array (sym);
16269 7 : sym->as->corank = corank;
16270 : }
16271 1355 : if (automatic_flag && sym->attr.save == SAVE_EXPLICIT)
16272 : {
16273 2 : gfc_error (auto_save_msg, sym->name, &sym->declared_at);
16274 2 : specification_expr = saved_specification_expr;
16275 2 : specification_expr_symbol = saved_specification_expr_symbol;
16276 2 : return false;
16277 : }
16278 : }
16279 :
16280 : /* Ensure that any initializer is simplified. */
16281 691024 : if (sym->value)
16282 8562 : gfc_simplify_expr (sym->value, 1);
16283 :
16284 : /* Reject illegal initializers. */
16285 691024 : if (!sym->mark && sym->value)
16286 : {
16287 8562 : if (sym->attr.allocatable || (sym->ts.type == BT_CLASS
16288 67 : && CLASS_DATA (sym)->attr.allocatable))
16289 1 : gfc_error ("Allocatable %qs at %L cannot have an initializer",
16290 : sym->name, &sym->declared_at);
16291 8561 : else if (sym->attr.external)
16292 0 : gfc_error ("External %qs at %L cannot have an initializer",
16293 : sym->name, &sym->declared_at);
16294 8561 : else if (sym->attr.dummy)
16295 3 : gfc_error ("Dummy %qs at %L cannot have an initializer",
16296 : sym->name, &sym->declared_at);
16297 8558 : else if (sym->attr.intrinsic)
16298 0 : gfc_error ("Intrinsic %qs at %L cannot have an initializer",
16299 : sym->name, &sym->declared_at);
16300 8558 : else if (sym->attr.result)
16301 1 : gfc_error ("Function result %qs at %L cannot have an initializer",
16302 : sym->name, &sym->declared_at);
16303 8557 : else if (automatic_flag)
16304 5 : gfc_error ("Automatic array %qs at %L cannot have an initializer",
16305 : sym->name, &sym->declared_at);
16306 : else
16307 8552 : goto no_init_error;
16308 10 : specification_expr = saved_specification_expr;
16309 10 : specification_expr_symbol = saved_specification_expr_symbol;
16310 10 : return false;
16311 : }
16312 :
16313 682462 : no_init_error:
16314 691014 : if (sym->ts.type == BT_DERIVED || sym->ts.type == BT_CLASS)
16315 : {
16316 86587 : bool res = resolve_fl_variable_derived (sym, no_init_flag);
16317 86587 : specification_expr = saved_specification_expr;
16318 86587 : specification_expr_symbol = saved_specification_expr_symbol;
16319 86587 : return res;
16320 : }
16321 :
16322 604427 : specification_expr = saved_specification_expr;
16323 604427 : specification_expr_symbol = saved_specification_expr_symbol;
16324 604427 : return true;
16325 : }
16326 :
16327 :
16328 : /* Compare the dummy characteristics of a module procedure interface
16329 : declaration with the corresponding declaration in a submodule. */
16330 : static gfc_formal_arglist *new_formal;
16331 : static char errmsg[200];
16332 :
16333 : static void
16334 1424 : compare_fsyms (gfc_symbol *sym)
16335 : {
16336 1424 : gfc_symbol *fsym;
16337 :
16338 1424 : if (sym == NULL || new_formal == NULL)
16339 : return;
16340 :
16341 1424 : fsym = new_formal->sym;
16342 :
16343 1424 : if (sym == fsym)
16344 : return;
16345 :
16346 1400 : if (strcmp (sym->name, fsym->name) == 0)
16347 : {
16348 559 : if (!gfc_check_dummy_characteristics (fsym, sym, true, errmsg, 200))
16349 2 : gfc_error ("%s at %L", errmsg, &fsym->declared_at);
16350 : }
16351 : }
16352 :
16353 :
16354 : /* Resolve a procedure. */
16355 :
16356 : static bool
16357 511585 : resolve_fl_procedure (gfc_symbol *sym, int mp_flag)
16358 : {
16359 511585 : gfc_formal_arglist *arg;
16360 511585 : bool allocatable_or_pointer = false;
16361 :
16362 511585 : if (sym->attr.function
16363 511585 : && !resolve_fl_var_and_proc (sym, mp_flag))
16364 : return false;
16365 :
16366 : /* Constraints on deferred type parameter. */
16367 511575 : if (!deferred_requirements (sym))
16368 : return false;
16369 :
16370 511574 : if (sym->ts.type == BT_CHARACTER)
16371 : {
16372 12111 : gfc_charlen *cl = sym->ts.u.cl;
16373 :
16374 7860 : if (cl && cl->length && gfc_is_constant_expr (cl->length)
16375 13466 : && !resolve_charlen (cl))
16376 : return false;
16377 :
16378 12110 : if ((!cl || !cl->length || cl->length->expr_type != EXPR_CONSTANT)
16379 10756 : && sym->attr.proc == PROC_ST_FUNCTION)
16380 : {
16381 0 : gfc_error ("Character-valued statement function %qs at %L must "
16382 : "have constant length", sym->name, &sym->declared_at);
16383 0 : return false;
16384 : }
16385 : }
16386 :
16387 : /* Ensure that derived type for are not of a private type. Internal
16388 : module procedures are excluded by 2.2.3.3 - i.e., they are not
16389 : externally accessible and can access all the objects accessible in
16390 : the host. */
16391 117817 : if (!(sym->ns->parent && sym->ns->parent->proc_name
16392 117817 : && sym->ns->parent->proc_name->attr.flavor == FL_MODULE)
16393 601942 : && gfc_check_symbol_access (sym))
16394 : {
16395 476832 : gfc_interface *iface;
16396 :
16397 1014748 : for (arg = gfc_sym_get_dummy_args (sym); arg; arg = arg->next)
16398 : {
16399 537917 : if (arg->sym
16400 537777 : && arg->sym->ts.type == BT_DERIVED
16401 44255 : && arg->sym->ts.u.derived
16402 44255 : && !arg->sym->ts.u.derived->attr.use_assoc
16403 4526 : && !gfc_check_symbol_access (arg->sym->ts.u.derived)
16404 537926 : && !gfc_notify_std (GFC_STD_F2003, "%qs is of a PRIVATE type "
16405 : "and cannot be a dummy argument"
16406 : " of %qs, which is PUBLIC at %L",
16407 9 : arg->sym->name, sym->name,
16408 : &sym->declared_at))
16409 : {
16410 : /* Stop this message from recurring. */
16411 1 : arg->sym->ts.u.derived->attr.access = ACCESS_PUBLIC;
16412 1 : return false;
16413 : }
16414 : }
16415 :
16416 : /* PUBLIC interfaces may expose PRIVATE procedures that take types
16417 : PRIVATE to the containing module. */
16418 675328 : for (iface = sym->generic; iface; iface = iface->next)
16419 : {
16420 465969 : for (arg = gfc_sym_get_dummy_args (iface->sym); arg; arg = arg->next)
16421 : {
16422 267472 : if (arg->sym
16423 267440 : && arg->sym->ts.type == BT_DERIVED
16424 8051 : && !arg->sym->ts.u.derived->attr.use_assoc
16425 232 : && !gfc_check_symbol_access (arg->sym->ts.u.derived)
16426 267476 : && !gfc_notify_std (GFC_STD_F2003, "Procedure %qs in "
16427 : "PUBLIC interface %qs at %L "
16428 : "takes dummy arguments of %qs which "
16429 : "is PRIVATE", iface->sym->name,
16430 4 : sym->name, &iface->sym->declared_at,
16431 4 : gfc_typename(&arg->sym->ts)))
16432 : {
16433 : /* Stop this message from recurring. */
16434 1 : arg->sym->ts.u.derived->attr.access = ACCESS_PUBLIC;
16435 1 : return false;
16436 : }
16437 : }
16438 : }
16439 : }
16440 :
16441 511571 : if (sym->attr.function && sym->value && sym->attr.proc != PROC_ST_FUNCTION
16442 89 : && !sym->attr.proc_pointer)
16443 : {
16444 2 : gfc_error ("Function %qs at %L cannot have an initializer",
16445 : sym->name, &sym->declared_at);
16446 :
16447 : /* Make sure no second error is issued for this. */
16448 2 : sym->value->error = 1;
16449 2 : return false;
16450 : }
16451 :
16452 : /* An external symbol may not have an initializer because it is taken to be
16453 : a procedure. Exception: Procedure Pointers. */
16454 511569 : if (sym->attr.external && sym->value && !sym->attr.proc_pointer)
16455 : {
16456 0 : gfc_error ("External object %qs at %L may not have an initializer",
16457 : sym->name, &sym->declared_at);
16458 0 : return false;
16459 : }
16460 :
16461 : /* An elemental function is required to return a scalar 12.7.1 */
16462 511569 : if (sym->attr.elemental && sym->attr.function
16463 86674 : && (sym->as || (sym->ts.type == BT_CLASS && sym->attr.class_ok
16464 2 : && CLASS_DATA (sym)->as)))
16465 : {
16466 3 : gfc_error ("ELEMENTAL function %qs at %L must have a scalar "
16467 : "result", sym->name, &sym->declared_at);
16468 : /* Reset so that the error only occurs once. */
16469 3 : sym->attr.elemental = 0;
16470 3 : return false;
16471 : }
16472 :
16473 511566 : if (sym->attr.proc == PROC_ST_FUNCTION
16474 223 : && (sym->attr.allocatable || sym->attr.pointer))
16475 : {
16476 2 : gfc_error ("Statement function %qs at %L may not have pointer or "
16477 : "allocatable attribute", sym->name, &sym->declared_at);
16478 2 : return false;
16479 : }
16480 :
16481 : /* 5.1.1.5 of the Standard: A function name declared with an asterisk
16482 : char-len-param shall not be array-valued, pointer-valued, recursive
16483 : or pure. ....snip... A character value of * may only be used in the
16484 : following ways: (i) Dummy arg of procedure - dummy associates with
16485 : actual length; (ii) To declare a named constant; or (iii) External
16486 : function - but length must be declared in calling scoping unit. */
16487 511564 : if (sym->attr.function
16488 340196 : && sym->ts.type == BT_CHARACTER && !sym->ts.deferred
16489 6916 : && sym->ts.u.cl && sym->ts.u.cl->length == NULL)
16490 : {
16491 180 : if ((sym->as && sym->as->rank) || (sym->attr.pointer)
16492 178 : || (sym->attr.recursive) || (sym->attr.pure))
16493 : {
16494 4 : if (sym->as && sym->as->rank)
16495 1 : gfc_error ("CHARACTER(*) function %qs at %L cannot be "
16496 : "array-valued", sym->name, &sym->declared_at);
16497 :
16498 4 : if (sym->attr.pointer)
16499 1 : gfc_error ("CHARACTER(*) function %qs at %L cannot be "
16500 : "pointer-valued", sym->name, &sym->declared_at);
16501 :
16502 4 : if (sym->attr.pure)
16503 1 : gfc_error ("CHARACTER(*) function %qs at %L cannot be "
16504 : "pure", sym->name, &sym->declared_at);
16505 :
16506 4 : if (sym->attr.recursive)
16507 1 : gfc_error ("CHARACTER(*) function %qs at %L cannot be "
16508 : "recursive", sym->name, &sym->declared_at);
16509 :
16510 : return false;
16511 : }
16512 :
16513 : /* Appendix B.2 of the standard. Contained functions give an
16514 : error anyway. Deferred character length is an F2003 feature.
16515 : Don't warn on intrinsic conversion functions, which start
16516 : with two underscores. */
16517 176 : if (!sym->attr.contained && !sym->ts.deferred
16518 172 : && (sym->name[0] != '_' || sym->name[1] != '_'))
16519 172 : gfc_notify_std (GFC_STD_F95_OBS,
16520 : "CHARACTER(*) function %qs at %L",
16521 : sym->name, &sym->declared_at);
16522 : }
16523 :
16524 : /* F2008, C1218. */
16525 511560 : if (sym->attr.elemental)
16526 : {
16527 89988 : if (sym->attr.proc_pointer)
16528 : {
16529 7 : const char* name = (sym->attr.result ? sym->ns->proc_name->name
16530 : : sym->name);
16531 7 : gfc_error ("Procedure pointer %qs at %L shall not be elemental",
16532 : name, &sym->declared_at);
16533 7 : return false;
16534 : }
16535 89981 : if (sym->attr.dummy)
16536 : {
16537 3 : gfc_error ("Dummy procedure %qs at %L shall not be elemental",
16538 : sym->name, &sym->declared_at);
16539 3 : return false;
16540 : }
16541 : }
16542 :
16543 : /* F2018, C15100: "The result of an elemental function shall be scalar,
16544 : and shall not have the POINTER or ALLOCATABLE attribute." The scalar
16545 : pointer is tested and caught elsewhere. */
16546 511550 : if (sym->result)
16547 286378 : allocatable_or_pointer = sym->result->ts.type == BT_CLASS
16548 286378 : && CLASS_DATA (sym->result) ?
16549 1721 : (CLASS_DATA (sym->result)->attr.allocatable
16550 1721 : || CLASS_DATA (sym->result)->attr.pointer) :
16551 284657 : (sym->result->attr.allocatable
16552 284657 : || sym->result->attr.pointer);
16553 :
16554 511550 : if (sym->attr.elemental && sym->result
16555 86279 : && allocatable_or_pointer)
16556 : {
16557 4 : gfc_error ("Function result variable %qs at %L of elemental "
16558 : "function %qs shall not have an ALLOCATABLE or POINTER "
16559 : "attribute", sym->result->name,
16560 : &sym->result->declared_at, sym->name);
16561 4 : return false;
16562 : }
16563 :
16564 : /* F2018:C1585: "The function result of a pure function shall not be both
16565 : polymorphic and allocatable, or have a polymorphic allocatable ultimate
16566 : component." */
16567 511546 : if (sym->attr.pure && sym->result && sym->ts.u.derived)
16568 : {
16569 2544 : if (sym->ts.type == BT_CLASS
16570 5 : && sym->attr.class_ok
16571 4 : && CLASS_DATA (sym->result)
16572 4 : && CLASS_DATA (sym->result)->attr.allocatable)
16573 : {
16574 4 : gfc_error ("Result variable %qs of pure function at %L is "
16575 : "polymorphic allocatable",
16576 : sym->result->name, &sym->result->declared_at);
16577 4 : return false;
16578 : }
16579 :
16580 2540 : if (sym->ts.type == BT_DERIVED && sym->ts.u.derived->components)
16581 : {
16582 : gfc_component *c = sym->ts.u.derived->components;
16583 4805 : for (; c; c = c->next)
16584 2574 : if (c->ts.type == BT_CLASS
16585 2 : && CLASS_DATA (c)
16586 2 : && CLASS_DATA (c)->attr.allocatable)
16587 : {
16588 2 : gfc_error ("Result variable %qs of pure function at %L has "
16589 : "polymorphic allocatable component %qs",
16590 : sym->result->name, &sym->result->declared_at,
16591 : c->name);
16592 2 : return false;
16593 : }
16594 : }
16595 : }
16596 :
16597 511540 : if (sym->attr.is_bind_c && sym->attr.is_c_interop != 1)
16598 : {
16599 7472 : gfc_formal_arglist *curr_arg;
16600 7472 : int has_non_interop_arg = 0;
16601 :
16602 7472 : if (!verify_bind_c_sym (sym, &(sym->ts), sym->attr.in_common,
16603 7472 : sym->common_block))
16604 : {
16605 : /* Clear these to prevent looking at them again if there was an
16606 : error. */
16607 2 : sym->attr.is_bind_c = 0;
16608 2 : sym->attr.is_c_interop = 0;
16609 2 : sym->ts.is_c_interop = 0;
16610 : }
16611 : else
16612 : {
16613 : /* So far, no errors have been found. */
16614 : sym->attr.is_c_interop = 1;
16615 : sym->ts.is_c_interop = 1;
16616 : }
16617 :
16618 7472 : curr_arg = gfc_sym_get_dummy_args (sym);
16619 32667 : while (curr_arg != NULL)
16620 : {
16621 : /* Skip implicitly typed dummy args here. */
16622 17723 : if (curr_arg->sym && curr_arg->sym->attr.implicit_type == 0)
16623 17666 : if (!gfc_verify_c_interop_param (curr_arg->sym))
16624 : /* If something is found to fail, record the fact so we
16625 : can mark the symbol for the procedure as not being
16626 : BIND(C) to try and prevent multiple errors being
16627 : reported. */
16628 17723 : has_non_interop_arg = 1;
16629 :
16630 17723 : curr_arg = curr_arg->next;
16631 : }
16632 :
16633 : /* See if any of the arguments were not interoperable and if so, clear
16634 : the procedure symbol to prevent duplicate error messages. */
16635 7472 : if (has_non_interop_arg != 0)
16636 : {
16637 128 : sym->attr.is_c_interop = 0;
16638 128 : sym->ts.is_c_interop = 0;
16639 128 : sym->attr.is_bind_c = 0;
16640 : }
16641 : }
16642 :
16643 511540 : if (!sym->attr.proc_pointer)
16644 : {
16645 510421 : if (sym->attr.save == SAVE_EXPLICIT)
16646 : {
16647 5 : gfc_error ("PROCEDURE attribute conflicts with SAVE attribute "
16648 : "in %qs at %L", sym->name, &sym->declared_at);
16649 5 : return false;
16650 : }
16651 510416 : if (sym->attr.intent)
16652 : {
16653 1 : gfc_error ("PROCEDURE attribute conflicts with INTENT attribute "
16654 : "in %qs at %L", sym->name, &sym->declared_at);
16655 1 : return false;
16656 : }
16657 510415 : if (sym->attr.subroutine && sym->attr.result)
16658 : {
16659 2 : gfc_error ("PROCEDURE attribute conflicts with RESULT attribute "
16660 2 : "in %qs at %L", sym->ns->proc_name->name, &sym->declared_at);
16661 2 : return false;
16662 : }
16663 510413 : if (sym->attr.external && sym->attr.function && !sym->attr.module_procedure
16664 148153 : && ((sym->attr.if_source == IFSRC_DECL && !sym->attr.procedure)
16665 148150 : || sym->attr.contained))
16666 : {
16667 3 : gfc_error ("EXTERNAL attribute conflicts with FUNCTION attribute "
16668 : "in %qs at %L", sym->name, &sym->declared_at);
16669 3 : return false;
16670 : }
16671 510410 : if (strcmp ("ppr@", sym->name) == 0)
16672 : {
16673 0 : gfc_error ("Procedure pointer result %qs at %L "
16674 : "is missing the pointer attribute",
16675 0 : sym->ns->proc_name->name, &sym->declared_at);
16676 0 : return false;
16677 : }
16678 : }
16679 :
16680 : /* Assume that a procedure whose body is not known has references
16681 : to external arrays. */
16682 511529 : if (sym->attr.if_source != IFSRC_DECL)
16683 352797 : sym->attr.array_outer_dependency = 1;
16684 :
16685 : /* Compare the characteristics of a module procedure with the
16686 : interface declaration. Ideally this would be done with
16687 : gfc_compare_interfaces but, at present, the formal interface
16688 : cannot be copied to the ts.interface. */
16689 511529 : if (sym->attr.module_procedure
16690 1723 : && sym->attr.if_source == IFSRC_DECL)
16691 : {
16692 695 : gfc_symbol *iface;
16693 695 : char name[2*GFC_MAX_SYMBOL_LEN + 1];
16694 695 : char *module_name;
16695 695 : char *submodule_name;
16696 695 : strcpy (name, sym->ns->proc_name->name);
16697 695 : module_name = strtok (name, ".");
16698 695 : submodule_name = strtok (NULL, ".");
16699 :
16700 695 : iface = sym->tlink;
16701 695 : sym->tlink = NULL;
16702 :
16703 : /* Make sure that the result uses the correct charlen for deferred
16704 : length results. */
16705 695 : if (iface && sym->result
16706 228 : && iface->ts.type == BT_CHARACTER
16707 19 : && iface->ts.deferred)
16708 6 : sym->result->ts.u.cl = iface->ts.u.cl;
16709 :
16710 6 : if (iface == NULL)
16711 196 : goto check_formal;
16712 :
16713 : /* Check the procedure characteristics. */
16714 499 : if (sym->attr.elemental != iface->attr.elemental)
16715 : {
16716 1 : gfc_error ("Mismatch in ELEMENTAL attribute between MODULE "
16717 : "PROCEDURE at %L and its interface in %s",
16718 : &sym->declared_at, module_name);
16719 10 : return false;
16720 : }
16721 :
16722 498 : if (sym->attr.pure != iface->attr.pure)
16723 : {
16724 2 : gfc_error ("Mismatch in PURE attribute between MODULE "
16725 : "PROCEDURE at %L and its interface in %s",
16726 : &sym->declared_at, module_name);
16727 2 : return false;
16728 : }
16729 :
16730 496 : if (sym->attr.recursive != iface->attr.recursive)
16731 : {
16732 2 : gfc_error ("Mismatch in RECURSIVE attribute between MODULE "
16733 : "PROCEDURE at %L and its interface in %s",
16734 : &sym->declared_at, module_name);
16735 2 : return false;
16736 : }
16737 :
16738 : /* Check the result characteristics. */
16739 494 : if (!gfc_check_result_characteristics (sym, iface, errmsg, 200))
16740 : {
16741 5 : gfc_error ("%s between the MODULE PROCEDURE declaration "
16742 : "in MODULE %qs and the declaration at %L in "
16743 : "(SUB)MODULE %qs",
16744 : errmsg, module_name, &sym->declared_at,
16745 : submodule_name ? submodule_name : module_name);
16746 5 : return false;
16747 : }
16748 :
16749 489 : check_formal:
16750 : /* Check the characteristics of the formal arguments. */
16751 685 : if (sym->formal && sym->formal_ns)
16752 : {
16753 1332 : for (arg = sym->formal; arg && arg->sym; arg = arg->next)
16754 : {
16755 758 : new_formal = arg;
16756 758 : gfc_traverse_ns (sym->formal_ns, compare_fsyms);
16757 : }
16758 : }
16759 : }
16760 :
16761 : /* F2018:15.4.2.2 requires an explicit interface for procedures with the
16762 : BIND(C) attribute. */
16763 511519 : if (sym->attr.is_bind_c && sym->attr.if_source == IFSRC_UNKNOWN)
16764 : {
16765 1 : gfc_error ("Interface of %qs at %L must be explicit",
16766 : sym->name, &sym->declared_at);
16767 1 : return false;
16768 : }
16769 :
16770 : return true;
16771 : }
16772 :
16773 :
16774 : /* Resolve a list of finalizer procedures. That is, after they have hopefully
16775 : been defined and we now know their defined arguments, check that they fulfill
16776 : the requirements of the standard for procedures used as finalizers. */
16777 :
16778 : static bool
16779 120725 : gfc_resolve_finalizers (gfc_symbol* derived, bool *finalizable)
16780 : {
16781 120725 : gfc_finalizer *list, *pdt_finalizers = NULL;
16782 120725 : gfc_finalizer** prev_link; /* For removing wrong entries from the list. */
16783 120725 : bool result = true;
16784 120725 : bool seen_scalar = false;
16785 120725 : gfc_symbol *vtab;
16786 120725 : gfc_component *c;
16787 120725 : gfc_symbol *parent = gfc_get_derived_super_type (derived);
16788 :
16789 120725 : if (parent)
16790 17157 : gfc_resolve_finalizers (parent, finalizable);
16791 :
16792 : /* Ensure that derived-type components have a their finalizers resolved. */
16793 120725 : bool has_final = derived->f2k_derived && derived->f2k_derived->finalizers;
16794 382812 : for (c = derived->components; c; c = c->next)
16795 262087 : if (c->ts.type == BT_DERIVED
16796 73067 : && !c->attr.pointer && !c->attr.proc_pointer && !c->attr.allocatable)
16797 : {
16798 9586 : bool has_final2 = false;
16799 9586 : if (!gfc_resolve_finalizers (c->ts.u.derived, &has_final2))
16800 0 : return false; /* Error. */
16801 9586 : has_final = has_final || has_final2;
16802 : }
16803 : /* Return early if not finalizable. */
16804 120725 : if (!has_final)
16805 : {
16806 117944 : if (finalizable)
16807 9602 : *finalizable = false;
16808 : return true;
16809 : }
16810 :
16811 : /* If a PDT has finalizers, the pdt_type's f2k_derived is a copy of that of
16812 : the template. If the finalizers field has the same value, it needs to be
16813 : supplied with finalizers of the same pdt_type. */
16814 2781 : if (derived->attr.pdt_type
16815 78 : && derived->template_sym
16816 36 : && derived->template_sym->f2k_derived
16817 36 : && (pdt_finalizers = derived->template_sym->f2k_derived->finalizers)
16818 2817 : && derived->f2k_derived->finalizers == pdt_finalizers)
16819 : {
16820 36 : gfc_finalizer *tmp = NULL;
16821 36 : derived->f2k_derived->finalizers = NULL;
16822 36 : prev_link = &derived->f2k_derived->finalizers;
16823 132 : for (list = pdt_finalizers; list; list = list->next)
16824 : {
16825 96 : gfc_formal_arglist *args = gfc_sym_get_dummy_args (list->proc_sym);
16826 96 : if (args->sym
16827 96 : && args->sym->ts.type == BT_DERIVED
16828 96 : && args->sym->ts.u.derived
16829 96 : && !strcmp (args->sym->ts.u.derived->name, derived->name))
16830 : {
16831 54 : tmp = gfc_get_finalizer ();
16832 54 : *tmp = *list;
16833 54 : tmp->next = NULL;
16834 54 : *prev_link = tmp;
16835 54 : prev_link = &(tmp->next);
16836 54 : list->proc_tree = gfc_find_sym_in_symtree (list->proc_sym);
16837 : }
16838 : }
16839 : }
16840 :
16841 : /* Walk over the list of finalizer-procedures, check them, and if any one
16842 : does not fit in with the standard's definition, print an error and remove
16843 : it from the list. */
16844 2781 : prev_link = &derived->f2k_derived->finalizers;
16845 5746 : for (list = derived->f2k_derived->finalizers; list; list = *prev_link)
16846 : {
16847 2965 : gfc_formal_arglist *dummy_args;
16848 2965 : gfc_symbol* arg;
16849 2965 : gfc_finalizer* i;
16850 2965 : int my_rank;
16851 :
16852 : /* Skip this finalizer if we already resolved it. */
16853 2965 : if (list->proc_tree)
16854 : {
16855 2378 : if (list->proc_tree->n.sym->formal->sym->as == NULL
16856 620 : || list->proc_tree->n.sym->formal->sym->as->rank == 0)
16857 1758 : seen_scalar = true;
16858 2378 : prev_link = &(list->next);
16859 2378 : continue;
16860 : }
16861 :
16862 : /* Check this exists and is a SUBROUTINE. */
16863 587 : if (!list->proc_sym->attr.subroutine)
16864 : {
16865 3 : gfc_error ("FINAL procedure %qs at %L is not a SUBROUTINE",
16866 : list->proc_sym->name, &list->where);
16867 3 : goto error;
16868 : }
16869 :
16870 : /* We should have exactly one argument. */
16871 584 : dummy_args = gfc_sym_get_dummy_args (list->proc_sym);
16872 584 : if (!dummy_args || dummy_args->next)
16873 : {
16874 2 : gfc_error ("FINAL procedure at %L must have exactly one argument",
16875 : &list->where);
16876 2 : goto error;
16877 : }
16878 582 : arg = dummy_args->sym;
16879 :
16880 582 : if (!arg)
16881 : {
16882 1 : gfc_error ("Argument of FINAL procedure at %L must be of type %qs",
16883 1 : &list->proc_sym->declared_at, derived->name);
16884 1 : goto error;
16885 : }
16886 :
16887 581 : if (arg->as && arg->as->type == AS_ASSUMED_RANK
16888 6 : && ((list != derived->f2k_derived->finalizers) || list->next))
16889 : {
16890 0 : gfc_error ("FINAL procedure at %L with assumed rank argument must "
16891 : "be the only finalizer with the same kind/type "
16892 : "(F2018: C790)", &list->where);
16893 0 : goto error;
16894 : }
16895 :
16896 : /* This argument must be of our type. */
16897 581 : if (!derived->attr.pdt_template
16898 569 : && (arg->ts.type != BT_DERIVED || arg->ts.u.derived != derived))
16899 : {
16900 2 : gfc_error ("Argument of FINAL procedure at %L must be of type %qs",
16901 : &arg->declared_at, derived->name);
16902 2 : goto error;
16903 : }
16904 :
16905 : /* It must neither be a pointer nor allocatable nor optional. */
16906 579 : if (arg->attr.pointer)
16907 : {
16908 1 : gfc_error ("Argument of FINAL procedure at %L must not be a POINTER",
16909 : &arg->declared_at);
16910 1 : goto error;
16911 : }
16912 578 : if (arg->attr.allocatable)
16913 : {
16914 1 : gfc_error ("Argument of FINAL procedure at %L must not be"
16915 : " ALLOCATABLE", &arg->declared_at);
16916 1 : goto error;
16917 : }
16918 577 : if (arg->attr.optional)
16919 : {
16920 1 : gfc_error ("Argument of FINAL procedure at %L must not be OPTIONAL",
16921 : &arg->declared_at);
16922 1 : goto error;
16923 : }
16924 :
16925 : /* It must not be INTENT(OUT). */
16926 576 : if (arg->attr.intent == INTENT_OUT)
16927 : {
16928 1 : gfc_error ("Argument of FINAL procedure at %L must not be"
16929 : " INTENT(OUT)", &arg->declared_at);
16930 1 : goto error;
16931 : }
16932 :
16933 : /* Warn if the procedure is non-scalar and not assumed shape. */
16934 575 : if (warn_surprising && arg->as && arg->as->rank != 0
16935 3 : && arg->as->type != AS_ASSUMED_SHAPE)
16936 2 : gfc_warning (OPT_Wsurprising,
16937 : "Non-scalar FINAL procedure at %L should have assumed"
16938 : " shape argument", &arg->declared_at);
16939 :
16940 : /* Check that it does not match in kind and rank with a FINAL procedure
16941 : defined earlier. To really loop over the *earlier* declarations,
16942 : we need to walk the tail of the list as new ones were pushed at the
16943 : front. */
16944 : /* TODO: Handle kind parameters once they are implemented. */
16945 575 : my_rank = (arg->as ? arg->as->rank : 0);
16946 688 : for (i = list->next; i; i = i->next)
16947 : {
16948 115 : gfc_formal_arglist *dummy_args;
16949 :
16950 : /* Argument list might be empty; that is an error signalled earlier,
16951 : but we nevertheless continued resolving. */
16952 115 : dummy_args = gfc_sym_get_dummy_args (i->proc_sym);
16953 115 : if (dummy_args && !derived->attr.pdt_template)
16954 : {
16955 113 : gfc_symbol* i_arg = dummy_args->sym;
16956 113 : const int i_rank = (i_arg->as ? i_arg->as->rank : 0);
16957 113 : if (i_rank == my_rank)
16958 : {
16959 2 : gfc_error ("FINAL procedure %qs declared at %L has the same"
16960 : " rank (%d) as %qs",
16961 2 : list->proc_sym->name, &list->where, my_rank,
16962 2 : i->proc_sym->name);
16963 2 : list->proc_sym->refs++;
16964 2 : goto error;
16965 : }
16966 : }
16967 : }
16968 :
16969 : /* Is this the/a scalar finalizer procedure? */
16970 573 : if (my_rank == 0)
16971 435 : seen_scalar = true;
16972 :
16973 : /* Find the symtree for this procedure. */
16974 573 : gcc_assert (!list->proc_tree);
16975 573 : list->proc_tree = gfc_find_sym_in_symtree (list->proc_sym);
16976 :
16977 573 : prev_link = &list->next;
16978 573 : continue;
16979 :
16980 : /* Remove wrong nodes immediately from the list so we don't risk any
16981 : troubles in the future when they might fail later expectations. */
16982 14 : error:
16983 14 : i = list;
16984 14 : *prev_link = list->next;
16985 14 : gfc_free_finalizer (i);
16986 14 : result = false;
16987 573 : }
16988 :
16989 2781 : if (result == false)
16990 : return false;
16991 :
16992 : /* Warn if we haven't seen a scalar finalizer procedure (but we know there
16993 : were nodes in the list, must have been for arrays. It is surely a good
16994 : idea to have a scalar version there if there's something to finalize. */
16995 2777 : if (warn_surprising && derived->f2k_derived->finalizers && !seen_scalar)
16996 1 : gfc_warning (OPT_Wsurprising,
16997 : "Only array FINAL procedures declared for derived type %qs"
16998 : " defined at %L, suggest also scalar one unless an assumed"
16999 : " rank finalizer has been declared",
17000 : derived->name, &derived->declared_at);
17001 :
17002 2777 : if (!derived->attr.pdt_template)
17003 : {
17004 2717 : vtab = gfc_find_derived_vtab (derived);
17005 2717 : c = vtab->ts.u.derived->components->next->next->next->next->next;
17006 2717 : if (c && c->initializer && c->initializer->symtree && c->initializer->symtree->n.sym)
17007 2717 : gfc_set_sym_referenced (c->initializer->symtree->n.sym);
17008 : }
17009 :
17010 2777 : if (finalizable)
17011 676 : *finalizable = true;
17012 :
17013 : return true;
17014 : }
17015 :
17016 :
17017 : static gfc_symbol * containing_dt;
17018 :
17019 : /* Helper function for check_generic_tbp_ambiguity, which ensures that passed
17020 : arguments whose declared types are PDT instances only transmit the PASS arg
17021 : if they match the enclosing derived type. */
17022 :
17023 : static bool
17024 1496 : check_pdt_args (gfc_tbp_generic* t, const char *pass)
17025 : {
17026 1496 : gfc_formal_arglist *dummy_args;
17027 1496 : if (pass && containing_dt != NULL && containing_dt->attr.pdt_type)
17028 : {
17029 532 : dummy_args = gfc_sym_get_dummy_args (t->specific->u.specific->n.sym);
17030 1190 : while (dummy_args && strcmp (pass, dummy_args->sym->name))
17031 126 : dummy_args = dummy_args->next;
17032 532 : gcc_assert (strcmp (pass, dummy_args->sym->name) == 0);
17033 532 : if (dummy_args->sym->ts.type == BT_CLASS
17034 532 : && strcmp (CLASS_DATA (dummy_args->sym)->ts.u.derived->name,
17035 : containing_dt->name))
17036 356 : return true;
17037 : }
17038 : return false;
17039 : }
17040 :
17041 :
17042 : /* Check if two GENERIC targets are ambiguous and emit an error is they are. */
17043 :
17044 : static bool
17045 750 : check_generic_tbp_ambiguity (gfc_tbp_generic* t1, gfc_tbp_generic* t2,
17046 : const char* generic_name, locus where)
17047 : {
17048 750 : gfc_symbol *sym1, *sym2;
17049 750 : const char *pass1, *pass2;
17050 750 : gfc_formal_arglist *dummy_args;
17051 :
17052 750 : gcc_assert (t1->specific && t2->specific);
17053 750 : gcc_assert (!t1->specific->is_generic);
17054 750 : gcc_assert (!t2->specific->is_generic);
17055 750 : gcc_assert (t1->is_operator == t2->is_operator);
17056 :
17057 750 : sym1 = t1->specific->u.specific->n.sym;
17058 750 : sym2 = t2->specific->u.specific->n.sym;
17059 :
17060 750 : if (sym1 == sym2)
17061 : return true;
17062 :
17063 : /* Both must be SUBROUTINEs or both must be FUNCTIONs. */
17064 750 : if (sym1->attr.subroutine != sym2->attr.subroutine
17065 748 : || sym1->attr.function != sym2->attr.function)
17066 : {
17067 2 : gfc_error ("%qs and %qs cannot be mixed FUNCTION/SUBROUTINE for"
17068 : " GENERIC %qs at %L",
17069 : sym1->name, sym2->name, generic_name, &where);
17070 2 : return false;
17071 : }
17072 :
17073 : /* Determine PASS arguments. */
17074 748 : if (t1->specific->nopass)
17075 : pass1 = NULL;
17076 697 : else if (t1->specific->pass_arg)
17077 : pass1 = t1->specific->pass_arg;
17078 : else
17079 : {
17080 438 : dummy_args = gfc_sym_get_dummy_args (t1->specific->u.specific->n.sym);
17081 438 : if (dummy_args)
17082 437 : pass1 = dummy_args->sym->name;
17083 : else
17084 : pass1 = NULL;
17085 : }
17086 748 : if (t2->specific->nopass)
17087 : pass2 = NULL;
17088 696 : else if (t2->specific->pass_arg)
17089 : pass2 = t2->specific->pass_arg;
17090 : else
17091 : {
17092 559 : dummy_args = gfc_sym_get_dummy_args (t2->specific->u.specific->n.sym);
17093 559 : if (dummy_args)
17094 558 : pass2 = dummy_args->sym->name;
17095 : else
17096 : pass2 = NULL;
17097 : }
17098 :
17099 : /* Care must be taken with pdt types and templates because the declared type
17100 : of the argument that is not 'no_pass' need not be the same as the
17101 : containing derived type. If this is the case, subject the argument to
17102 : the full interface check, even though it cannot be used in the type
17103 : bound context. */
17104 748 : pass1 = check_pdt_args (t1, pass1) ? NULL : pass1;
17105 748 : pass2 = check_pdt_args (t2, pass2) ? NULL : pass2;
17106 :
17107 748 : if (containing_dt != NULL && containing_dt->attr.pdt_template)
17108 748 : pass1 = pass2 = NULL;
17109 :
17110 : /* Compare the interfaces. */
17111 748 : if (gfc_compare_interfaces (sym1, sym2, sym2->name, !t1->is_operator, 0,
17112 : NULL, 0, pass1, pass2))
17113 : {
17114 8 : gfc_error ("%qs and %qs for GENERIC %qs at %L are ambiguous",
17115 : sym1->name, sym2->name, generic_name, &where);
17116 8 : return false;
17117 : }
17118 :
17119 : return true;
17120 : }
17121 :
17122 :
17123 : /* Worker function for resolving a generic procedure binding; this is used to
17124 : resolve GENERIC as well as user and intrinsic OPERATOR typebound procedures.
17125 :
17126 : The difference between those cases is finding possible inherited bindings
17127 : that are overridden, as one has to look for them in tb_sym_root,
17128 : tb_uop_root or tb_op, respectively. Thus the caller must already find
17129 : the super-type and set p->overridden correctly. */
17130 :
17131 : static bool
17132 2421 : resolve_tb_generic_targets (gfc_symbol* super_type,
17133 : gfc_typebound_proc* p, const char* name)
17134 : {
17135 2421 : gfc_tbp_generic* target;
17136 2421 : gfc_symtree* first_target;
17137 2421 : gfc_symtree* inherited;
17138 :
17139 2421 : gcc_assert (p && p->is_generic);
17140 :
17141 : /* Try to find the specific bindings for the symtrees in our target-list. */
17142 2421 : gcc_assert (p->u.generic);
17143 5446 : for (target = p->u.generic; target; target = target->next)
17144 3042 : if (!target->specific)
17145 : {
17146 2627 : gfc_typebound_proc* overridden_tbp;
17147 2627 : gfc_tbp_generic* g;
17148 2627 : const char* target_name;
17149 :
17150 2627 : target_name = target->specific_st->name;
17151 :
17152 : /* Defined for this type directly. */
17153 2627 : if (target->specific_st->n.tb && !target->specific_st->n.tb->error)
17154 : {
17155 2618 : target->specific = target->specific_st->n.tb;
17156 2618 : goto specific_found;
17157 : }
17158 :
17159 : /* Look for an inherited specific binding. */
17160 9 : if (super_type)
17161 : {
17162 5 : inherited = gfc_find_typebound_proc (super_type, NULL, target_name,
17163 : true, NULL);
17164 :
17165 5 : if (inherited)
17166 : {
17167 5 : gcc_assert (inherited->n.tb);
17168 5 : target->specific = inherited->n.tb;
17169 5 : goto specific_found;
17170 : }
17171 : }
17172 :
17173 4 : gfc_error ("Undefined specific binding %qs as target of GENERIC %qs"
17174 : " at %L", target_name, name, &p->where);
17175 4 : return false;
17176 :
17177 : /* Once we've found the specific binding, check it is not ambiguous with
17178 : other specifics already found or inherited for the same GENERIC. */
17179 2623 : specific_found:
17180 2623 : gcc_assert (target->specific);
17181 :
17182 : /* This must really be a specific binding! */
17183 2623 : if (target->specific->is_generic)
17184 : {
17185 3 : gfc_error ("GENERIC %qs at %L must target a specific binding,"
17186 : " %qs is GENERIC, too", name, &p->where, target_name);
17187 3 : return false;
17188 : }
17189 :
17190 : /* Check those already resolved on this type directly. */
17191 6690 : for (g = p->u.generic; g; g = g->next)
17192 1464 : if (g != target && g->specific
17193 4809 : && !check_generic_tbp_ambiguity (target, g, name, p->where))
17194 : return false;
17195 :
17196 : /* Check for ambiguity with inherited specific targets. */
17197 2629 : for (overridden_tbp = p->overridden; overridden_tbp;
17198 16 : overridden_tbp = overridden_tbp->overridden)
17199 19 : if (overridden_tbp->is_generic)
17200 : {
17201 33 : for (g = overridden_tbp->u.generic; g; g = g->next)
17202 : {
17203 18 : gcc_assert (g->specific);
17204 18 : if (!check_generic_tbp_ambiguity (target, g, name, p->where))
17205 : return false;
17206 : }
17207 : }
17208 : }
17209 :
17210 : /* If we attempt to "overwrite" a specific binding, this is an error. */
17211 2404 : if (p->overridden && !p->overridden->is_generic)
17212 : {
17213 1 : gfc_error ("GENERIC %qs at %L cannot overwrite specific binding with"
17214 : " the same name", name, &p->where);
17215 1 : return false;
17216 : }
17217 :
17218 : /* Take the SUBROUTINE/FUNCTION attributes of the first specific target, as
17219 : all must have the same attributes here. */
17220 2403 : first_target = p->u.generic->specific->u.specific;
17221 2403 : gcc_assert (first_target);
17222 2403 : p->subroutine = first_target->n.sym->attr.subroutine;
17223 2403 : p->function = first_target->n.sym->attr.function;
17224 :
17225 2403 : return true;
17226 : }
17227 :
17228 :
17229 : /* Resolve a GENERIC procedure binding for a derived type. */
17230 :
17231 : static bool
17232 1249 : resolve_typebound_generic (gfc_symbol* derived, gfc_symtree* st)
17233 : {
17234 1249 : gfc_symbol* super_type;
17235 :
17236 : /* Find the overridden binding if any. */
17237 1249 : st->n.tb->overridden = NULL;
17238 1249 : super_type = gfc_get_derived_super_type (derived);
17239 1249 : if (super_type)
17240 : {
17241 40 : gfc_symtree* overridden;
17242 40 : overridden = gfc_find_typebound_proc (super_type, NULL, st->name,
17243 : true, NULL);
17244 :
17245 40 : if (overridden && overridden->n.tb)
17246 21 : st->n.tb->overridden = overridden->n.tb;
17247 : }
17248 :
17249 : /* Resolve using worker function. */
17250 1249 : return resolve_tb_generic_targets (super_type, st->n.tb, st->name);
17251 : }
17252 :
17253 :
17254 : /* Retrieve the target-procedure of an operator binding and do some checks in
17255 : common for intrinsic and user-defined type-bound operators. */
17256 :
17257 : static gfc_symbol*
17258 1244 : get_checked_tb_operator_target (gfc_tbp_generic* target, locus where)
17259 : {
17260 1244 : gfc_symbol* target_proc;
17261 :
17262 1244 : gcc_assert (target->specific && !target->specific->is_generic);
17263 1244 : target_proc = target->specific->u.specific->n.sym;
17264 1244 : gcc_assert (target_proc);
17265 :
17266 : /* F08:C468. All operator bindings must have a passed-object dummy argument. */
17267 1244 : if (target->specific->nopass)
17268 : {
17269 2 : gfc_error ("Type-bound operator at %L cannot be NOPASS", &where);
17270 2 : return NULL;
17271 : }
17272 :
17273 : return target_proc;
17274 : }
17275 :
17276 :
17277 : /* Resolve a type-bound intrinsic operator. */
17278 :
17279 : static bool
17280 1059 : resolve_typebound_intrinsic_op (gfc_symbol* derived, gfc_intrinsic_op op,
17281 : gfc_typebound_proc* p)
17282 : {
17283 1059 : gfc_symbol* super_type;
17284 1059 : gfc_tbp_generic* target;
17285 :
17286 : /* If there's already an error here, do nothing (but don't fail again). */
17287 1059 : if (p->error)
17288 : return true;
17289 :
17290 : /* Operators should always be GENERIC bindings. */
17291 1059 : gcc_assert (p->is_generic);
17292 :
17293 : /* Look for an overridden binding. */
17294 1059 : super_type = gfc_get_derived_super_type (derived);
17295 1059 : if (super_type && super_type->f2k_derived)
17296 1 : p->overridden = gfc_find_typebound_intrinsic_op (super_type, NULL,
17297 : op, true, NULL);
17298 : else
17299 1058 : p->overridden = NULL;
17300 :
17301 : /* Resolve general GENERIC properties using worker function. */
17302 1059 : if (!resolve_tb_generic_targets (super_type, p, gfc_op2string(op)))
17303 1 : goto error;
17304 :
17305 : /* Check the targets to be procedures of correct interface. */
17306 2163 : for (target = p->u.generic; target; target = target->next)
17307 : {
17308 1130 : gfc_symbol* target_proc;
17309 :
17310 1130 : target_proc = get_checked_tb_operator_target (target, p->where);
17311 1130 : if (!target_proc)
17312 1 : goto error;
17313 :
17314 1129 : if (!gfc_check_operator_interface (target_proc, op, p->where))
17315 3 : goto error;
17316 :
17317 : /* Add target to non-typebound operator list. */
17318 1126 : if (!target->specific->deferred && !derived->attr.use_assoc
17319 397 : && p->access != ACCESS_PRIVATE && derived->ns == gfc_current_ns)
17320 : {
17321 395 : gfc_interface *head, *intr;
17322 :
17323 : /* Preempt 'gfc_check_new_interface' for submodules, where the
17324 : mechanism for handling module procedures winds up resolving
17325 : operator interfaces twice and would otherwise cause an error.
17326 : Likewise, new instances of PDTs can cause the operator inter-
17327 : faces to be resolved multiple times. */
17328 467 : for (intr = derived->ns->op[op]; intr; intr = intr->next)
17329 91 : if (intr->sym == target_proc
17330 21 : && (target_proc->attr.used_in_submodule
17331 4 : || derived->attr.pdt_type
17332 2 : || derived->attr.pdt_template))
17333 : return true;
17334 :
17335 376 : if (!gfc_check_new_interface (derived->ns->op[op],
17336 : target_proc, p->where))
17337 : return false;
17338 374 : head = derived->ns->op[op];
17339 374 : intr = gfc_get_interface ();
17340 374 : intr->sym = target_proc;
17341 374 : intr->where = p->where;
17342 374 : intr->next = head;
17343 374 : derived->ns->op[op] = intr;
17344 : }
17345 : }
17346 :
17347 : return true;
17348 :
17349 5 : error:
17350 5 : p->error = 1;
17351 5 : return false;
17352 : }
17353 :
17354 :
17355 : /* Resolve a type-bound user operator (tree-walker callback). */
17356 :
17357 : static gfc_symbol* resolve_bindings_derived;
17358 : static bool resolve_bindings_result;
17359 :
17360 : static bool check_uop_procedure (gfc_symbol* sym, locus where);
17361 :
17362 : static void
17363 113 : resolve_typebound_user_op (gfc_symtree* stree)
17364 : {
17365 113 : gfc_symbol* super_type;
17366 113 : gfc_tbp_generic* target;
17367 :
17368 113 : gcc_assert (stree && stree->n.tb);
17369 :
17370 113 : if (stree->n.tb->error)
17371 : return;
17372 :
17373 : /* Operators should always be GENERIC bindings. */
17374 113 : gcc_assert (stree->n.tb->is_generic);
17375 :
17376 : /* Find overridden procedure, if any. */
17377 113 : super_type = gfc_get_derived_super_type (resolve_bindings_derived);
17378 113 : if (super_type && super_type->f2k_derived)
17379 : {
17380 18 : gfc_symtree* overridden;
17381 18 : overridden = gfc_find_typebound_user_op (super_type, NULL,
17382 : stree->name, true, NULL);
17383 :
17384 18 : if (overridden && overridden->n.tb)
17385 0 : stree->n.tb->overridden = overridden->n.tb;
17386 : }
17387 : else
17388 95 : stree->n.tb->overridden = NULL;
17389 :
17390 : /* Resolve basically using worker function. */
17391 113 : if (!resolve_tb_generic_targets (super_type, stree->n.tb, stree->name))
17392 0 : goto error;
17393 :
17394 : /* Check the targets to be functions of correct interface. */
17395 224 : for (target = stree->n.tb->u.generic; target; target = target->next)
17396 : {
17397 114 : gfc_symbol* target_proc;
17398 :
17399 114 : target_proc = get_checked_tb_operator_target (target, stree->n.tb->where);
17400 114 : if (!target_proc)
17401 1 : goto error;
17402 :
17403 113 : if (!check_uop_procedure (target_proc, stree->n.tb->where))
17404 2 : goto error;
17405 : }
17406 :
17407 : return;
17408 :
17409 3 : error:
17410 3 : resolve_bindings_result = false;
17411 3 : stree->n.tb->error = 1;
17412 : }
17413 :
17414 :
17415 : /* Resolve the type-bound procedures for a derived type. */
17416 :
17417 : static void
17418 10339 : resolve_typebound_procedure (gfc_symtree* stree)
17419 : {
17420 10339 : gfc_symbol* proc;
17421 10339 : locus where;
17422 10339 : gfc_symbol* me_arg;
17423 10339 : gfc_symbol* super_type;
17424 10339 : gfc_component* comp;
17425 :
17426 10339 : gcc_assert (stree);
17427 :
17428 : /* Undefined specific symbol from GENERIC target definition. */
17429 10339 : if (!stree->n.tb)
17430 10257 : return;
17431 :
17432 10333 : if (stree->n.tb->error)
17433 : return;
17434 :
17435 : /* If this is a GENERIC binding, use that routine. */
17436 10317 : if (stree->n.tb->is_generic)
17437 : {
17438 1249 : if (!resolve_typebound_generic (resolve_bindings_derived, stree))
17439 17 : goto error;
17440 : return;
17441 : }
17442 :
17443 : /* Get the target-procedure to check it. */
17444 9068 : gcc_assert (!stree->n.tb->is_generic);
17445 9068 : gcc_assert (stree->n.tb->u.specific);
17446 9068 : proc = stree->n.tb->u.specific->n.sym;
17447 9068 : where = stree->n.tb->where;
17448 :
17449 : /* Default access should already be resolved from the parser. */
17450 9068 : gcc_assert (stree->n.tb->access != ACCESS_UNKNOWN);
17451 :
17452 9068 : if (stree->n.tb->deferred)
17453 : {
17454 676 : if (!check_proc_interface (proc, &where))
17455 5 : goto error;
17456 : }
17457 : else
17458 : {
17459 : /* If proc has not been resolved at this point, proc->name may
17460 : actually be a USE associated entity. See PR fortran/89647. */
17461 8392 : if (!proc->resolve_symbol_called
17462 5842 : && proc->attr.function == 0 && proc->attr.subroutine == 0)
17463 : {
17464 11 : gfc_symbol *tmp;
17465 11 : gfc_find_symbol (proc->name, gfc_current_ns->parent, 1, &tmp);
17466 11 : if (tmp && tmp->attr.use_assoc)
17467 : {
17468 1 : proc->module = tmp->module;
17469 1 : proc->attr.proc = tmp->attr.proc;
17470 1 : proc->attr.function = tmp->attr.function;
17471 1 : proc->attr.subroutine = tmp->attr.subroutine;
17472 1 : proc->attr.use_assoc = tmp->attr.use_assoc;
17473 1 : proc->ts = tmp->ts;
17474 1 : proc->result = tmp->result;
17475 : }
17476 : }
17477 :
17478 : /* Check for F08:C465. */
17479 8392 : if ((!proc->attr.subroutine && !proc->attr.function)
17480 8382 : || (proc->attr.proc != PROC_MODULE
17481 70 : && proc->attr.if_source != IFSRC_IFBODY
17482 7 : && !proc->attr.module_procedure)
17483 8381 : || proc->attr.abstract)
17484 : {
17485 12 : gfc_error ("%qs must be a module procedure or an external "
17486 : "procedure with an explicit interface at %L",
17487 : proc->name, &where);
17488 12 : goto error;
17489 : }
17490 : }
17491 :
17492 9051 : stree->n.tb->subroutine = proc->attr.subroutine;
17493 9051 : stree->n.tb->function = proc->attr.function;
17494 :
17495 : /* Find the super-type of the current derived type. We could do this once and
17496 : store in a global if speed is needed, but as long as not I believe this is
17497 : more readable and clearer. */
17498 9051 : super_type = gfc_get_derived_super_type (resolve_bindings_derived);
17499 :
17500 : /* If PASS, resolve and check arguments if not already resolved / loaded
17501 : from a .mod file. */
17502 9051 : if (!stree->n.tb->nopass && stree->n.tb->pass_arg_num == 0)
17503 : {
17504 2898 : gfc_formal_arglist *dummy_args;
17505 :
17506 2898 : dummy_args = gfc_sym_get_dummy_args (proc);
17507 2898 : if (stree->n.tb->pass_arg)
17508 : {
17509 468 : gfc_formal_arglist *i;
17510 :
17511 : /* If an explicit passing argument name is given, walk the arg-list
17512 : and look for it. */
17513 :
17514 468 : me_arg = NULL;
17515 468 : stree->n.tb->pass_arg_num = 1;
17516 601 : for (i = dummy_args; i; i = i->next)
17517 : {
17518 599 : if (!strcmp (i->sym->name, stree->n.tb->pass_arg))
17519 : {
17520 : me_arg = i->sym;
17521 : break;
17522 : }
17523 133 : ++stree->n.tb->pass_arg_num;
17524 : }
17525 :
17526 468 : if (!me_arg)
17527 : {
17528 2 : gfc_error ("Procedure %qs with PASS(%s) at %L has no"
17529 : " argument %qs",
17530 : proc->name, stree->n.tb->pass_arg, &where,
17531 : stree->n.tb->pass_arg);
17532 2 : goto error;
17533 : }
17534 : }
17535 : else
17536 : {
17537 : /* Otherwise, take the first one; there should in fact be at least
17538 : one. */
17539 2430 : stree->n.tb->pass_arg_num = 1;
17540 2430 : if (!dummy_args)
17541 : {
17542 2 : gfc_error ("Procedure %qs with PASS at %L must have at"
17543 : " least one argument", proc->name, &where);
17544 2 : goto error;
17545 : }
17546 2428 : me_arg = dummy_args->sym;
17547 : }
17548 :
17549 : /* Now check that the argument-type matches and the passed-object
17550 : dummy argument is generally fine. */
17551 :
17552 2428 : gcc_assert (me_arg);
17553 :
17554 2894 : if (me_arg->ts.type != BT_CLASS)
17555 : {
17556 5 : gfc_error ("Non-polymorphic passed-object dummy argument of %qs"
17557 : " at %L", proc->name, &where);
17558 5 : goto error;
17559 : }
17560 :
17561 : /* The derived type is not a PDT template or type. Resolve as usual. */
17562 2889 : if (!resolve_bindings_derived->attr.pdt_template
17563 2880 : && !(containing_dt && containing_dt->attr.pdt_type
17564 60 : && CLASS_DATA (me_arg)->ts.u.derived != containing_dt)
17565 2860 : && (CLASS_DATA (me_arg)->ts.u.derived != resolve_bindings_derived))
17566 : {
17567 0 : gfc_error ("Argument %qs of %qs with PASS(%s) at %L must be of "
17568 : "the derived-type %qs", me_arg->name, proc->name,
17569 : me_arg->name, &where, resolve_bindings_derived->name);
17570 0 : goto error;
17571 : }
17572 :
17573 2889 : if (resolve_bindings_derived->attr.pdt_template
17574 2898 : && !gfc_pdt_is_instance_of (resolve_bindings_derived,
17575 9 : CLASS_DATA (me_arg)->ts.u.derived))
17576 : {
17577 0 : gfc_error ("Argument %qs of %qs with PASS(%s) at %L must be of "
17578 : "the parametric derived-type %qs", me_arg->name,
17579 : proc->name, me_arg->name, &where,
17580 : resolve_bindings_derived->name);
17581 0 : goto error;
17582 : }
17583 :
17584 2889 : if (((resolve_bindings_derived->attr.pdt_template
17585 9 : && gfc_pdt_is_instance_of (resolve_bindings_derived,
17586 9 : CLASS_DATA (me_arg)->ts.u.derived))
17587 2880 : || resolve_bindings_derived->attr.pdt_type)
17588 69 : && (me_arg->param_list != NULL)
17589 2958 : && (gfc_spec_list_type (me_arg->param_list,
17590 69 : CLASS_DATA(me_arg)->ts.u.derived)
17591 : != SPEC_ASSUMED))
17592 : {
17593 :
17594 : /* Add a check to verify if there are any LEN parameters in the
17595 : first place. If there are LEN parameters, throw this error.
17596 : If there are only KIND parameters, then don't trigger
17597 : this error. */
17598 6 : gfc_component *c;
17599 6 : bool seen_len_param = false;
17600 6 : gfc_actual_arglist *me_arg_param = me_arg->param_list;
17601 :
17602 6 : for (; me_arg_param; me_arg_param = me_arg_param->next)
17603 : {
17604 6 : c = gfc_find_component (CLASS_DATA(me_arg)->ts.u.derived,
17605 : me_arg_param->name, true, true, NULL);
17606 :
17607 6 : gcc_assert (c != NULL);
17608 :
17609 6 : if (c->attr.pdt_kind)
17610 0 : continue;
17611 :
17612 : /* Getting here implies that there is a pdt_len parameter
17613 : in the list. */
17614 : seen_len_param = true;
17615 : break;
17616 : }
17617 :
17618 6 : if (seen_len_param)
17619 : {
17620 6 : gfc_error ("All LEN type parameters of the passed dummy "
17621 : "argument %qs of %qs at %L must be ASSUMED.",
17622 : me_arg->name, proc->name, &where);
17623 6 : goto error;
17624 : }
17625 : }
17626 :
17627 2883 : gcc_assert (me_arg->ts.type == BT_CLASS);
17628 2883 : if (CLASS_DATA (me_arg)->as && CLASS_DATA (me_arg)->as->rank != 0)
17629 : {
17630 1 : gfc_error ("Passed-object dummy argument of %qs at %L must be"
17631 : " scalar", proc->name, &where);
17632 1 : goto error;
17633 : }
17634 2882 : if (CLASS_DATA (me_arg)->attr.allocatable)
17635 : {
17636 2 : gfc_error ("Passed-object dummy argument of %qs at %L must not"
17637 : " be ALLOCATABLE", proc->name, &where);
17638 2 : goto error;
17639 : }
17640 2880 : if (CLASS_DATA (me_arg)->attr.class_pointer)
17641 : {
17642 2 : gfc_error ("Passed-object dummy argument of %qs at %L must not"
17643 : " be POINTER", proc->name, &where);
17644 2 : goto error;
17645 : }
17646 : }
17647 :
17648 : /* If we are extending some type, check that we don't override a procedure
17649 : flagged NON_OVERRIDABLE. */
17650 9031 : stree->n.tb->overridden = NULL;
17651 9031 : if (super_type)
17652 : {
17653 1537 : gfc_symtree* overridden;
17654 1537 : overridden = gfc_find_typebound_proc (super_type, NULL,
17655 : stree->name, true, NULL);
17656 :
17657 1537 : if (overridden)
17658 : {
17659 1242 : if (overridden->n.tb)
17660 1242 : stree->n.tb->overridden = overridden->n.tb;
17661 :
17662 1242 : if (!gfc_check_typebound_override (stree, overridden))
17663 26 : goto error;
17664 : }
17665 : }
17666 :
17667 : /* See if there's a name collision with a component directly in this type. */
17668 21585 : for (comp = resolve_bindings_derived->components; comp; comp = comp->next)
17669 12581 : if (!strcmp (comp->name, stree->name))
17670 : {
17671 1 : gfc_error ("Procedure %qs at %L has the same name as a component of"
17672 : " %qs",
17673 : stree->name, &where, resolve_bindings_derived->name);
17674 1 : goto error;
17675 : }
17676 :
17677 : /* Try to find a name collision with an inherited component. */
17678 9004 : if (super_type && gfc_find_component (super_type, stree->name, true, true,
17679 : NULL))
17680 : {
17681 1 : gfc_error ("Procedure %qs at %L has the same name as an inherited"
17682 : " component of %qs",
17683 : stree->name, &where, resolve_bindings_derived->name);
17684 1 : goto error;
17685 : }
17686 :
17687 9003 : stree->n.tb->error = 0;
17688 9003 : return;
17689 :
17690 82 : error:
17691 82 : resolve_bindings_result = false;
17692 82 : stree->n.tb->error = 1;
17693 : }
17694 :
17695 :
17696 : static bool
17697 91702 : resolve_typebound_procedures (gfc_symbol* derived)
17698 : {
17699 91702 : int op;
17700 91702 : gfc_symbol* super_type;
17701 :
17702 : /* Resolve the super-type first so that inherited bindings (including
17703 : user operators) are fully resolved before we look them up via
17704 : gfc_find_typebound_user_op. This must happen even when 'derived'
17705 : has no direct type-bound bindings of its own. */
17706 91702 : super_type = gfc_get_derived_super_type (derived);
17707 91702 : if (super_type)
17708 14543 : resolve_symbol (super_type);
17709 :
17710 91702 : if (!derived->f2k_derived || !derived->f2k_derived->tb_sym_root)
17711 : return true;
17712 :
17713 4972 : resolve_bindings_derived = derived;
17714 4972 : resolve_bindings_result = true;
17715 :
17716 4972 : containing_dt = derived; /* Needed for checks of PDTs. */
17717 4972 : if (derived->f2k_derived->tb_sym_root)
17718 4972 : gfc_traverse_symtree (derived->f2k_derived->tb_sym_root,
17719 : &resolve_typebound_procedure);
17720 :
17721 4972 : if (derived->f2k_derived->tb_uop_root)
17722 91 : gfc_traverse_symtree (derived->f2k_derived->tb_uop_root,
17723 : &resolve_typebound_user_op);
17724 4972 : containing_dt = NULL;
17725 :
17726 144188 : for (op = 0; op != GFC_INTRINSIC_OPS; ++op)
17727 : {
17728 139216 : gfc_typebound_proc* p = derived->f2k_derived->tb_op[op];
17729 139216 : if (p && !resolve_typebound_intrinsic_op (derived,
17730 : (gfc_intrinsic_op)op, p))
17731 7 : resolve_bindings_result = false;
17732 : }
17733 :
17734 4972 : return resolve_bindings_result;
17735 : }
17736 :
17737 :
17738 : /* Add a derived type to the dt_list. The dt_list is used in trans-types.cc
17739 : to give all identical derived types the same backend_decl. */
17740 : static void
17741 188947 : add_dt_to_dt_list (gfc_symbol *derived)
17742 : {
17743 188947 : if (!derived->dt_next)
17744 : {
17745 88494 : if (gfc_derived_types)
17746 : {
17747 72429 : derived->dt_next = gfc_derived_types->dt_next;
17748 72429 : gfc_derived_types->dt_next = derived;
17749 : }
17750 : else
17751 : {
17752 16065 : derived->dt_next = derived;
17753 : }
17754 88494 : gfc_derived_types = derived;
17755 : }
17756 188947 : }
17757 :
17758 :
17759 : /* Ensure that a derived-type is really not abstract, meaning that every
17760 : inherited DEFERRED binding is overridden by a non-DEFERRED one. */
17761 :
17762 : static bool
17763 7212 : ensure_not_abstract_walker (gfc_symbol* sub, gfc_symtree* st)
17764 : {
17765 7212 : if (!st)
17766 : return true;
17767 :
17768 2772 : if (!ensure_not_abstract_walker (sub, st->left))
17769 : return false;
17770 2772 : if (!ensure_not_abstract_walker (sub, st->right))
17771 : return false;
17772 :
17773 2771 : if (st->n.tb && st->n.tb->deferred)
17774 : {
17775 2019 : gfc_symtree* overriding;
17776 2019 : overriding = gfc_find_typebound_proc (sub, NULL, st->name, true, NULL);
17777 2019 : if (!overriding)
17778 : return false;
17779 2018 : gcc_assert (overriding->n.tb);
17780 2018 : if (overriding->n.tb->deferred)
17781 : {
17782 5 : gfc_error ("Derived-type %qs declared at %L must be ABSTRACT because"
17783 : " %qs is DEFERRED and not overridden",
17784 : sub->name, &sub->declared_at, st->name);
17785 5 : return false;
17786 : }
17787 : }
17788 :
17789 : return true;
17790 : }
17791 :
17792 : static bool
17793 1520 : ensure_not_abstract (gfc_symbol* sub, gfc_symbol* ancestor)
17794 : {
17795 : /* The algorithm used here is to recursively travel up the ancestry of sub
17796 : and for each ancestor-type, check all bindings. If any of them is
17797 : DEFERRED, look it up starting from sub and see if the found (overriding)
17798 : binding is not DEFERRED.
17799 : This is not the most efficient way to do this, but it should be ok and is
17800 : clearer than something sophisticated. */
17801 :
17802 1669 : gcc_assert (ancestor && !sub->attr.abstract);
17803 :
17804 1669 : if (!ancestor->attr.abstract)
17805 : return true;
17806 :
17807 : /* Walk bindings of this ancestor. */
17808 1668 : if (ancestor->f2k_derived)
17809 : {
17810 1668 : bool t;
17811 1668 : t = ensure_not_abstract_walker (sub, ancestor->f2k_derived->tb_sym_root);
17812 1668 : if (!t)
17813 : return false;
17814 : }
17815 :
17816 : /* Find next ancestor type and recurse on it. */
17817 1662 : ancestor = gfc_get_derived_super_type (ancestor);
17818 1662 : if (ancestor)
17819 : return ensure_not_abstract (sub, ancestor);
17820 :
17821 : return true;
17822 : }
17823 :
17824 :
17825 : /* This check for typebound defined assignments is done recursively
17826 : since the order in which derived types are resolved is not always in
17827 : order of the declarations. */
17828 :
17829 : static void
17830 195149 : check_defined_assignments (gfc_symbol *derived)
17831 : {
17832 195149 : gfc_component *c;
17833 :
17834 659942 : for (c = derived->components; c; c = c->next)
17835 : {
17836 466600 : if (!gfc_bt_struct (c->ts.type)
17837 112442 : || c->attr.pointer
17838 23463 : || c->attr.proc_pointer_comp
17839 23463 : || c->attr.class_pointer
17840 23457 : || c->attr.proc_pointer)
17841 443677 : continue;
17842 :
17843 22923 : if (c->ts.u.derived->attr.defined_assign_comp
17844 22688 : || (c->ts.u.derived->f2k_derived
17845 22106 : && c->ts.u.derived->f2k_derived->tb_op[INTRINSIC_ASSIGN]))
17846 : {
17847 1783 : derived->attr.defined_assign_comp = 1;
17848 1783 : return;
17849 : }
17850 :
17851 21140 : if (c->attr.allocatable)
17852 7369 : continue;
17853 :
17854 13771 : check_defined_assignments (c->ts.u.derived);
17855 13771 : if (c->ts.u.derived->attr.defined_assign_comp)
17856 : {
17857 24 : derived->attr.defined_assign_comp = 1;
17858 24 : return;
17859 : }
17860 : }
17861 : }
17862 :
17863 :
17864 : /* Resolve a single component of a derived type or structure. */
17865 :
17866 : static bool
17867 442452 : resolve_component (gfc_component *c, gfc_symbol *sym)
17868 : {
17869 442452 : gfc_symbol *super_type;
17870 442452 : symbol_attribute *attr;
17871 :
17872 442452 : if (c->attr.artificial)
17873 : return true;
17874 :
17875 : /* Do not allow vtype components to be resolved in nameless namespaces
17876 : such as block data because the procedure pointers will cause ICEs
17877 : and vtables are not needed in these contexts. */
17878 303196 : if (sym->attr.vtype && sym->attr.use_assoc
17879 51398 : && sym->ns->proc_name == NULL)
17880 : return true;
17881 :
17882 : /* F2008, C442. */
17883 303187 : if ((!sym->attr.is_class || c != sym->components)
17884 303187 : && c->attr.codimension
17885 230 : && (!c->attr.allocatable || (c->as && c->as->type != AS_DEFERRED)))
17886 : {
17887 4 : gfc_error ("Coarray component %qs at %L must be allocatable with "
17888 : "deferred shape", c->name, &c->loc);
17889 4 : return false;
17890 : }
17891 :
17892 : /* F2008, C443. */
17893 303183 : if (c->attr.codimension && c->ts.type == BT_DERIVED
17894 85 : && c->ts.u.derived->ts.is_iso_c)
17895 : {
17896 1 : gfc_error ("Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) "
17897 : "shall not be a coarray", c->name, &c->loc);
17898 1 : return false;
17899 : }
17900 :
17901 : /* F2008, C444. */
17902 303182 : if (gfc_bt_struct (c->ts.type) && c->ts.u.derived->attr.coarray_comp
17903 28 : && (c->attr.codimension || c->attr.pointer || c->attr.dimension
17904 26 : || c->attr.allocatable))
17905 : {
17906 3 : gfc_error ("Component %qs at %L with coarray component "
17907 : "shall be a nonpointer, nonallocatable scalar",
17908 : c->name, &c->loc);
17909 3 : return false;
17910 : }
17911 :
17912 : /* F2008, C448. */
17913 303179 : if (c->ts.type == BT_CLASS)
17914 : {
17915 7736 : if (c->attr.class_ok && CLASS_DATA (c))
17916 : {
17917 7728 : attr = &(CLASS_DATA (c)->attr);
17918 :
17919 : /* Fix up contiguous attribute. */
17920 7728 : if (c->attr.contiguous)
17921 11 : attr->contiguous = 1;
17922 : }
17923 : else
17924 : attr = NULL;
17925 : }
17926 : else
17927 295443 : attr = &c->attr;
17928 :
17929 303171 : if (attr && attr->contiguous && (!attr->dimension || !attr->pointer))
17930 : {
17931 5 : gfc_error ("Component %qs at %L has the CONTIGUOUS attribute but "
17932 : "is not an array pointer", c->name, &c->loc);
17933 5 : return false;
17934 : }
17935 :
17936 : /* F2003, 15.2.1 - length has to be one. */
17937 41938 : if (sym->attr.is_bind_c && c->ts.type == BT_CHARACTER
17938 303193 : && (c->ts.u.cl == NULL || c->ts.u.cl->length == NULL
17939 19 : || !gfc_is_constant_expr (c->ts.u.cl->length)
17940 19 : || mpz_cmp_si (c->ts.u.cl->length->value.integer, 1) != 0))
17941 : {
17942 1 : gfc_error ("Component %qs of BIND(C) type at %L must have length one",
17943 : c->name, &c->loc);
17944 1 : return false;
17945 : }
17946 :
17947 56578 : if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.pdt_template
17948 529 : && !sym->attr.pdt_type && !sym->attr.pdt_template
17949 303181 : && !(gfc_get_derived_super_type (sym)
17950 0 : && (gfc_get_derived_super_type (sym)->attr.pdt_type
17951 0 : || gfc_get_derived_super_type (sym)->attr.pdt_template)))
17952 : {
17953 8 : gfc_actual_arglist *type_spec_list;
17954 8 : if (gfc_get_pdt_instance (c->param_list, &c->ts.u.derived,
17955 : &type_spec_list)
17956 : != MATCH_YES)
17957 0 : return false;
17958 8 : gfc_free_actual_arglist (c->param_list);
17959 8 : c->param_list = type_spec_list;
17960 8 : if (!sym->attr.pdt_type)
17961 8 : sym->attr.pdt_comp = 1;
17962 : }
17963 303165 : else if (IS_PDT (c) && !sym->attr.pdt_type)
17964 54 : sym->attr.pdt_comp = 1;
17965 :
17966 303173 : if (c->attr.proc_pointer && c->ts.interface)
17967 : {
17968 15462 : gfc_symbol *ifc = c->ts.interface;
17969 :
17970 15462 : if (!sym->attr.vtype && !check_proc_interface (ifc, &c->loc))
17971 : {
17972 6 : c->tb->error = 1;
17973 6 : return false;
17974 : }
17975 :
17976 15456 : if (ifc->attr.if_source || ifc->attr.intrinsic)
17977 : {
17978 : /* Resolve interface and copy attributes. */
17979 15405 : if (ifc->formal && !ifc->formal_ns)
17980 2665 : resolve_symbol (ifc);
17981 15405 : if (ifc->attr.intrinsic)
17982 0 : gfc_resolve_intrinsic (ifc, &ifc->declared_at);
17983 :
17984 15405 : if (ifc->result)
17985 : {
17986 8217 : c->ts = ifc->result->ts;
17987 8217 : c->attr.allocatable = ifc->result->attr.allocatable;
17988 8217 : c->attr.pointer = ifc->result->attr.pointer;
17989 8217 : c->attr.dimension = ifc->result->attr.dimension;
17990 8217 : c->as = gfc_copy_array_spec (ifc->result->as);
17991 8217 : c->attr.class_ok = ifc->result->attr.class_ok;
17992 : }
17993 : else
17994 : {
17995 7188 : c->ts = ifc->ts;
17996 7188 : c->attr.allocatable = ifc->attr.allocatable;
17997 7188 : c->attr.pointer = ifc->attr.pointer;
17998 7188 : c->attr.dimension = ifc->attr.dimension;
17999 7188 : c->as = gfc_copy_array_spec (ifc->as);
18000 7188 : c->attr.class_ok = ifc->attr.class_ok;
18001 : }
18002 15405 : c->ts.interface = ifc;
18003 15405 : c->attr.function = ifc->attr.function;
18004 15405 : c->attr.subroutine = ifc->attr.subroutine;
18005 :
18006 15405 : c->attr.pure = ifc->attr.pure;
18007 15405 : c->attr.elemental = ifc->attr.elemental;
18008 15405 : c->attr.recursive = ifc->attr.recursive;
18009 15405 : c->attr.always_explicit = ifc->attr.always_explicit;
18010 15405 : c->attr.ext_attr |= ifc->attr.ext_attr;
18011 : /* Copy char length. */
18012 15405 : if (ifc->ts.type == BT_CHARACTER && ifc->ts.u.cl)
18013 : {
18014 491 : gfc_charlen *cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl);
18015 454 : if (cl->length && !cl->resolved
18016 601 : && !gfc_resolve_expr (cl->length))
18017 : {
18018 0 : c->tb->error = 1;
18019 0 : return false;
18020 : }
18021 491 : c->ts.u.cl = cl;
18022 : }
18023 : }
18024 : }
18025 287711 : else if (c->attr.proc_pointer && c->ts.type == BT_UNKNOWN)
18026 : {
18027 : /* Since PPCs are not implicitly typed, a PPC without an explicit
18028 : interface must be a subroutine. */
18029 116 : gfc_add_subroutine (&c->attr, c->name, &c->loc);
18030 : }
18031 :
18032 : /* Procedure pointer components: Check PASS arg. */
18033 303167 : if (c->attr.proc_pointer && !c->tb->nopass && c->tb->pass_arg_num == 0
18034 578 : && !sym->attr.vtype)
18035 : {
18036 95 : gfc_symbol* me_arg;
18037 :
18038 95 : if (c->tb->pass_arg)
18039 : {
18040 20 : gfc_formal_arglist* i;
18041 :
18042 : /* If an explicit passing argument name is given, walk the arg-list
18043 : and look for it. */
18044 :
18045 20 : me_arg = NULL;
18046 20 : c->tb->pass_arg_num = 1;
18047 34 : for (i = c->ts.interface->formal; i; i = i->next)
18048 : {
18049 33 : if (!strcmp (i->sym->name, c->tb->pass_arg))
18050 : {
18051 : me_arg = i->sym;
18052 : break;
18053 : }
18054 14 : c->tb->pass_arg_num++;
18055 : }
18056 :
18057 20 : if (!me_arg)
18058 : {
18059 1 : gfc_error ("Procedure pointer component %qs with PASS(%s) "
18060 : "at %L has no argument %qs", c->name,
18061 : c->tb->pass_arg, &c->loc, c->tb->pass_arg);
18062 1 : c->tb->error = 1;
18063 1 : return false;
18064 : }
18065 : }
18066 : else
18067 : {
18068 : /* Otherwise, take the first one; there should in fact be at least
18069 : one. */
18070 75 : c->tb->pass_arg_num = 1;
18071 75 : if (!c->ts.interface->formal)
18072 : {
18073 3 : gfc_error ("Procedure pointer component %qs with PASS at %L "
18074 : "must have at least one argument",
18075 : c->name, &c->loc);
18076 3 : c->tb->error = 1;
18077 3 : return false;
18078 : }
18079 72 : me_arg = c->ts.interface->formal->sym;
18080 : }
18081 :
18082 : /* Now check that the argument-type matches. */
18083 72 : gcc_assert (me_arg);
18084 91 : if ((me_arg->ts.type != BT_DERIVED && me_arg->ts.type != BT_CLASS)
18085 90 : || (me_arg->ts.type == BT_DERIVED && me_arg->ts.u.derived != sym)
18086 90 : || (me_arg->ts.type == BT_CLASS
18087 82 : && CLASS_DATA (me_arg)->ts.u.derived != sym))
18088 : {
18089 1 : gfc_error ("Argument %qs of %qs with PASS(%s) at %L must be of"
18090 : " the derived type %qs", me_arg->name, c->name,
18091 : me_arg->name, &c->loc, sym->name);
18092 1 : c->tb->error = 1;
18093 1 : return false;
18094 : }
18095 :
18096 : /* Check for F03:C453. */
18097 90 : if (CLASS_DATA (me_arg)->attr.dimension)
18098 : {
18099 1 : gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
18100 : "must be scalar", me_arg->name, c->name, me_arg->name,
18101 : &c->loc);
18102 1 : c->tb->error = 1;
18103 1 : return false;
18104 : }
18105 :
18106 89 : if (CLASS_DATA (me_arg)->attr.class_pointer)
18107 : {
18108 1 : gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
18109 : "may not have the POINTER attribute", me_arg->name,
18110 : c->name, me_arg->name, &c->loc);
18111 1 : c->tb->error = 1;
18112 1 : return false;
18113 : }
18114 :
18115 88 : if (CLASS_DATA (me_arg)->attr.allocatable)
18116 : {
18117 1 : gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
18118 : "may not be ALLOCATABLE", me_arg->name, c->name,
18119 : me_arg->name, &c->loc);
18120 1 : c->tb->error = 1;
18121 1 : return false;
18122 : }
18123 :
18124 87 : if (gfc_type_is_extensible (sym) && me_arg->ts.type != BT_CLASS)
18125 : {
18126 2 : gfc_error ("Non-polymorphic passed-object dummy argument of %qs"
18127 : " at %L", c->name, &c->loc);
18128 2 : return false;
18129 : }
18130 :
18131 : }
18132 :
18133 : /* Check type-spec if this is not the parent-type component. */
18134 303157 : if (((sym->attr.is_class
18135 13655 : && (!sym->components->ts.u.derived->attr.extension
18136 2448 : || c != CLASS_DATA (sym->components)))
18137 290883 : || (!sym->attr.is_class
18138 289502 : && (!sym->attr.extension || c != sym->components)))
18139 294101 : && !sym->attr.vtype
18140 481384 : && !resolve_typespec_used (&c->ts, &c->loc, c->name))
18141 : return false;
18142 :
18143 303156 : super_type = gfc_get_derived_super_type (sym);
18144 :
18145 : /* If this type is an extension, set the accessibility of the parent
18146 : component. */
18147 303156 : if (super_type
18148 29812 : && ((sym->attr.is_class
18149 13655 : && c == CLASS_DATA (sym->components))
18150 20412 : || (!sym->attr.is_class && c == sym->components))
18151 17075 : && strcmp (super_type->name, c->name) == 0)
18152 7219 : c->attr.access = super_type->attr.access;
18153 :
18154 : /* If this type is an extension, see if this component has the same name
18155 : as an inherited type-bound procedure. */
18156 29812 : if (super_type && !sym->attr.is_class
18157 16157 : && gfc_find_typebound_proc (super_type, NULL, c->name, true, NULL))
18158 : {
18159 1 : gfc_error ("Component %qs of %qs at %L has the same name as an"
18160 : " inherited type-bound procedure",
18161 : c->name, sym->name, &c->loc);
18162 1 : return false;
18163 : }
18164 :
18165 303155 : if (c->ts.type == BT_CHARACTER && !c->attr.proc_pointer
18166 10586 : && !c->ts.deferred)
18167 : {
18168 8303 : if (sym->attr.pdt_template || c->attr.pdt_string)
18169 537 : gfc_correct_parm_expr (sym, &c->ts.u.cl->length);
18170 :
18171 8303 : if (c->ts.u.cl->length == NULL
18172 8297 : || !resolve_charlen(c->ts.u.cl)
18173 16599 : || !gfc_is_constant_expr (c->ts.u.cl->length))
18174 : {
18175 9 : gfc_error ("Character length of component %qs needs to "
18176 : "be a constant specification expression at %L",
18177 : c->name,
18178 9 : c->ts.u.cl->length ? &c->ts.u.cl->length->where : &c->loc);
18179 9 : return false;
18180 : }
18181 :
18182 8294 : if (c->ts.u.cl->length && c->ts.u.cl->length->ts.type != BT_INTEGER)
18183 : {
18184 2 : if (!c->ts.u.cl->length->error)
18185 : {
18186 1 : gfc_error ("Character length expression of component %qs at %L "
18187 : "must be of INTEGER type, found %s",
18188 1 : c->name, &c->ts.u.cl->length->where,
18189 : gfc_basic_typename (c->ts.u.cl->length->ts.type));
18190 1 : c->ts.u.cl->length->error = 1;
18191 : }
18192 : return false;
18193 : }
18194 : }
18195 :
18196 303144 : if (c->ts.type == BT_CHARACTER && c->ts.deferred
18197 2319 : && !c->attr.pointer && !c->attr.allocatable)
18198 : {
18199 1 : gfc_error ("Character component %qs of %qs at %L with deferred "
18200 : "length must be a POINTER or ALLOCATABLE",
18201 : c->name, sym->name, &c->loc);
18202 1 : return false;
18203 : }
18204 :
18205 : /* Add the hidden deferred length field. */
18206 303143 : if (c->ts.type == BT_CHARACTER
18207 11086 : && (c->ts.deferred || c->attr.pdt_string)
18208 2628 : && !c->attr.function
18209 2592 : && !sym->attr.is_class)
18210 : {
18211 2445 : char name[GFC_MAX_SYMBOL_LEN+9];
18212 2445 : gfc_component *strlen;
18213 2445 : sprintf (name, "_%s_length", c->name);
18214 2445 : strlen = gfc_find_component (sym, name, true, true, NULL);
18215 2445 : if (strlen == NULL)
18216 : {
18217 568 : if (!gfc_add_component (sym, name, &strlen))
18218 0 : return false;
18219 568 : strlen->ts.type = BT_INTEGER;
18220 568 : strlen->ts.kind = gfc_charlen_int_kind;
18221 568 : strlen->attr.access = ACCESS_PRIVATE;
18222 568 : strlen->attr.artificial = 1;
18223 : }
18224 : }
18225 :
18226 303143 : if (c->ts.type == BT_DERIVED
18227 56788 : && sym->component_access != ACCESS_PRIVATE
18228 55768 : && gfc_check_symbol_access (sym)
18229 109500 : && !is_sym_host_assoc (c->ts.u.derived, sym->ns)
18230 54691 : && !c->ts.u.derived->attr.use_assoc
18231 29641 : && !gfc_check_symbol_access (c->ts.u.derived)
18232 303340 : && !gfc_notify_std (GFC_STD_F2003, "the component %qs is a "
18233 : "PRIVATE type and cannot be a component of "
18234 : "%qs, which is PUBLIC at %L", c->name,
18235 : sym->name, &sym->declared_at))
18236 : return false;
18237 :
18238 303142 : if ((sym->attr.sequence || sym->attr.is_bind_c) && c->ts.type == BT_CLASS)
18239 : {
18240 2 : gfc_error ("Polymorphic component %s at %L in SEQUENCE or BIND(C) "
18241 : "type %s", c->name, &c->loc, sym->name);
18242 2 : return false;
18243 : }
18244 :
18245 303140 : if (sym->attr.sequence)
18246 : {
18247 2506 : if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.sequence == 0)
18248 : {
18249 0 : gfc_error ("Component %s of SEQUENCE type declared at %L does "
18250 : "not have the SEQUENCE attribute",
18251 : c->ts.u.derived->name, &sym->declared_at);
18252 0 : return false;
18253 : }
18254 : }
18255 :
18256 303140 : if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.generic)
18257 0 : c->ts.u.derived = gfc_find_dt_in_generic (c->ts.u.derived);
18258 303140 : else if (c->ts.type == BT_CLASS && c->attr.class_ok
18259 8070 : && CLASS_DATA (c)->ts.u.derived->attr.generic)
18260 0 : CLASS_DATA (c)->ts.u.derived
18261 0 : = gfc_find_dt_in_generic (CLASS_DATA (c)->ts.u.derived);
18262 :
18263 : /* If an allocatable component derived type is of the same type as
18264 : the enclosing derived type, we need a vtable generating so that
18265 : the __deallocate procedure is created. */
18266 303140 : if ((c->ts.type == BT_DERIVED || c->ts.type == BT_CLASS)
18267 64868 : && c->ts.u.derived == sym && c->attr.allocatable == 1)
18268 519 : gfc_find_vtab (&c->ts);
18269 :
18270 : /* Ensure that all the derived type components are put on the
18271 : derived type list; even in formal namespaces, where derived type
18272 : pointer components might not have been declared. */
18273 303140 : if (c->ts.type == BT_DERIVED
18274 56787 : && c->ts.u.derived
18275 56787 : && c->ts.u.derived->components
18276 53459 : && c->attr.pointer
18277 35785 : && sym != c->ts.u.derived)
18278 4520 : add_dt_to_dt_list (c->ts.u.derived);
18279 :
18280 303140 : if (c->as && c->as->type != AS_DEFERRED
18281 9096 : && (c->attr.pointer || c->attr.allocatable))
18282 : return false;
18283 :
18284 303126 : if (!gfc_resolve_array_spec (c->as,
18285 303126 : !(c->attr.pointer || c->attr.proc_pointer
18286 247991 : || c->attr.allocatable)))
18287 : return false;
18288 :
18289 118050 : if (c->initializer && !sym->attr.vtype
18290 39247 : && !c->attr.pdt_kind && !c->attr.pdt_len
18291 336799 : && !gfc_check_assign_symbol (sym, c, c->initializer))
18292 : return false;
18293 :
18294 : return true;
18295 : }
18296 :
18297 :
18298 : /* Be nice about the locus for a structure expression - show the locus of the
18299 : first non-null sub-expression if we can. */
18300 :
18301 : static locus *
18302 4 : cons_where (gfc_expr *struct_expr)
18303 : {
18304 4 : gfc_constructor *cons;
18305 :
18306 4 : gcc_assert (struct_expr && struct_expr->expr_type == EXPR_STRUCTURE);
18307 :
18308 4 : cons = gfc_constructor_first (struct_expr->value.constructor);
18309 12 : for (; cons; cons = gfc_constructor_next (cons))
18310 : {
18311 8 : if (cons->expr && cons->expr->expr_type != EXPR_NULL)
18312 4 : return &cons->expr->where;
18313 : }
18314 :
18315 0 : return &struct_expr->where;
18316 : }
18317 :
18318 : /* Resolve the components of a structure type. Much less work than derived
18319 : types. */
18320 :
18321 : static bool
18322 913 : resolve_fl_struct (gfc_symbol *sym)
18323 : {
18324 913 : gfc_component *c;
18325 913 : gfc_expr *init = NULL;
18326 913 : bool success;
18327 :
18328 : /* Make sure UNIONs do not have overlapping initializers. */
18329 913 : if (sym->attr.flavor == FL_UNION)
18330 : {
18331 498 : for (c = sym->components; c; c = c->next)
18332 : {
18333 331 : if (init && c->initializer)
18334 : {
18335 2 : gfc_error ("Conflicting initializers in union at %L and %L",
18336 : cons_where (init), cons_where (c->initializer));
18337 2 : gfc_free_expr (c->initializer);
18338 2 : c->initializer = NULL;
18339 : }
18340 : if (init == NULL)
18341 291 : init = c->initializer;
18342 : }
18343 : }
18344 :
18345 913 : success = true;
18346 2830 : for (c = sym->components; c; c = c->next)
18347 1917 : if (!resolve_component (c, sym))
18348 0 : success = false;
18349 :
18350 913 : if (!success)
18351 : return false;
18352 :
18353 913 : if (sym->components)
18354 862 : add_dt_to_dt_list (sym);
18355 :
18356 : return true;
18357 : }
18358 :
18359 : /* Figure if the derived type is using itself directly in one of its components
18360 : or through referencing other derived types. The information is required to
18361 : generate the __deallocate and __final type bound procedures to ensure
18362 : freeing larger hierarchies of derived types with allocatable objects. */
18363 :
18364 : static void
18365 147063 : resolve_cyclic_derived_type (gfc_symbol *derived)
18366 : {
18367 147063 : hash_set<gfc_symbol *> seen, to_examin;
18368 147063 : gfc_component *c;
18369 147063 : seen.add (derived);
18370 147063 : to_examin.add (derived);
18371 494547 : while (!to_examin.is_empty ())
18372 : {
18373 202733 : gfc_symbol *cand = *to_examin.begin ();
18374 202733 : to_examin.remove (cand);
18375 552114 : for (c = cand->components; c; c = c->next)
18376 351693 : if (c->ts.type == BT_DERIVED)
18377 : {
18378 77183 : if (c->ts.u.derived == derived)
18379 : {
18380 1240 : derived->attr.recursive = 1;
18381 2312 : return;
18382 : }
18383 75943 : else if (!seen.contains (c->ts.u.derived))
18384 : {
18385 50494 : seen.add (c->ts.u.derived);
18386 50494 : to_examin.add (c->ts.u.derived);
18387 : }
18388 : }
18389 274510 : else if (c->ts.type == BT_CLASS)
18390 : {
18391 10501 : if (!c->attr.class_ok)
18392 7 : continue;
18393 10494 : if (CLASS_DATA (c)->ts.u.derived == derived)
18394 : {
18395 1072 : derived->attr.recursive = 1;
18396 1072 : return;
18397 : }
18398 9422 : else if (!seen.contains (CLASS_DATA (c)->ts.u.derived))
18399 : {
18400 5503 : seen.add (CLASS_DATA (c)->ts.u.derived);
18401 5503 : to_examin.add (CLASS_DATA (c)->ts.u.derived);
18402 : }
18403 : }
18404 : }
18405 147063 : }
18406 :
18407 : /* Resolve the components of a derived type. This does not have to wait until
18408 : resolution stage, but can be done as soon as the dt declaration has been
18409 : parsed. */
18410 :
18411 : static bool
18412 181474 : resolve_fl_derived0 (gfc_symbol *sym)
18413 : {
18414 181474 : gfc_symbol* super_type;
18415 181474 : gfc_component *c;
18416 181474 : gfc_formal_arglist *f;
18417 181474 : bool success;
18418 :
18419 181474 : if (sym->attr.unlimited_polymorphic)
18420 : return true;
18421 :
18422 181474 : super_type = gfc_get_derived_super_type (sym);
18423 :
18424 : /* F2008, C432. */
18425 181474 : if (super_type && sym->attr.coarray_comp && !super_type->attr.coarray_comp)
18426 : {
18427 2 : gfc_error ("As extending type %qs at %L has a coarray component, "
18428 : "parent type %qs shall also have one", sym->name,
18429 : &sym->declared_at, super_type->name);
18430 2 : return false;
18431 : }
18432 :
18433 : /* Ensure the extended type gets resolved before we do. */
18434 19151 : if (super_type && !resolve_fl_derived0 (super_type))
18435 : return false;
18436 :
18437 : /* An ABSTRACT type must be extensible. */
18438 181466 : if (sym->attr.abstract && !gfc_type_is_extensible (sym))
18439 : {
18440 2 : gfc_error ("Non-extensible derived-type %qs at %L must not be ABSTRACT",
18441 : sym->name, &sym->declared_at);
18442 2 : return false;
18443 : }
18444 :
18445 : /* Resolving components below, may create vtabs for which the cyclic type
18446 : information needs to be present. */
18447 181464 : if (!sym->attr.vtype)
18448 147063 : resolve_cyclic_derived_type (sym);
18449 :
18450 181464 : c = (sym->attr.is_class) ? CLASS_DATA (sym->components)
18451 : : sym->components;
18452 :
18453 181464 : success = true;
18454 621999 : for ( ; c != NULL; c = c->next)
18455 440535 : if (!resolve_component (c, sym))
18456 96 : success = false;
18457 :
18458 181464 : if (!success)
18459 : return false;
18460 :
18461 : /* Now add the caf token field, where needed. */
18462 181378 : if (flag_coarray == GFC_FCOARRAY_LIB && !sym->attr.is_class
18463 1065 : && !sym->attr.vtype)
18464 : {
18465 2335 : for (c = sym->components; c; c = c->next)
18466 1483 : if (!c->attr.dimension && !c->attr.codimension
18467 809 : && (c->attr.allocatable || c->attr.pointer))
18468 : {
18469 146 : char name[GFC_MAX_SYMBOL_LEN+9];
18470 146 : gfc_component *token;
18471 146 : sprintf (name, "_caf_%s", c->name);
18472 146 : token = gfc_find_component (sym, name, true, true, NULL);
18473 146 : if (token == NULL)
18474 : {
18475 82 : if (!gfc_add_component (sym, name, &token))
18476 0 : return false;
18477 82 : token->ts.type = BT_VOID;
18478 82 : token->ts.kind = gfc_default_integer_kind;
18479 82 : token->attr.access = ACCESS_PRIVATE;
18480 82 : token->attr.artificial = 1;
18481 82 : token->attr.caf_token = 1;
18482 : }
18483 146 : c->caf_token = token;
18484 : }
18485 : }
18486 :
18487 181378 : check_defined_assignments (sym);
18488 :
18489 181378 : if (!sym->attr.defined_assign_comp && super_type)
18490 18144 : sym->attr.defined_assign_comp
18491 18144 : = super_type->attr.defined_assign_comp;
18492 :
18493 : /* If this is a non-ABSTRACT type extending an ABSTRACT one, ensure that
18494 : all DEFERRED bindings are overridden. */
18495 19144 : if (super_type && super_type->attr.abstract && !sym->attr.abstract
18496 1523 : && !sym->attr.is_class
18497 3303 : && !ensure_not_abstract (sym, super_type))
18498 : return false;
18499 :
18500 : /* Check that there is a component for every PDT parameter. */
18501 181372 : if (sym->attr.pdt_template)
18502 : {
18503 4602 : for (f = sym->formal; f; f = f->next)
18504 : {
18505 2800 : if (!f->sym)
18506 1 : continue;
18507 2799 : c = gfc_find_component (sym, f->sym->name, true, true, NULL);
18508 2799 : if (c == NULL)
18509 : {
18510 9 : gfc_error ("Parameterized type %qs does not have a component "
18511 : "corresponding to parameter %qs at %L", sym->name,
18512 9 : f->sym->name, &sym->declared_at);
18513 9 : break;
18514 : }
18515 : }
18516 : }
18517 :
18518 : /* Add derived type to the derived type list. */
18519 181372 : add_dt_to_dt_list (sym);
18520 :
18521 181372 : return true;
18522 : }
18523 :
18524 : /* The following procedure does the full resolution of a derived type,
18525 : including resolution of all type-bound procedures (if present). In contrast
18526 : to 'resolve_fl_derived0' this can only be done after the module has been
18527 : parsed completely. */
18528 :
18529 : static bool
18530 93999 : resolve_fl_derived (gfc_symbol *sym)
18531 : {
18532 93999 : gfc_symbol *gen_dt = NULL;
18533 :
18534 93999 : if (sym->attr.unlimited_polymorphic)
18535 : return true;
18536 :
18537 93999 : if (!sym->attr.is_class)
18538 80331 : gfc_find_symbol (sym->name, sym->ns, 0, &gen_dt);
18539 60349 : if (gen_dt && gen_dt->generic && gen_dt->generic->next
18540 2315 : && (!gen_dt->generic->sym->attr.use_assoc
18541 2166 : || gen_dt->generic->sym->module != gen_dt->generic->next->sym->module)
18542 94181 : && !gfc_notify_std (GFC_STD_F2003, "Generic name %qs of function "
18543 : "%qs at %L being the same name as derived "
18544 : "type at %L", sym->name,
18545 : gen_dt->generic->sym == sym
18546 11 : ? gen_dt->generic->next->sym->name
18547 : : gen_dt->generic->sym->name,
18548 : gen_dt->generic->sym == sym
18549 11 : ? &gen_dt->generic->next->sym->declared_at
18550 : : &gen_dt->generic->sym->declared_at,
18551 : &sym->declared_at))
18552 : return false;
18553 :
18554 93995 : if (sym->components == NULL && !sym->attr.zero_comp && !sym->attr.use_assoc)
18555 : {
18556 13 : gfc_error ("Derived type %qs at %L has not been declared",
18557 : sym->name, &sym->declared_at);
18558 13 : return false;
18559 : }
18560 :
18561 : /* Resolve the finalizer procedures. */
18562 93982 : if (!gfc_resolve_finalizers (sym, NULL))
18563 : return false;
18564 :
18565 93979 : if (sym->attr.is_class && sym->ts.u.derived == NULL)
18566 : {
18567 : /* Fix up incomplete CLASS symbols. */
18568 13668 : gfc_component *data = gfc_find_component (sym, "_data", true, true, NULL);
18569 13668 : gfc_component *vptr = gfc_find_component (sym, "_vptr", true, true, NULL);
18570 :
18571 13668 : if (data->ts.u.derived->attr.pdt_template)
18572 : {
18573 0 : match m;
18574 0 : m = gfc_get_pdt_instance (sym->param_list, &data->ts.u.derived,
18575 : &data->param_list);
18576 0 : if (m != MATCH_YES
18577 0 : || !gfc_build_class_symbol (&sym->ts, &sym->attr, &sym->as))
18578 : {
18579 0 : gfc_error ("Failed to build PDT class component at %L",
18580 : &sym->declared_at);
18581 0 : return false;
18582 : }
18583 0 : data = gfc_find_component (sym, "_data", true, true, NULL);
18584 0 : vptr = gfc_find_component (sym, "_vptr", true, true, NULL);
18585 : }
18586 :
18587 : /* Nothing more to do for unlimited polymorphic entities. */
18588 13668 : if (data->ts.u.derived->attr.unlimited_polymorphic)
18589 : {
18590 2193 : add_dt_to_dt_list (sym);
18591 2193 : return true;
18592 : }
18593 11475 : else if (vptr->ts.u.derived == NULL)
18594 : {
18595 6801 : gfc_symbol *vtab = gfc_find_derived_vtab (data->ts.u.derived);
18596 6801 : gcc_assert (vtab);
18597 6801 : vptr->ts.u.derived = vtab->ts.u.derived;
18598 6801 : if (vptr->ts.u.derived && !resolve_fl_derived0 (vptr->ts.u.derived))
18599 : return false;
18600 : }
18601 : }
18602 :
18603 91786 : if (!resolve_fl_derived0 (sym))
18604 : return false;
18605 :
18606 : /* Resolve the type-bound procedures. */
18607 91702 : if (!resolve_typebound_procedures (sym))
18608 : return false;
18609 :
18610 : /* Generate module vtables subject to their accessibility and their not
18611 : being vtables or pdt templates. If this is not done class declarations
18612 : in external procedures wind up with their own version and so SELECT TYPE
18613 : fails because the vptrs do not have the same address. */
18614 91661 : if (gfc_option.allow_std & GFC_STD_F2003 && sym->ns->proc_name
18615 91600 : && (sym->ns->proc_name->attr.flavor == FL_MODULE
18616 68572 : || (sym->attr.recursive && sym->attr.alloc_comp))
18617 23206 : && sym->attr.access != ACCESS_PRIVATE
18618 23173 : && !(sym->attr.vtype || sym->attr.pdt_template))
18619 : {
18620 20634 : gfc_symbol *vtab = gfc_find_derived_vtab (sym);
18621 20634 : gfc_set_sym_referenced (vtab);
18622 : }
18623 :
18624 : return true;
18625 : }
18626 :
18627 :
18628 : static bool
18629 881 : resolve_fl_namelist (gfc_symbol *sym)
18630 : {
18631 881 : gfc_namelist *nl;
18632 881 : gfc_symbol *nlsym;
18633 :
18634 3082 : for (nl = sym->namelist; nl; nl = nl->next)
18635 : {
18636 : /* Check again, the check in match only works if NAMELIST comes
18637 : after the decl. */
18638 2206 : if (nl->sym->as && nl->sym->as->type == AS_ASSUMED_SIZE)
18639 : {
18640 1 : gfc_error ("Assumed size array %qs in namelist %qs at %L is not "
18641 : "allowed", nl->sym->name, sym->name, &sym->declared_at);
18642 1 : return false;
18643 : }
18644 :
18645 678 : if (nl->sym->as && nl->sym->as->type == AS_ASSUMED_SHAPE
18646 2213 : && !gfc_notify_std (GFC_STD_F2003, "NAMELIST array object %qs "
18647 : "with assumed shape in namelist %qs at %L",
18648 : nl->sym->name, sym->name, &sym->declared_at))
18649 : return false;
18650 :
18651 2204 : if (is_non_constant_shape_array (nl->sym)
18652 2254 : && !gfc_notify_std (GFC_STD_F2003, "NAMELIST array object %qs "
18653 : "with nonconstant shape in namelist %qs at %L",
18654 50 : nl->sym->name, sym->name, &sym->declared_at))
18655 : return false;
18656 :
18657 2203 : if (nl->sym->ts.type == BT_CHARACTER
18658 605 : && (nl->sym->ts.u.cl->length == NULL
18659 566 : || !gfc_is_constant_expr (nl->sym->ts.u.cl->length))
18660 2285 : && !gfc_notify_std (GFC_STD_F2003, "NAMELIST object %qs with "
18661 : "nonconstant character length in "
18662 82 : "namelist %qs at %L", nl->sym->name,
18663 : sym->name, &sym->declared_at))
18664 : return false;
18665 :
18666 : }
18667 :
18668 : /* Reject PRIVATE objects in a PUBLIC namelist. */
18669 876 : if (gfc_check_symbol_access (sym))
18670 : {
18671 3063 : for (nl = sym->namelist; nl; nl = nl->next)
18672 : {
18673 2200 : if (!nl->sym->attr.use_assoc
18674 4104 : && !is_sym_host_assoc (nl->sym, sym->ns)
18675 4230 : && !gfc_check_symbol_access (nl->sym))
18676 : {
18677 2 : gfc_error ("NAMELIST object %qs was declared PRIVATE and "
18678 : "cannot be member of PUBLIC namelist %qs at %L",
18679 2 : nl->sym->name, sym->name, &sym->declared_at);
18680 2 : return false;
18681 : }
18682 :
18683 2198 : if (nl->sym->ts.type == BT_DERIVED
18684 478 : && (nl->sym->ts.u.derived->attr.alloc_comp
18685 476 : || nl->sym->ts.u.derived->attr.pointer_comp))
18686 : {
18687 5 : if (!gfc_notify_std (GFC_STD_F2003, "NAMELIST object %qs in "
18688 : "namelist %qs at %L with ALLOCATABLE "
18689 : "or POINTER components", nl->sym->name,
18690 : sym->name, &sym->declared_at))
18691 : return false;
18692 : return true;
18693 : }
18694 :
18695 : /* Types with private components that came here by USE-association. */
18696 2193 : if (nl->sym->ts.type == BT_DERIVED
18697 2193 : && derived_inaccessible (nl->sym->ts.u.derived))
18698 : {
18699 6 : gfc_error ("NAMELIST object %qs has use-associated PRIVATE "
18700 : "components and cannot be member of namelist %qs at %L",
18701 : nl->sym->name, sym->name, &sym->declared_at);
18702 6 : return false;
18703 : }
18704 :
18705 : /* Types with private components that are defined in the same module. */
18706 2187 : if (nl->sym->ts.type == BT_DERIVED
18707 934 : && !is_sym_host_assoc (nl->sym->ts.u.derived, sym->ns)
18708 2477 : && nl->sym->ts.u.derived->attr.private_comp)
18709 : {
18710 0 : gfc_error ("NAMELIST object %qs has PRIVATE components and "
18711 : "cannot be a member of PUBLIC namelist %qs at %L",
18712 : nl->sym->name, sym->name, &sym->declared_at);
18713 0 : return false;
18714 : }
18715 : }
18716 : }
18717 :
18718 :
18719 : /* 14.1.2 A module or internal procedure represent local entities
18720 : of the same type as a namelist member and so are not allowed. */
18721 3047 : for (nl = sym->namelist; nl; nl = nl->next)
18722 : {
18723 2187 : if (nl->sym->ts.kind != 0 && nl->sym->attr.flavor == FL_VARIABLE)
18724 1616 : continue;
18725 :
18726 571 : if (nl->sym->attr.function && nl->sym == nl->sym->result)
18727 7 : if ((nl->sym == sym->ns->proc_name)
18728 1 : ||
18729 1 : (sym->ns->parent && nl->sym == sym->ns->parent->proc_name))
18730 6 : continue;
18731 :
18732 565 : nlsym = NULL;
18733 565 : if (nl->sym->name)
18734 565 : gfc_find_symbol (nl->sym->name, sym->ns, 1, &nlsym);
18735 565 : if (nlsym && nlsym->attr.flavor == FL_PROCEDURE)
18736 : {
18737 3 : gfc_error ("PROCEDURE attribute conflicts with NAMELIST "
18738 : "attribute in %qs at %L", nlsym->name,
18739 : &sym->declared_at);
18740 3 : return false;
18741 : }
18742 : }
18743 :
18744 : return true;
18745 : }
18746 :
18747 :
18748 : static bool
18749 418360 : resolve_fl_parameter (gfc_symbol *sym)
18750 : {
18751 : /* A parameter array's shape needs to be constant. */
18752 418360 : if (sym->as != NULL
18753 418360 : && (sym->as->type == AS_DEFERRED
18754 6395 : || is_non_constant_shape_array (sym)))
18755 : {
18756 17 : gfc_error ("Parameter array %qs at %L cannot be automatic "
18757 : "or of deferred shape", sym->name, &sym->declared_at);
18758 17 : return false;
18759 : }
18760 :
18761 : /* Constraints on deferred type parameter. */
18762 418343 : if (!deferred_requirements (sym))
18763 : return false;
18764 :
18765 : /* Make sure a parameter that has been implicitly typed still
18766 : matches the implicit type, since PARAMETER statements can precede
18767 : IMPLICIT statements. */
18768 418342 : if (sym->attr.implicit_type
18769 419055 : && !gfc_compare_types (&sym->ts, gfc_get_default_type (sym->name,
18770 713 : sym->ns)))
18771 : {
18772 0 : gfc_error ("Implicitly typed PARAMETER %qs at %L doesn't match a "
18773 : "later IMPLICIT type", sym->name, &sym->declared_at);
18774 0 : return false;
18775 : }
18776 :
18777 : /* Make sure the types of derived parameters are consistent. This
18778 : type checking is deferred until resolution because the type may
18779 : refer to a derived type from the host. */
18780 418342 : if (sym->ts.type == BT_DERIVED
18781 418342 : && !gfc_compare_types (&sym->ts, &sym->value->ts))
18782 : {
18783 0 : gfc_error ("Incompatible derived type in PARAMETER at %L",
18784 0 : &sym->value->where);
18785 0 : return false;
18786 : }
18787 :
18788 : /* F03:C509,C514. */
18789 418342 : if (sym->ts.type == BT_CLASS)
18790 : {
18791 0 : gfc_error ("CLASS variable %qs at %L cannot have the PARAMETER attribute",
18792 : sym->name, &sym->declared_at);
18793 0 : return false;
18794 : }
18795 :
18796 : /* Some programmers can have a typo when using an implied-do loop to
18797 : initialize an array constant. For example,
18798 : INTEGER I,J
18799 : INTEGER, PARAMETER :: A(3) = [(I, I = 1, 3)] ! OK
18800 : INTEGER, PARAMETER :: B(3) = [(A(J), I = 1, 3)] ! Not OK, J undefined
18801 : This check catches the typo. */
18802 418342 : if (sym->attr.dimension
18803 6388 : && sym->value && sym->value->expr_type == EXPR_ARRAY
18804 424724 : && !gfc_is_constant_expr (sym->value))
18805 : {
18806 : /* PR fortran/117070 argues a nonconstant proc pointer can appear in
18807 : the array constructor of a parameter. This seems inconsistent with
18808 : the concept of a parameter. TODO: Needs an interpretation. */
18809 20 : if (sym->value->ts.type == BT_DERIVED
18810 18 : && sym->value->ts.u.derived
18811 18 : && sym->value->ts.u.derived->attr.proc_pointer_comp)
18812 : return true;
18813 2 : gfc_error ("Expecting constant expression near %L", &sym->value->where);
18814 2 : return false;
18815 : }
18816 :
18817 : return true;
18818 : }
18819 :
18820 :
18821 : /* Called by resolve_symbol to check PDTs. */
18822 :
18823 : static void
18824 2260 : resolve_pdt (gfc_symbol* sym)
18825 : {
18826 2260 : gfc_symbol *derived = NULL;
18827 2260 : gfc_actual_arglist *param;
18828 2260 : gfc_component *c;
18829 2260 : bool const_len_exprs = true;
18830 2260 : bool assumed_len_exprs = false;
18831 2260 : symbol_attribute *attr;
18832 :
18833 2260 : if (sym->ts.type == BT_DERIVED)
18834 : {
18835 1949 : derived = sym->ts.u.derived;
18836 1949 : attr = &(sym->attr);
18837 : }
18838 311 : else if (sym->ts.type == BT_CLASS)
18839 : {
18840 311 : derived = CLASS_DATA (sym)->ts.u.derived;
18841 311 : attr = &(CLASS_DATA (sym)->attr);
18842 : }
18843 : else
18844 0 : gcc_unreachable ();
18845 :
18846 2260 : gcc_assert (derived->attr.pdt_type);
18847 :
18848 : /* Now that the result symbol has been corrected for these module
18849 : procedures, we can transfer the param_list from the proc sym. */
18850 2260 : if (sym->abr_modproc_decl && sym->result && sym != sym->result)
18851 : {
18852 18 : sym->result->param_list = sym->param_list;
18853 18 : sym->param_list = NULL;
18854 : }
18855 :
18856 5355 : for (param = sym->param_list; param; param = param->next)
18857 : {
18858 3095 : c = gfc_find_component (derived, param->name, false, true, NULL);
18859 3095 : gcc_assert (c);
18860 3095 : if (c->attr.pdt_kind)
18861 1408 : continue;
18862 :
18863 1076 : if (param->expr && !gfc_is_constant_expr (param->expr)
18864 1921 : && c->attr.pdt_len)
18865 : const_len_exprs = false;
18866 1453 : else if (param->spec_type == SPEC_ASSUMED)
18867 579 : assumed_len_exprs = true;
18868 :
18869 1687 : if (param->spec_type == SPEC_DEFERRED && !attr->allocatable
18870 18 : && ((sym->ts.type == BT_DERIVED && !attr->pointer)
18871 16 : || (sym->ts.type == BT_CLASS && !attr->class_pointer)))
18872 3 : gfc_error ("Entity %qs at %L has a deferred LEN "
18873 : "parameter %qs and requires either the POINTER "
18874 : "or ALLOCATABLE attribute",
18875 : sym->name, &sym->declared_at,
18876 : param->name);
18877 : }
18878 :
18879 2260 : if (!const_len_exprs
18880 228 : && (sym->ns->proc_name->attr.is_main_program
18881 227 : || sym->ns->proc_name->attr.flavor == FL_MODULE
18882 226 : || sym->attr.save != SAVE_NONE))
18883 2 : gfc_error ("The AUTOMATIC object %qs at %L must not have the "
18884 : "SAVE attribute or be a variable declared in the "
18885 : "main program, a module or a submodule(F08/C513)",
18886 : sym->name, &sym->declared_at);
18887 :
18888 2260 : if (assumed_len_exprs && !(sym->attr.dummy
18889 1 : || sym->attr.select_type_temporary || sym->attr.associate_var))
18890 1 : gfc_error ("The object %qs at %L with ASSUMED type parameters "
18891 : "must be a dummy or a SELECT TYPE selector(F08/4.2)",
18892 : sym->name, &sym->declared_at);
18893 2260 : }
18894 :
18895 :
18896 : /* Resolve the symbol's array spec. */
18897 :
18898 : static bool
18899 1819211 : resolve_symbol_array_spec (gfc_symbol *sym, int check_constant)
18900 : {
18901 1819211 : gfc_namespace *orig_current_ns = gfc_current_ns;
18902 1819211 : gfc_current_ns = gfc_get_spec_ns (sym);
18903 :
18904 1819211 : bool saved_specification_expr = specification_expr;
18905 1819211 : gfc_symbol *saved_specification_expr_symbol = specification_expr_symbol;
18906 1819211 : specification_expr = true;
18907 1819211 : specification_expr_symbol = sym;
18908 :
18909 1819211 : bool result = gfc_resolve_array_spec (sym->as, check_constant);
18910 :
18911 1819211 : specification_expr = saved_specification_expr;
18912 1819211 : specification_expr_symbol = saved_specification_expr_symbol;
18913 1819211 : gfc_current_ns = orig_current_ns;
18914 :
18915 1819211 : return result;
18916 : }
18917 :
18918 :
18919 : /* Do anything necessary to resolve a symbol. Right now, we just
18920 : assume that an otherwise unknown symbol is a variable. This sort
18921 : of thing commonly happens for symbols in module. */
18922 :
18923 : static void
18924 1988680 : resolve_symbol (gfc_symbol *sym)
18925 : {
18926 1988680 : int check_constant, mp_flag;
18927 1988680 : gfc_symtree *symtree;
18928 1988680 : gfc_symtree *this_symtree;
18929 1988680 : gfc_namespace *ns;
18930 1988680 : gfc_component *c;
18931 1988680 : symbol_attribute class_attr;
18932 1988680 : gfc_array_spec *as;
18933 1988680 : bool declared_has_coarray_comp = false;
18934 :
18935 1988680 : if (sym->resolve_symbol_called >= 1)
18936 201119 : return;
18937 1896566 : sym->resolve_symbol_called = 1;
18938 :
18939 : /* No symbol will ever have union type; only components can be unions.
18940 : Union type declaration symbols have type BT_UNKNOWN but flavor FL_UNION
18941 : (just like derived type declaration symbols have flavor FL_DERIVED). */
18942 1896566 : gcc_assert (sym->ts.type != BT_UNION);
18943 :
18944 : /* Coarrayed polymorphic objects with allocatable or pointer components are
18945 : yet unsupported for -fcoarray=lib. */
18946 1896566 : if (flag_coarray == GFC_FCOARRAY_LIB && sym->ts.type == BT_CLASS
18947 116 : && sym->ts.u.derived && CLASS_DATA (sym)
18948 116 : && CLASS_DATA (sym)->attr.codimension
18949 98 : && CLASS_DATA (sym)->ts.u.derived
18950 97 : && (CLASS_DATA (sym)->ts.u.derived->attr.alloc_comp
18951 94 : || CLASS_DATA (sym)->ts.u.derived->attr.pointer_comp))
18952 : {
18953 6 : gfc_error ("Sorry, allocatable/pointer components in polymorphic (CLASS) "
18954 : "type coarrays at %L are unsupported", &sym->declared_at);
18955 6 : return;
18956 : }
18957 :
18958 1896560 : if (sym->attr.artificial)
18959 : return;
18960 :
18961 1790407 : if (sym->attr.unlimited_polymorphic)
18962 : return;
18963 :
18964 1788826 : if (UNLIKELY (flag_openmp && strcmp (sym->name, "omp_all_memory") == 0))
18965 : {
18966 4 : gfc_error ("%<omp_all_memory%>, declared at %L, may only be used in "
18967 : "the OpenMP DEPEND clause", &sym->declared_at);
18968 4 : return;
18969 : }
18970 :
18971 1788822 : if (sym->attr.flavor == FL_UNKNOWN
18972 1766928 : || (sym->attr.flavor == FL_PROCEDURE && !sym->attr.intrinsic
18973 474563 : && !sym->attr.generic && !sym->attr.external
18974 187254 : && sym->attr.if_source == IFSRC_UNKNOWN
18975 84841 : && sym->ts.type == BT_UNKNOWN))
18976 : {
18977 : /* A symbol in a common block might not have been resolved yet properly.
18978 : Do not try to find an interface with the same name. */
18979 98029 : if (sym->attr.flavor == FL_UNKNOWN && !sym->attr.intrinsic
18980 21890 : && !sym->attr.generic && !sym->attr.external
18981 21839 : && sym->attr.in_common)
18982 2595 : goto skip_interfaces;
18983 :
18984 : /* If we find that a flavorless symbol is an interface in one of the
18985 : parent namespaces, find its symtree in this namespace, free the
18986 : symbol and set the symtree to point to the interface symbol. */
18987 136719 : for (ns = gfc_current_ns->parent; ns; ns = ns->parent)
18988 : {
18989 42007 : symtree = gfc_find_symtree (ns->sym_root, sym->name);
18990 42007 : if (symtree && (symtree->n.sym->generic ||
18991 821 : (symtree->n.sym->attr.flavor == FL_PROCEDURE
18992 707 : && sym->ns->construct_entities)))
18993 : {
18994 730 : this_symtree = gfc_find_symtree (gfc_current_ns->sym_root,
18995 : sym->name);
18996 730 : if (this_symtree->n.sym == sym)
18997 : {
18998 722 : symtree->n.sym->refs++;
18999 722 : gfc_release_symbol (sym);
19000 722 : this_symtree->n.sym = symtree->n.sym;
19001 722 : return;
19002 : }
19003 : }
19004 : }
19005 :
19006 94712 : skip_interfaces:
19007 : /* Otherwise give it a flavor according to such attributes as
19008 : it has. */
19009 97307 : if (sym->attr.flavor == FL_UNKNOWN && sym->attr.external == 0
19010 21709 : && sym->attr.intrinsic == 0)
19011 21705 : sym->attr.flavor = FL_VARIABLE;
19012 75602 : else if (sym->attr.flavor == FL_UNKNOWN)
19013 : {
19014 55 : sym->attr.flavor = FL_PROCEDURE;
19015 55 : if (sym->attr.dimension)
19016 0 : sym->attr.function = 1;
19017 : }
19018 : }
19019 :
19020 1788100 : if (sym->attr.external && sym->ts.type != BT_UNKNOWN && !sym->attr.function)
19021 2385 : gfc_add_function (&sym->attr, sym->name, &sym->declared_at);
19022 :
19023 1542 : if (sym->attr.procedure && sym->attr.if_source != IFSRC_DECL
19024 1789642 : && !resolve_procedure_interface (sym))
19025 : return;
19026 :
19027 1788089 : if (sym->attr.is_protected && !sym->attr.proc_pointer
19028 130 : && (sym->attr.procedure || sym->attr.external))
19029 : {
19030 0 : if (sym->attr.external)
19031 0 : gfc_error ("PROTECTED attribute conflicts with EXTERNAL attribute "
19032 : "at %L", &sym->declared_at);
19033 : else
19034 0 : gfc_error ("PROCEDURE attribute conflicts with PROTECTED attribute "
19035 : "at %L", &sym->declared_at);
19036 :
19037 : return;
19038 : }
19039 :
19040 : /* Ensure that variables of derived or class type having a finalizer are
19041 : marked used even when the variable is not used anything else in the scope.
19042 : This fixes PR118730. */
19043 691228 : if (sym->attr.flavor == FL_VARIABLE && !sym->attr.referenced
19044 478104 : && (sym->ts.type == BT_DERIVED || sym->ts.type == BT_CLASS)
19045 1839406 : && gfc_may_be_finalized (sym->ts))
19046 9032 : gfc_set_sym_referenced (sym);
19047 :
19048 1788089 : if (sym->attr.flavor == FL_DERIVED && !resolve_fl_derived (sym))
19049 : return;
19050 :
19051 1787944 : else if ((sym->attr.flavor == FL_STRUCT || sym->attr.flavor == FL_UNION)
19052 1787944 : && !resolve_fl_struct (sym))
19053 : return;
19054 :
19055 : /* Symbols that are module procedures with results (functions) have
19056 : the types and array specification copied for type checking in
19057 : procedures that call them, as well as for saving to a module
19058 : file. These symbols can't stand the scrutiny that their results
19059 : can. */
19060 1787944 : mp_flag = (sym->result != NULL && sym->result != sym);
19061 :
19062 : /* Make sure that the intrinsic is consistent with its internal
19063 : representation. This needs to be done before assigning a default
19064 : type to avoid spurious warnings. */
19065 1751438 : if (sym->attr.flavor != FL_MODULE && sym->attr.intrinsic
19066 1825565 : && !gfc_resolve_intrinsic (sym, &sym->declared_at))
19067 : return;
19068 :
19069 : /* Resolve associate names. */
19070 1787908 : if (sym->assoc)
19071 7380 : resolve_assoc_var (sym, true);
19072 :
19073 : /* Assign default type to symbols that need one and don't have one. */
19074 1787908 : if (sym->ts.type == BT_UNKNOWN)
19075 : {
19076 430868 : if (sym->attr.flavor == FL_VARIABLE || sym->attr.flavor == FL_PARAMETER)
19077 : {
19078 11855 : gfc_set_default_type (sym, 1, NULL);
19079 : }
19080 :
19081 279604 : if (sym->attr.flavor == FL_PROCEDURE && sym->attr.external
19082 67836 : && !sym->attr.function && !sym->attr.subroutine
19083 432541 : && gfc_get_default_type (sym->name, sym->ns)->type == BT_UNKNOWN)
19084 622 : gfc_add_subroutine (&sym->attr, sym->name, &sym->declared_at);
19085 :
19086 430868 : if (sym->attr.flavor == FL_PROCEDURE && sym->attr.function)
19087 : {
19088 : /* The specific case of an external procedure should emit an error
19089 : in the case that there is no implicit type. */
19090 108236 : if (!mp_flag)
19091 : {
19092 101805 : if (!sym->attr.mixed_entry_master)
19093 101697 : gfc_set_default_type (sym, sym->attr.external, NULL);
19094 : }
19095 : else
19096 : {
19097 : /* Result may be in another namespace. */
19098 6431 : resolve_symbol (sym->result);
19099 :
19100 6431 : if (!sym->result->attr.proc_pointer)
19101 : {
19102 6245 : sym->ts = sym->result->ts;
19103 6245 : sym->as = gfc_copy_array_spec (sym->result->as);
19104 6245 : sym->attr.dimension = sym->result->attr.dimension;
19105 6245 : sym->attr.codimension = sym->result->attr.codimension;
19106 6245 : sym->attr.pointer = sym->result->attr.pointer;
19107 6245 : sym->attr.allocatable = sym->result->attr.allocatable;
19108 6245 : sym->attr.contiguous = sym->result->attr.contiguous;
19109 : }
19110 : }
19111 : }
19112 : }
19113 1357040 : else if (mp_flag && sym->attr.flavor == FL_PROCEDURE && sym->attr.function)
19114 31647 : resolve_symbol_array_spec (sym->result, false);
19115 :
19116 : /* For a CLASS-valued function with a result variable, affirm that it has
19117 : been resolved also when looking at the symbol 'sym'. */
19118 462515 : if (mp_flag && sym->ts.type == BT_CLASS && sym->result->attr.class_ok)
19119 770 : sym->attr.class_ok = sym->result->attr.class_ok;
19120 :
19121 1787908 : if (sym->ts.type == BT_CLASS && sym->attr.class_ok && sym->ts.u.derived
19122 20626 : && CLASS_DATA (sym))
19123 : {
19124 20626 : as = CLASS_DATA (sym)->as;
19125 20626 : class_attr = CLASS_DATA (sym)->attr;
19126 20626 : class_attr.pointer = class_attr.class_pointer;
19127 20626 : declared_has_coarray_comp = CLASS_DATA (sym)->ts.u.derived
19128 20626 : && CLASS_DATA (sym)->ts.u.derived->attr.coarray_comp;
19129 : }
19130 : else
19131 : {
19132 1767282 : class_attr = sym->attr;
19133 1767282 : as = sym->as;
19134 : }
19135 :
19136 : /* F2008, C530. */
19137 1787908 : if (sym->attr.contiguous
19138 8568 : && !sym->attr.associate_var
19139 8566 : && (!class_attr.dimension
19140 8563 : || (as->type != AS_ASSUMED_SHAPE && as->type != AS_ASSUMED_RANK
19141 144 : && !class_attr.pointer)))
19142 : {
19143 7 : gfc_error ("%qs at %L has the CONTIGUOUS attribute but is not an "
19144 : "array pointer or an assumed-shape or assumed-rank array",
19145 : sym->name, &sym->declared_at);
19146 7 : return;
19147 : }
19148 :
19149 : /* Assumed size arrays and assumed shape arrays must be dummy
19150 : arguments. Array-spec's of implied-shape should have been resolved to
19151 : AS_EXPLICIT already. */
19152 :
19153 1779482 : if (as)
19154 : {
19155 : /* If AS_IMPLIED_SHAPE makes it to here, it must be a bad
19156 : specification expression. */
19157 154273 : if (as->type == AS_IMPLIED_SHAPE)
19158 : {
19159 : int i;
19160 1 : for (i=0; i<as->rank; i++)
19161 : {
19162 1 : if (as->lower[i] != NULL && as->upper[i] == NULL)
19163 : {
19164 1 : gfc_error ("Bad specification for assumed size array at %L",
19165 : &as->lower[i]->where);
19166 1 : return;
19167 : }
19168 : }
19169 0 : gcc_unreachable();
19170 : }
19171 :
19172 154272 : if (((as->type == AS_ASSUMED_SIZE && !as->cp_was_assumed)
19173 118944 : || as->type == AS_ASSUMED_SHAPE)
19174 48000 : && !sym->attr.dummy && !sym->attr.select_type_temporary
19175 9 : && !sym->attr.associate_var)
19176 : {
19177 7 : if (as->type == AS_ASSUMED_SIZE)
19178 7 : gfc_error ("Assumed size array at %L must be a dummy argument",
19179 : &sym->declared_at);
19180 : else
19181 0 : gfc_error ("Assumed shape array at %L must be a dummy argument",
19182 : &sym->declared_at);
19183 : return;
19184 : }
19185 : /* TS 29113, C535a. */
19186 154265 : if (as->type == AS_ASSUMED_RANK && !sym->attr.dummy
19187 60 : && !sym->attr.select_type_temporary
19188 60 : && !(cs_base && cs_base->current
19189 45 : && (cs_base->current->op == EXEC_SELECT_RANK
19190 3 : || ((gfc_option.allow_std & GFC_STD_F202Y)
19191 0 : && cs_base->current->op == EXEC_BLOCK))))
19192 : {
19193 18 : gfc_error ("Assumed-rank array at %L must be a dummy argument",
19194 : &sym->declared_at);
19195 18 : return;
19196 : }
19197 154247 : if (as->type == AS_ASSUMED_RANK
19198 27385 : && (sym->attr.codimension || sym->attr.value))
19199 : {
19200 5 : gfc_error ("Assumed-rank array at %L may not have the VALUE or "
19201 : "CODIMENSION attribute", &sym->declared_at);
19202 5 : return;
19203 : }
19204 :
19205 : /* F2008, C557 (F2018, C862; F2023, C867). Assumed-shape and
19206 : explicit-shape array dummies may have the VALUE attribute, but
19207 : assumed-size arrays may not. */
19208 154242 : if (as->type == AS_ASSUMED_SIZE && sym->attr.value)
19209 : {
19210 1 : gfc_error ("Assumed-size array %qs at %L may not have the VALUE "
19211 : "attribute", sym->name, &sym->declared_at);
19212 1 : return;
19213 : }
19214 154241 : else if (sym->attr.value && sym->attr.dummy
19215 144 : && (as->type == AS_EXPLICIT || as->type == AS_ASSUMED_SHAPE))
19216 : {
19217 144 : if (!gfc_notify_std (GFC_STD_F2008, "Array dummy argument %qs at "
19218 : "%L with VALUE attribute", sym->name,
19219 : &sym->declared_at))
19220 : return;
19221 :
19222 : /* F2023, 18.3.6 (4): only a scalar VALUE dummy is interoperable
19223 : with a formal parameter of the C prototype. */
19224 143 : if (sym->ns->proc_name && sym->ns->proc_name->attr.is_bind_c)
19225 : {
19226 2 : gfc_error ("Array dummy argument %qs at %L with VALUE attribute "
19227 : "not allowed in BIND(C) procedure %qs", sym->name,
19228 : &sym->declared_at, sym->ns->proc_name->name);
19229 2 : return;
19230 : }
19231 :
19232 141 : if (sym->ts.type == BT_CLASS)
19233 : {
19234 1 : gfc_error ("Sorry, polymorphic array dummy argument %qs at %L "
19235 : "with VALUE attribute is not yet implemented",
19236 : sym->name, &sym->declared_at);
19237 1 : return;
19238 : }
19239 : }
19240 : }
19241 :
19242 : /* Make sure symbols with known intent or optional are really dummy
19243 : variable. Because of ENTRY statement, this has to be deferred
19244 : until resolution time. */
19245 :
19246 1787865 : if (!sym->attr.dummy
19247 1284747 : && (sym->attr.optional || sym->attr.intent != INTENT_UNKNOWN))
19248 : {
19249 2 : gfc_error ("Symbol at %L is not a DUMMY variable", &sym->declared_at);
19250 2 : return;
19251 : }
19252 :
19253 1787863 : if (sym->attr.value && !sym->attr.dummy)
19254 : {
19255 2 : gfc_error ("%qs at %L cannot have the VALUE attribute because "
19256 : "it is not a dummy argument", sym->name, &sym->declared_at);
19257 2 : return;
19258 : }
19259 :
19260 1787861 : if (sym->attr.value && sym->ts.type == BT_CHARACTER)
19261 : {
19262 707 : gfc_charlen *cl = sym->ts.u.cl;
19263 707 : if (!cl)
19264 : {
19265 0 : gfc_error ("Character dummy variable %qs at %L with VALUE "
19266 : "attribute must have a length specification",
19267 : sym->name, &sym->declared_at);
19268 0 : return;
19269 : }
19270 :
19271 : /* C interoperable character dummies must have length one. */
19272 707 : if (sym->ts.is_c_interop
19273 394 : && (!cl->length
19274 393 : || cl->length->expr_type != EXPR_CONSTANT
19275 393 : || mpz_cmp_si (cl->length->value.integer, 1) != 0))
19276 : {
19277 2 : gfc_error ("C interoperable character dummy variable %qs at %L "
19278 : "with VALUE attribute must have length one",
19279 : sym->name, &sym->declared_at);
19280 2 : return;
19281 : }
19282 :
19283 : /* Assumed-length character dummy with VALUE, valid since F2008. */
19284 705 : if (!cl->length
19285 705 : && !gfc_notify_std (GFC_STD_F2008, "Assumed-length character "
19286 : "dummy variable %qs at %L with VALUE attribute",
19287 : sym->name, &sym->declared_at))
19288 : return;
19289 :
19290 : /* Likewise for a specified but non-constant length. */
19291 655 : if (cl->length && cl->length->expr_type != EXPR_CONSTANT
19292 727 : && !gfc_notify_std (GFC_STD_F2008, "Character dummy variable "
19293 : "%qs at %L with VALUE attribute and "
19294 : "non-constant length",
19295 24 : sym->name, &sym->declared_at))
19296 : return;
19297 : }
19298 :
19299 1787857 : if (sym->ts.type == BT_DERIVED && !sym->attr.is_iso_c
19300 128512 : && sym->ts.u.derived->attr.generic)
19301 : {
19302 20 : sym->ts.u.derived = gfc_find_dt_in_generic (sym->ts.u.derived);
19303 20 : if (!sym->ts.u.derived)
19304 : {
19305 0 : gfc_error ("The derived type %qs at %L is of type %qs, "
19306 : "which has not been defined", sym->name,
19307 : &sym->declared_at, sym->ts.u.derived->name);
19308 0 : sym->ts.type = BT_UNKNOWN;
19309 0 : return;
19310 : }
19311 : }
19312 :
19313 : /* Use the same constraints as TYPE(*), except for the type check
19314 : and that only scalars and assumed-size arrays are permitted. */
19315 1787857 : if (sym->attr.ext_attr & (1 << EXT_ATTR_NO_ARG_CHECK))
19316 : {
19317 14556 : if (!sym->attr.dummy)
19318 : {
19319 1 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute shall be "
19320 : "a dummy argument", sym->name, &sym->declared_at);
19321 1 : return;
19322 : }
19323 :
19324 14555 : if (sym->ts.type != BT_ASSUMED && sym->ts.type != BT_INTEGER
19325 8 : && sym->ts.type != BT_REAL && sym->ts.type != BT_LOGICAL
19326 0 : && sym->ts.type != BT_COMPLEX)
19327 : {
19328 0 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute shall be "
19329 : "of type TYPE(*) or of an numeric intrinsic type",
19330 : sym->name, &sym->declared_at);
19331 0 : return;
19332 : }
19333 :
19334 14555 : if (sym->attr.allocatable || sym->attr.codimension
19335 14553 : || sym->attr.pointer || sym->attr.value)
19336 : {
19337 4 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute may not "
19338 : "have the ALLOCATABLE, CODIMENSION, POINTER or VALUE "
19339 : "attribute", sym->name, &sym->declared_at);
19340 4 : return;
19341 : }
19342 :
19343 14551 : if (sym->attr.intent == INTENT_OUT)
19344 : {
19345 0 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute may not "
19346 : "have the INTENT(OUT) attribute",
19347 : sym->name, &sym->declared_at);
19348 0 : return;
19349 : }
19350 14551 : if (sym->attr.dimension && sym->as->type != AS_ASSUMED_SIZE)
19351 : {
19352 1 : gfc_error ("Variable %s at %L with NO_ARG_CHECK attribute shall "
19353 : "either be a scalar or an assumed-size array",
19354 : sym->name, &sym->declared_at);
19355 1 : return;
19356 : }
19357 :
19358 : /* Set the type to TYPE(*) and add a dimension(*) to ensure
19359 : NO_ARG_CHECK is correctly handled in trans*.c, e.g. with
19360 : packing. */
19361 14550 : sym->ts.type = BT_ASSUMED;
19362 14550 : sym->as = gfc_get_array_spec ();
19363 14550 : sym->as->type = AS_ASSUMED_SIZE;
19364 14550 : sym->as->rank = 1;
19365 14550 : sym->as->lower[0] = gfc_get_int_expr (gfc_default_integer_kind, NULL, 1);
19366 : }
19367 1773301 : else if (sym->ts.type == BT_ASSUMED)
19368 : {
19369 : /* TS 29113, C407a. */
19370 12350 : if (!sym->attr.dummy)
19371 : {
19372 7 : gfc_error ("Assumed type of variable %s at %L is only permitted "
19373 : "for dummy variables", sym->name, &sym->declared_at);
19374 7 : return;
19375 : }
19376 12343 : if (sym->attr.allocatable || sym->attr.codimension
19377 12339 : || sym->attr.pointer || sym->attr.value)
19378 : {
19379 8 : gfc_error ("Assumed-type variable %s at %L may not have the "
19380 : "ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute",
19381 : sym->name, &sym->declared_at);
19382 8 : return;
19383 : }
19384 12335 : if (sym->attr.intent == INTENT_OUT)
19385 : {
19386 2 : gfc_error ("Assumed-type variable %s at %L may not have the "
19387 : "INTENT(OUT) attribute",
19388 : sym->name, &sym->declared_at);
19389 2 : return;
19390 : }
19391 12333 : if (sym->attr.dimension && sym->as->type == AS_EXPLICIT)
19392 : {
19393 3 : gfc_error ("Assumed-type variable %s at %L shall not be an "
19394 : "explicit-shape array", sym->name, &sym->declared_at);
19395 3 : return;
19396 : }
19397 : }
19398 :
19399 : /* If the symbol is marked as bind(c), that it is declared at module level
19400 : scope and verify its type and kind. Do not do the latter for symbols
19401 : that are implicitly typed because that is handled in
19402 : gfc_set_default_type. Handle dummy arguments and procedure definitions
19403 : separately. Also, anything that is use associated is not handled here
19404 : but instead is handled in the module it is declared in. Finally, derived
19405 : type definitions are allowed to be BIND(C) since that only implies that
19406 : they're interoperable, and they are checked fully for interoperability
19407 : when a variable is declared of that type. */
19408 1787831 : if (sym->attr.is_bind_c && sym->attr.use_assoc == 0
19409 8048 : && sym->attr.dummy == 0 && sym->attr.flavor != FL_PROCEDURE
19410 568 : && sym->attr.flavor != FL_DERIVED)
19411 : {
19412 168 : bool t = true;
19413 :
19414 : /* First, make sure the variable is declared at the
19415 : module-level scope (J3/04-007, Section 15.3). */
19416 168 : if (!(sym->ns->proc_name && sym->ns->proc_name->attr.flavor == FL_MODULE)
19417 7 : && !sym->attr.in_common)
19418 : {
19419 6 : gfc_error ("Variable %qs at %L cannot be BIND(C) because it "
19420 : "is neither a COMMON block nor declared at the "
19421 : "module level scope", sym->name, &(sym->declared_at));
19422 6 : t = false;
19423 : }
19424 162 : else if (sym->ts.type == BT_CHARACTER
19425 162 : && (sym->ts.u.cl == NULL || sym->ts.u.cl->length == NULL
19426 1 : || !gfc_is_constant_expr (sym->ts.u.cl->length)
19427 1 : || mpz_cmp_si (sym->ts.u.cl->length->value.integer, 1) != 0))
19428 : {
19429 1 : gfc_error ("BIND(C) Variable %qs at %L must have length one",
19430 1 : sym->name, &sym->declared_at);
19431 1 : t = false;
19432 : }
19433 161 : else if (sym->common_head != NULL && sym->attr.implicit_type == 0)
19434 : {
19435 1 : t = verify_com_block_vars_c_interop (sym->common_head);
19436 : }
19437 160 : else if (sym->attr.implicit_type == 0)
19438 : {
19439 : /* If type() declaration, we need to verify that the components
19440 : of the given type are all C interoperable, etc. */
19441 158 : if (sym->ts.type == BT_DERIVED &&
19442 24 : sym->ts.u.derived->attr.is_c_interop != 1)
19443 : {
19444 : /* Make sure the user marked the derived type as BIND(C). If
19445 : not, call the verify routine. This could print an error
19446 : for the derived type more than once if multiple variables
19447 : of that type are declared. */
19448 14 : if (sym->ts.u.derived->attr.is_bind_c != 1)
19449 1 : verify_bind_c_derived_type (sym->ts.u.derived);
19450 158 : t = false;
19451 : }
19452 :
19453 : /* Verify the variable itself as C interoperable if it
19454 : is BIND(C). It is not possible for this to succeed if
19455 : the verify_bind_c_derived_type failed, so don't have to handle
19456 : any error returned by verify_bind_c_derived_type. */
19457 158 : t = verify_bind_c_sym (sym, &(sym->ts), sym->attr.in_common,
19458 158 : sym->common_block);
19459 : }
19460 :
19461 166 : if (!t)
19462 : {
19463 : /* clear the is_bind_c flag to prevent reporting errors more than
19464 : once if something failed. */
19465 10 : sym->attr.is_bind_c = 0;
19466 10 : return;
19467 : }
19468 : }
19469 :
19470 : /* If a derived type symbol has reached this point, without its
19471 : type being declared, we have an error. Notice that most
19472 : conditions that produce undefined derived types have already
19473 : been dealt with. However, the likes of:
19474 : implicit type(t) (t) ..... call foo (t) will get us here if
19475 : the type is not declared in the scope of the implicit
19476 : statement. Change the type to BT_UNKNOWN, both because it is so
19477 : and to prevent an ICE. */
19478 1787821 : if (sym->ts.type == BT_DERIVED && !sym->attr.is_iso_c
19479 128510 : && sym->ts.u.derived->components == NULL
19480 1195 : && !sym->ts.u.derived->attr.zero_comp)
19481 : {
19482 3 : gfc_error ("The derived type %qs at %L is of type %qs, "
19483 : "which has not been defined", sym->name,
19484 : &sym->declared_at, sym->ts.u.derived->name);
19485 3 : sym->ts.type = BT_UNKNOWN;
19486 3 : return;
19487 : }
19488 :
19489 : /* Make sure that the derived type has been resolved and that the
19490 : derived type is visible in the symbol's namespace, if it is a
19491 : module function and is not PRIVATE. */
19492 1787818 : if (sym->ts.type == BT_DERIVED
19493 135669 : && sym->ts.u.derived->attr.use_assoc
19494 116721 : && sym->ns->proc_name
19495 116713 : && sym->ns->proc_name->attr.flavor == FL_MODULE
19496 1793801 : && !resolve_fl_derived (sym->ts.u.derived))
19497 : return;
19498 :
19499 : /* Unless the derived-type declaration is use associated, Fortran 95
19500 : does not allow public entries of private derived types.
19501 : See 4.4.1 (F95) and 4.5.1.1 (F2003); and related interpretation
19502 : 161 in 95-006r3. */
19503 1787818 : if (sym->ts.type == BT_DERIVED
19504 135669 : && sym->ns->proc_name && sym->ns->proc_name->attr.flavor == FL_MODULE
19505 8258 : && !sym->ts.u.derived->attr.use_assoc
19506 2275 : && gfc_check_symbol_access (sym)
19507 2062 : && !gfc_check_symbol_access (sym->ts.u.derived)
19508 1787832 : && !gfc_notify_std (GFC_STD_F2003, "PUBLIC %s %qs at %L of PRIVATE "
19509 : "derived type %qs",
19510 14 : (sym->attr.flavor == FL_PARAMETER)
19511 : ? "parameter" : "variable",
19512 : sym->name, &sym->declared_at,
19513 14 : sym->ts.u.derived->name))
19514 : return;
19515 :
19516 : /* F2008, C1302. */
19517 1787811 : if (sym->ts.type == BT_DERIVED
19518 135662 : && ((sym->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
19519 198 : && sym->ts.u.derived->intmod_sym_id == ISOFORTRAN_LOCK_TYPE)
19520 135631 : || sym->ts.u.derived->attr.lock_comp)
19521 44 : && !sym->attr.codimension && !sym->ts.u.derived->attr.coarray_comp)
19522 : {
19523 4 : gfc_error ("Variable %s at %L of type LOCK_TYPE or with subcomponent of "
19524 : "type LOCK_TYPE must be a coarray", sym->name,
19525 : &sym->declared_at);
19526 4 : return;
19527 : }
19528 :
19529 : /* TS18508, C702/C703. */
19530 1787807 : if (sym->ts.type == BT_DERIVED
19531 135658 : && ((sym->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
19532 197 : && sym->ts.u.derived->intmod_sym_id == ISOFORTRAN_EVENT_TYPE)
19533 135641 : || sym->ts.u.derived->attr.event_comp)
19534 17 : && !sym->attr.codimension && !sym->ts.u.derived->attr.coarray_comp)
19535 : {
19536 1 : gfc_error ("Variable %s at %L of type EVENT_TYPE or with subcomponent of "
19537 : "type EVENT_TYPE must be a coarray", sym->name,
19538 : &sym->declared_at);
19539 1 : return;
19540 : }
19541 :
19542 : /* An assumed-size array with INTENT(OUT) shall not be of a type for which
19543 : default initialization is defined (5.1.2.4.4). */
19544 1787806 : if (sym->ts.type == BT_DERIVED
19545 135657 : && sym->attr.dummy
19546 46428 : && sym->attr.intent == INTENT_OUT
19547 2441 : && sym->as
19548 418 : && sym->as->type == AS_ASSUMED_SIZE)
19549 : {
19550 1 : for (c = sym->ts.u.derived->components; c; c = c->next)
19551 : {
19552 1 : if (c->initializer)
19553 : {
19554 1 : gfc_error ("The INTENT(OUT) dummy argument %qs at %L is "
19555 : "ASSUMED SIZE and so cannot have a default initializer",
19556 : sym->name, &sym->declared_at);
19557 1 : return;
19558 : }
19559 : }
19560 : }
19561 :
19562 : /* F2008, C542. */
19563 1787805 : if (sym->ts.type == BT_DERIVED && sym->attr.dummy
19564 46427 : && sym->attr.intent == INTENT_OUT && sym->attr.lock_comp)
19565 : {
19566 0 : gfc_error ("Dummy argument %qs at %L of LOCK_TYPE shall not be "
19567 : "INTENT(OUT)", sym->name, &sym->declared_at);
19568 0 : return;
19569 : }
19570 :
19571 : /* TS18508. */
19572 1787805 : if (sym->ts.type == BT_DERIVED && sym->attr.dummy
19573 46427 : && sym->attr.intent == INTENT_OUT && sym->attr.event_comp)
19574 : {
19575 0 : gfc_error ("Dummy argument %qs at %L of EVENT_TYPE shall not be "
19576 : "INTENT(OUT)", sym->name, &sym->declared_at);
19577 0 : return;
19578 : }
19579 :
19580 : /* F2008, C525. */
19581 1787805 : if ((((sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.coarray_comp)
19582 1787692 : || (sym->ts.type == BT_CLASS && sym->attr.class_ok
19583 20628 : && sym->ts.u.derived && CLASS_DATA (sym)
19584 20623 : && CLASS_DATA (sym)->attr.coarray_comp))
19585 1787692 : || class_attr.codimension)
19586 2030 : && (sym->attr.result || sym->result == sym))
19587 : {
19588 8 : gfc_error ("Function result %qs at %L shall not be a coarray or have "
19589 : "a coarray component", sym->name, &sym->declared_at);
19590 8 : return;
19591 : }
19592 :
19593 : /* F2008, C524. */
19594 1787797 : if (sym->attr.codimension && sym->ts.type == BT_DERIVED
19595 438 : && sym->ts.u.derived->ts.is_iso_c)
19596 : {
19597 3 : gfc_error ("Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) "
19598 : "shall not be a coarray", sym->name, &sym->declared_at);
19599 3 : return;
19600 : }
19601 :
19602 : /* F2008, C525. */
19603 1787794 : if (((sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.coarray_comp)
19604 1787684 : || (sym->ts.type == BT_CLASS && sym->attr.class_ok
19605 20627 : && sym->ts.u.derived && CLASS_DATA (sym)
19606 20622 : && CLASS_DATA (sym)->attr.coarray_comp))
19607 110 : && (class_attr.codimension || class_attr.pointer || class_attr.dimension
19608 106 : || class_attr.allocatable))
19609 : {
19610 4 : gfc_error ("Variable %qs at %L with coarray component shall be a "
19611 : "nonpointer, nonallocatable scalar, which is not a coarray",
19612 : sym->name, &sym->declared_at);
19613 4 : return;
19614 : }
19615 :
19616 : /* F2008, C526. The function-result case was handled above. */
19617 1787790 : if (class_attr.codimension
19618 1909 : && !(class_attr.allocatable || sym->attr.dummy || sym->attr.save
19619 379 : || sym->attr.select_type_temporary
19620 303 : || sym->attr.associate_var
19621 285 : || (sym->ns->save_all && !sym->attr.automatic)
19622 285 : || sym->ns->proc_name->attr.flavor == FL_MODULE
19623 285 : || sym->ns->proc_name->attr.is_main_program
19624 5 : || sym->attr.function || sym->attr.result || sym->attr.use_assoc))
19625 : {
19626 4 : gfc_error ("Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE "
19627 : "nor a dummy argument", sym->name, &sym->declared_at);
19628 4 : return;
19629 : }
19630 : /* F2008, C528. */
19631 1787786 : else if (class_attr.codimension && !sym->attr.select_type_temporary
19632 1829 : && !class_attr.allocatable && as && as->cotype == AS_DEFERRED)
19633 : {
19634 7 : gfc_error ("Coarray variable %qs at %L shall not have codimensions with "
19635 : "deferred shape without allocatable", sym->name,
19636 : &sym->declared_at);
19637 7 : return;
19638 : }
19639 1787779 : else if (class_attr.codimension && class_attr.allocatable && as
19640 800 : && (as->cotype != AS_DEFERRED || as->type != AS_DEFERRED))
19641 : {
19642 9 : gfc_error ("Allocatable coarray variable %qs at %L must have "
19643 : "deferred shape", sym->name, &sym->declared_at);
19644 9 : return;
19645 : }
19646 :
19647 : /* F2008, C541. */
19648 1787770 : if ((((sym->ts.type == BT_DERIVED && sym->ts.u.derived->attr.coarray_comp)
19649 1787664 : || (sym->ts.type == BT_CLASS && sym->attr.class_ok
19650 20622 : && declared_has_coarray_comp))
19651 1787657 : || (class_attr.codimension && class_attr.allocatable))
19652 904 : && sym->attr.dummy && sym->attr.intent == INTENT_OUT)
19653 : {
19654 4 : gfc_error ("Variable %qs at %L is INTENT(OUT) and can thus not be an "
19655 : "allocatable coarray or have coarray components",
19656 : sym->name, &sym->declared_at);
19657 4 : return;
19658 : }
19659 :
19660 1787766 : if (class_attr.codimension && sym->attr.dummy
19661 481 : && sym->ns->proc_name && sym->ns->proc_name->attr.is_bind_c)
19662 : {
19663 2 : gfc_error ("Coarray dummy variable %qs at %L not allowed in BIND(C) "
19664 : "procedure %qs", sym->name, &sym->declared_at,
19665 : sym->ns->proc_name->name);
19666 2 : return;
19667 : }
19668 :
19669 1787764 : if (sym->ts.type == BT_LOGICAL
19670 114910 : && ((sym->attr.function && sym->attr.is_bind_c && sym->result == sym)
19671 114907 : || ((sym->attr.dummy || sym->attr.result) && sym->ns->proc_name
19672 32870 : && sym->ns->proc_name->attr.is_bind_c)))
19673 : {
19674 : int i;
19675 200 : for (i = 0; gfc_logical_kinds[i].kind; i++)
19676 200 : if (gfc_logical_kinds[i].kind == sym->ts.kind)
19677 : break;
19678 16 : if (!gfc_logical_kinds[i].c_bool && sym->attr.dummy
19679 181 : && !gfc_notify_std (GFC_STD_GNU, "LOGICAL dummy argument %qs at "
19680 : "%L with non-C_Bool kind in BIND(C) procedure "
19681 : "%qs", sym->name, &sym->declared_at,
19682 13 : sym->ns->proc_name->name))
19683 : return;
19684 167 : else if (!gfc_logical_kinds[i].c_bool
19685 182 : && !gfc_notify_std (GFC_STD_GNU, "LOGICAL result variable "
19686 : "%qs at %L with non-C_Bool kind in "
19687 : "BIND(C) procedure %qs", sym->name,
19688 : &sym->declared_at,
19689 15 : sym->attr.function ? sym->name
19690 13 : : sym->ns->proc_name->name))
19691 : return;
19692 : }
19693 :
19694 1787761 : switch (sym->attr.flavor)
19695 : {
19696 691100 : case FL_VARIABLE:
19697 691100 : if (!resolve_fl_variable (sym, mp_flag))
19698 : return;
19699 : break;
19700 :
19701 511586 : case FL_PROCEDURE:
19702 511586 : if (sym->formal && !sym->formal_ns)
19703 : {
19704 : /* Check that none of the arguments are a namelist. */
19705 : gfc_formal_arglist *formal = sym->formal;
19706 :
19707 109065 : for (; formal; formal = formal->next)
19708 73736 : if (formal->sym && formal->sym->attr.flavor == FL_NAMELIST)
19709 : {
19710 1 : gfc_error ("Namelist %qs cannot be an argument to "
19711 : "subroutine or function at %L",
19712 : formal->sym->name, &sym->declared_at);
19713 1 : return;
19714 : }
19715 : }
19716 :
19717 511585 : if (!resolve_fl_procedure (sym, mp_flag))
19718 : return;
19719 : break;
19720 :
19721 881 : case FL_NAMELIST:
19722 881 : if (!resolve_fl_namelist (sym))
19723 : return;
19724 : break;
19725 :
19726 418360 : case FL_PARAMETER:
19727 418360 : if (!resolve_fl_parameter (sym))
19728 : return;
19729 : break;
19730 :
19731 : default:
19732 : break;
19733 : }
19734 :
19735 : /* Resolve array specifier. Check as well some constraints
19736 : on COMMON blocks. */
19737 :
19738 1787564 : check_constant = sym->attr.in_common && !sym->attr.pointer && !sym->error;
19739 :
19740 1787564 : resolve_symbol_array_spec (sym, check_constant);
19741 :
19742 : /* Resolve formal namespaces. */
19743 1787564 : if (sym->formal_ns && sym->formal_ns != gfc_current_ns
19744 285638 : && !sym->attr.contained && !sym->attr.intrinsic)
19745 255497 : gfc_resolve (sym->formal_ns);
19746 :
19747 : /* Make sure the formal namespace is present. */
19748 1787564 : if (sym->formal && !sym->formal_ns)
19749 : {
19750 : gfc_formal_arglist *formal = sym->formal;
19751 36032 : while (formal && !formal->sym)
19752 11 : formal = formal->next;
19753 :
19754 36021 : if (formal)
19755 : {
19756 36010 : sym->formal_ns = formal->sym->ns;
19757 36010 : if (sym->formal_ns && sym->ns != formal->sym->ns)
19758 27536 : sym->formal_ns->refs++;
19759 : }
19760 : }
19761 :
19762 : /* Check threadprivate restrictions. */
19763 1787564 : if ((sym->attr.threadprivate || sym->attr.omp_groupprivate)
19764 387 : && !(sym->attr.save || sym->attr.data || sym->attr.in_common)
19765 33 : && !(sym->ns->save_all && !sym->attr.automatic)
19766 32 : && sym->module == NULL
19767 17 : && (sym->ns->proc_name == NULL
19768 17 : || (sym->ns->proc_name->attr.flavor != FL_MODULE
19769 4 : && !sym->ns->proc_name->attr.is_main_program)))
19770 : {
19771 2 : if (sym->attr.threadprivate)
19772 1 : gfc_error ("Threadprivate at %L isn't SAVEd", &sym->declared_at);
19773 : else
19774 1 : gfc_error ("OpenMP groupprivate variable %qs at %L must have the SAVE "
19775 : "attribute", sym->name, &sym->declared_at);
19776 : }
19777 :
19778 1787564 : if (sym->attr.omp_groupprivate && sym->value)
19779 2 : gfc_error ("!$OMP GROUPPRIVATE variable %qs at %L must not have an "
19780 : "initializer", sym->name, &sym->declared_at);
19781 :
19782 : /* Check omp declare target restrictions. */
19783 1787564 : if ((sym->attr.omp_declare_target
19784 1786140 : || sym->attr.omp_declare_target_link
19785 1786091 : || sym->attr.omp_declare_target_local)
19786 1521 : && !sym->attr.omp_groupprivate /* already warned. */
19787 1471 : && sym->attr.flavor == FL_VARIABLE
19788 628 : && !sym->attr.save
19789 206 : && !(sym->ns->save_all && !sym->attr.automatic)
19790 206 : && (!sym->attr.in_common
19791 192 : && sym->module == NULL
19792 102 : && (sym->ns->proc_name == NULL
19793 102 : || (sym->ns->proc_name->attr.flavor != FL_MODULE
19794 12 : && !sym->ns->proc_name->attr.is_main_program))))
19795 4 : gfc_error ("!$OMP DECLARE TARGET variable %qs at %L isn't SAVEd",
19796 : sym->name, &sym->declared_at);
19797 :
19798 : /* If we have come this far we can apply default-initializers, as
19799 : described in 14.7.5, to those variables that have not already
19800 : been assigned one. */
19801 1787564 : if (sym->ts.type == BT_DERIVED
19802 135627 : && !sym->value
19803 109766 : && !sym->attr.allocatable
19804 106530 : && !sym->attr.alloc_comp)
19805 : {
19806 106453 : symbol_attribute *a = &sym->attr;
19807 :
19808 106453 : if ((!a->save && !a->dummy && !a->pointer
19809 58728 : && !a->in_common && !a->use_assoc
19810 11233 : && a->referenced
19811 8815 : && !((a->function || a->result)
19812 1828 : && (!a->dimension
19813 178 : || sym->ts.u.derived->attr.alloc_comp
19814 101 : || sym->ts.u.derived->attr.pointer_comp))
19815 7074 : && !(a->function && sym != sym->result))
19816 99405 : || (a->dummy && !a->pointer && a->intent == INTENT_OUT
19817 1528 : && sym->ns->proc_name->attr.if_source != IFSRC_IFBODY))
19818 8477 : apply_default_init (sym);
19819 97976 : else if (a->function && !a->pointer && !a->allocatable
19820 21310 : && !a->use_assoc && !a->used_in_submodule && sym->result)
19821 : /* Default initialization for function results. */
19822 2846 : apply_default_init (sym->result);
19823 95130 : else if (a->function && sym->result && a->access != ACCESS_PRIVATE
19824 12215 : && (sym->ts.u.derived->attr.alloc_comp
19825 11650 : || sym->ts.u.derived->attr.pointer_comp))
19826 : /* Mark the result symbol to be referenced, when it has allocatable
19827 : components. */
19828 624 : sym->result->attr.referenced = 1;
19829 : }
19830 :
19831 1787564 : if (sym->ts.type == BT_CLASS && sym->ns == gfc_current_ns
19832 20084 : && sym->attr.dummy && sym->attr.intent == INTENT_OUT
19833 1370 : && sym->ns->proc_name->attr.if_source != IFSRC_IFBODY
19834 1295 : && !CLASS_DATA (sym)->attr.class_pointer
19835 1269 : && !CLASS_DATA (sym)->attr.allocatable)
19836 913 : apply_default_init (sym);
19837 :
19838 : /* If this symbol has a type-spec, check it. */
19839 1787564 : if (sym->attr.flavor == FL_VARIABLE || sym->attr.flavor == FL_PARAMETER
19840 678214 : || (sym->attr.flavor == FL_PROCEDURE && sym->attr.function))
19841 1449507 : if (!resolve_typespec_used (&sym->ts, &sym->declared_at, sym->name))
19842 : return;
19843 :
19844 1787561 : if (sym->param_list)
19845 2260 : resolve_pdt (sym);
19846 : }
19847 :
19848 :
19849 4189 : void gfc_resolve_symbol (gfc_symbol *sym)
19850 : {
19851 4189 : resolve_symbol (sym);
19852 4189 : return;
19853 : }
19854 :
19855 :
19856 : /************* Resolve DATA statements *************/
19857 :
19858 : static struct
19859 : {
19860 : gfc_data_value *vnode;
19861 : mpz_t left;
19862 : }
19863 : values;
19864 :
19865 :
19866 : /* Advance the values structure to point to the next value in the data list. */
19867 :
19868 : static bool
19869 10928 : next_data_value (void)
19870 : {
19871 16696 : while (mpz_cmp_ui (values.left, 0) == 0)
19872 : {
19873 :
19874 8216 : if (values.vnode->next == NULL)
19875 : return false;
19876 :
19877 5768 : values.vnode = values.vnode->next;
19878 5768 : mpz_set (values.left, values.vnode->repeat);
19879 : }
19880 :
19881 : return true;
19882 : }
19883 :
19884 :
19885 : static bool
19886 3575 : check_data_variable (gfc_data_variable *var, locus *where)
19887 : {
19888 3575 : gfc_expr *e;
19889 3575 : mpz_t size;
19890 3575 : mpz_t offset;
19891 3575 : bool t;
19892 3575 : ar_type mark = AR_UNKNOWN;
19893 3575 : int i;
19894 3575 : mpz_t section_index[GFC_MAX_DIMENSIONS];
19895 3575 : int vector_offset[GFC_MAX_DIMENSIONS];
19896 3575 : gfc_ref *ref;
19897 3575 : gfc_array_ref *ar;
19898 3575 : gfc_symbol *sym;
19899 3575 : int has_pointer;
19900 :
19901 3575 : if (!gfc_resolve_expr (var->expr))
19902 : return false;
19903 :
19904 3575 : ar = NULL;
19905 3575 : e = var->expr;
19906 :
19907 3575 : if (e->expr_type == EXPR_FUNCTION && e->value.function.isym
19908 0 : && e->value.function.isym->id == GFC_ISYM_CAF_GET)
19909 0 : e = e->value.function.actual->expr;
19910 :
19911 3575 : if (e->expr_type != EXPR_VARIABLE)
19912 : {
19913 0 : gfc_error ("Expecting definable entity near %L", where);
19914 0 : return false;
19915 : }
19916 :
19917 3575 : sym = e->symtree->n.sym;
19918 :
19919 3575 : if (sym->ns->is_block_data && !sym->attr.in_common)
19920 : {
19921 2 : gfc_error ("BLOCK DATA element %qs at %L must be in COMMON",
19922 : sym->name, &sym->declared_at);
19923 2 : return false;
19924 : }
19925 :
19926 3573 : if (e->ref == NULL && sym->as)
19927 : {
19928 1 : gfc_error ("DATA array %qs at %L must be specified in a previous"
19929 : " declaration", sym->name, where);
19930 1 : return false;
19931 : }
19932 :
19933 3572 : if (gfc_is_coindexed (e))
19934 : {
19935 7 : gfc_error ("DATA element %qs at %L cannot have a coindex", sym->name,
19936 : where);
19937 7 : return false;
19938 : }
19939 :
19940 3565 : has_pointer = sym->attr.pointer;
19941 :
19942 6006 : for (ref = e->ref; ref; ref = ref->next)
19943 : {
19944 2445 : if (ref->type == REF_COMPONENT && ref->u.c.component->attr.pointer)
19945 : has_pointer = 1;
19946 :
19947 2419 : if (has_pointer)
19948 : {
19949 29 : if (ref->type == REF_ARRAY && ref->u.ar.type != AR_FULL)
19950 : {
19951 1 : gfc_error ("DATA element %qs at %L is a pointer and so must "
19952 : "be a full array", sym->name, where);
19953 1 : return false;
19954 : }
19955 :
19956 28 : if (values.vnode->expr->expr_type == EXPR_CONSTANT)
19957 : {
19958 1 : gfc_error ("DATA object near %L has the pointer attribute "
19959 : "and the corresponding DATA value is not a valid "
19960 : "initial-data-target", where);
19961 1 : return false;
19962 : }
19963 : }
19964 :
19965 2443 : if (ref->type == REF_COMPONENT && ref->u.c.component->attr.allocatable)
19966 : {
19967 1 : gfc_error ("DATA element %qs at %L cannot have the ALLOCATABLE "
19968 : "attribute", ref->u.c.component->name, &e->where);
19969 1 : return false;
19970 : }
19971 :
19972 : /* Reject substrings of strings of non-constant length. */
19973 2442 : if (ref->type == REF_SUBSTRING
19974 73 : && ref->u.ss.length
19975 73 : && ref->u.ss.length->length
19976 2515 : && !gfc_is_constant_expr (ref->u.ss.length->length))
19977 1 : goto bad_charlen;
19978 : }
19979 :
19980 : /* Reject strings with deferred length or non-constant length. */
19981 3561 : if (e->ts.type == BT_CHARACTER
19982 3561 : && (e->ts.deferred
19983 380 : || (e->ts.u.cl->length
19984 379 : && !gfc_is_constant_expr (e->ts.u.cl->length))))
19985 5 : goto bad_charlen;
19986 :
19987 3556 : mpz_init_set_si (offset, 0);
19988 :
19989 3556 : if (e->rank == 0 || has_pointer)
19990 : {
19991 2709 : mpz_init_set_ui (size, 1);
19992 2709 : ref = NULL;
19993 : }
19994 : else
19995 : {
19996 847 : ref = e->ref;
19997 :
19998 : /* Find the array section reference. */
19999 1030 : for (ref = e->ref; ref; ref = ref->next)
20000 : {
20001 1030 : if (ref->type != REF_ARRAY)
20002 92 : continue;
20003 938 : if (ref->u.ar.type == AR_ELEMENT)
20004 91 : continue;
20005 : break;
20006 : }
20007 847 : gcc_assert (ref);
20008 :
20009 : /* Set marks according to the reference pattern. */
20010 847 : switch (ref->u.ar.type)
20011 : {
20012 : case AR_FULL:
20013 : mark = AR_FULL;
20014 : break;
20015 :
20016 151 : case AR_SECTION:
20017 151 : ar = &ref->u.ar;
20018 : /* Get the start position of array section. */
20019 151 : gfc_get_section_index (ar, section_index, &offset, vector_offset);
20020 151 : mark = AR_SECTION;
20021 151 : break;
20022 :
20023 0 : default:
20024 0 : gcc_unreachable ();
20025 : }
20026 :
20027 847 : if (!gfc_array_size (e, &size))
20028 : {
20029 1 : gfc_error ("Nonconstant array section at %L in DATA statement",
20030 : where);
20031 1 : mpz_clear (offset);
20032 1 : return false;
20033 : }
20034 : }
20035 :
20036 3555 : t = true;
20037 :
20038 11973 : while (mpz_cmp_ui (size, 0) > 0)
20039 : {
20040 8481 : if (!next_data_value ())
20041 : {
20042 1 : gfc_error ("DATA statement at %L has more variables than values",
20043 : where);
20044 1 : t = false;
20045 1 : break;
20046 : }
20047 :
20048 8480 : t = gfc_check_assign (var->expr, values.vnode->expr, 0);
20049 8480 : if (!t)
20050 : break;
20051 :
20052 : /* If we have more than one element left in the repeat count,
20053 : and we have more than one element left in the target variable,
20054 : then create a range assignment. */
20055 : /* FIXME: Only done for full arrays for now, since array sections
20056 : seem tricky. */
20057 8461 : if (mark == AR_FULL && ref && ref->next == NULL
20058 5364 : && mpz_cmp_ui (values.left, 1) > 0 && mpz_cmp_ui (size, 1) > 0)
20059 : {
20060 137 : mpz_t range;
20061 :
20062 137 : if (mpz_cmp (size, values.left) >= 0)
20063 : {
20064 126 : mpz_init_set (range, values.left);
20065 126 : mpz_sub (size, size, values.left);
20066 126 : mpz_set_ui (values.left, 0);
20067 : }
20068 : else
20069 : {
20070 11 : mpz_init_set (range, size);
20071 11 : mpz_sub (values.left, values.left, size);
20072 11 : mpz_set_ui (size, 0);
20073 : }
20074 :
20075 137 : t = gfc_assign_data_value (var->expr, values.vnode->expr,
20076 : offset, &range);
20077 :
20078 137 : mpz_add (offset, offset, range);
20079 137 : mpz_clear (range);
20080 :
20081 137 : if (!t)
20082 : break;
20083 129 : }
20084 :
20085 : /* Assign initial value to symbol. */
20086 : else
20087 : {
20088 8324 : mpz_sub_ui (values.left, values.left, 1);
20089 8324 : mpz_sub_ui (size, size, 1);
20090 :
20091 8324 : t = gfc_assign_data_value (var->expr, values.vnode->expr,
20092 : offset, NULL);
20093 8324 : if (!t)
20094 : break;
20095 :
20096 8289 : if (mark == AR_FULL)
20097 5259 : mpz_add_ui (offset, offset, 1);
20098 :
20099 : /* Modify the array section indexes and recalculate the offset
20100 : for next element. */
20101 3030 : else if (mark == AR_SECTION)
20102 366 : gfc_advance_section (section_index, ar, &offset, vector_offset);
20103 : }
20104 : }
20105 :
20106 3555 : if (mark == AR_SECTION)
20107 : {
20108 344 : for (i = 0; i < ar->dimen; i++)
20109 194 : mpz_clear (section_index[i]);
20110 : }
20111 :
20112 3555 : mpz_clear (size);
20113 3555 : mpz_clear (offset);
20114 :
20115 3555 : return t;
20116 :
20117 6 : bad_charlen:
20118 6 : gfc_error ("Non-constant character length at %L in DATA statement",
20119 : &e->where);
20120 6 : return false;
20121 : }
20122 :
20123 :
20124 : static bool traverse_data_var (gfc_data_variable *, locus *);
20125 :
20126 : /* Iterate over a list of elements in a DATA statement. */
20127 :
20128 : static bool
20129 237 : traverse_data_list (gfc_data_variable *var, locus *where)
20130 : {
20131 237 : mpz_t trip;
20132 237 : iterator_stack frame;
20133 237 : gfc_expr *e, *start, *end, *step;
20134 237 : bool retval = true;
20135 :
20136 237 : mpz_init (frame.value);
20137 237 : mpz_init (trip);
20138 :
20139 237 : start = gfc_copy_expr (var->iter.start);
20140 237 : end = gfc_copy_expr (var->iter.end);
20141 237 : step = gfc_copy_expr (var->iter.step);
20142 :
20143 237 : if (!gfc_simplify_expr (start, 1)
20144 237 : || start->expr_type != EXPR_CONSTANT)
20145 : {
20146 0 : gfc_error ("start of implied-do loop at %L could not be "
20147 : "simplified to a constant value", &start->where);
20148 0 : retval = false;
20149 0 : goto cleanup;
20150 : }
20151 237 : if (!gfc_simplify_expr (end, 1)
20152 237 : || end->expr_type != EXPR_CONSTANT)
20153 : {
20154 0 : gfc_error ("end of implied-do loop at %L could not be "
20155 : "simplified to a constant value", &end->where);
20156 0 : retval = false;
20157 0 : goto cleanup;
20158 : }
20159 237 : if (!gfc_simplify_expr (step, 1)
20160 237 : || step->expr_type != EXPR_CONSTANT)
20161 : {
20162 0 : gfc_error ("step of implied-do loop at %L could not be "
20163 : "simplified to a constant value", &step->where);
20164 0 : retval = false;
20165 0 : goto cleanup;
20166 : }
20167 237 : if (mpz_cmp_si (step->value.integer, 0) == 0)
20168 : {
20169 1 : gfc_error ("step of implied-do loop at %L shall not be zero",
20170 : &step->where);
20171 1 : retval = false;
20172 1 : goto cleanup;
20173 : }
20174 :
20175 236 : mpz_set (trip, end->value.integer);
20176 236 : mpz_sub (trip, trip, start->value.integer);
20177 236 : mpz_add (trip, trip, step->value.integer);
20178 :
20179 236 : mpz_div (trip, trip, step->value.integer);
20180 :
20181 236 : mpz_set (frame.value, start->value.integer);
20182 :
20183 236 : frame.prev = iter_stack;
20184 236 : frame.variable = var->iter.var->symtree;
20185 236 : iter_stack = &frame;
20186 :
20187 1127 : while (mpz_cmp_ui (trip, 0) > 0)
20188 : {
20189 905 : if (!traverse_data_var (var->list, where))
20190 : {
20191 14 : retval = false;
20192 14 : goto cleanup;
20193 : }
20194 :
20195 891 : e = gfc_copy_expr (var->expr);
20196 891 : if (!gfc_simplify_expr (e, 1))
20197 : {
20198 0 : gfc_free_expr (e);
20199 0 : retval = false;
20200 0 : goto cleanup;
20201 : }
20202 :
20203 891 : mpz_add (frame.value, frame.value, step->value.integer);
20204 :
20205 891 : mpz_sub_ui (trip, trip, 1);
20206 : }
20207 :
20208 222 : cleanup:
20209 237 : mpz_clear (frame.value);
20210 237 : mpz_clear (trip);
20211 :
20212 237 : gfc_free_expr (start);
20213 237 : gfc_free_expr (end);
20214 237 : gfc_free_expr (step);
20215 :
20216 237 : iter_stack = frame.prev;
20217 237 : return retval;
20218 : }
20219 :
20220 :
20221 : /* Type resolve variables in the variable list of a DATA statement. */
20222 :
20223 : static bool
20224 3436 : traverse_data_var (gfc_data_variable *var, locus *where)
20225 : {
20226 3436 : bool t;
20227 :
20228 7150 : for (; var; var = var->next)
20229 : {
20230 3812 : if (var->expr == NULL)
20231 237 : t = traverse_data_list (var, where);
20232 : else
20233 3575 : t = check_data_variable (var, where);
20234 :
20235 3812 : if (!t)
20236 : return false;
20237 : }
20238 :
20239 : return true;
20240 : }
20241 :
20242 :
20243 : /* Resolve the expressions and iterators associated with a data statement.
20244 : This is separate from the assignment checking because data lists should
20245 : only be resolved once. */
20246 :
20247 : static bool
20248 2686 : resolve_data_variables (gfc_data_variable *d)
20249 : {
20250 5743 : for (; d; d = d->next)
20251 : {
20252 3062 : if (d->list == NULL)
20253 : {
20254 2909 : if (!gfc_resolve_expr (d->expr))
20255 : return false;
20256 : }
20257 : else
20258 : {
20259 153 : if (!gfc_resolve_iterator (&d->iter, false, true))
20260 : return false;
20261 :
20262 150 : if (!resolve_data_variables (d->list))
20263 : return false;
20264 : }
20265 : }
20266 :
20267 : return true;
20268 : }
20269 :
20270 :
20271 : /* Resolve a single DATA statement. We implement this by storing a pointer to
20272 : the value list into static variables, and then recursively traversing the
20273 : variables list, expanding iterators and such. */
20274 :
20275 : static void
20276 2536 : resolve_data (gfc_data *d)
20277 : {
20278 2536 : gfc_data_value *v;
20279 :
20280 2536 : if (!resolve_data_variables (d->var))
20281 : return;
20282 :
20283 10851 : for (v = d->value; v; v = v->next)
20284 8320 : if (v->expr && !gfc_resolve_expr (v->expr))
20285 : return;
20286 :
20287 2531 : values.vnode = d->value;
20288 2531 : if (d->value == NULL)
20289 0 : mpz_set_ui (values.left, 0);
20290 : else
20291 2531 : mpz_set (values.left, d->value->repeat);
20292 :
20293 2531 : if (!traverse_data_var (d->var, &d->where))
20294 : return;
20295 :
20296 : /* At this point, we better not have any values left. */
20297 :
20298 2447 : if (next_data_value ())
20299 0 : gfc_error ("DATA statement at %L has more values than variables",
20300 : &d->where);
20301 : }
20302 :
20303 :
20304 : /* 12.6 Constraint: In a pure subprogram any variable which is in common or
20305 : accessed by host or use association, is a dummy argument to a pure function,
20306 : is a dummy argument with INTENT (IN) to a pure subroutine, or an object that
20307 : is storage associated with any such variable, shall not be used in the
20308 : following contexts: (clients of this function). */
20309 :
20310 : /* Determines if a variable is not 'pure', i.e., not assignable within a pure
20311 : procedure. Returns zero if assignment is OK, nonzero if there is a
20312 : problem. */
20313 : bool
20314 59075 : gfc_impure_variable (gfc_symbol *sym)
20315 : {
20316 59075 : gfc_symbol *proc;
20317 59075 : gfc_namespace *ns;
20318 :
20319 59075 : if (sym->attr.use_assoc || sym->attr.in_common)
20320 : return 1;
20321 :
20322 : /* The namespace of a module procedure interface holds the arguments and
20323 : symbols, and so the symbol namespace can be different to that of the
20324 : procedure. */
20325 58445 : if (sym->ns != gfc_current_ns
20326 6329 : && gfc_current_ns->proc_name->abr_modproc_decl
20327 48 : && sym->ns->proc_name->attr.function
20328 12 : && sym->attr.result
20329 12 : && !strcmp (sym->ns->proc_name->name, gfc_current_ns->proc_name->name))
20330 : return 0;
20331 :
20332 : /* Check if the symbol's ns is inside the pure procedure. */
20333 63363 : for (ns = gfc_current_ns; ns; ns = ns->parent)
20334 : {
20335 63079 : if (ns == sym->ns)
20336 : break;
20337 6651 : if (ns->proc_name->attr.flavor == FL_PROCEDURE
20338 5489 : && !(sym->attr.function || sym->attr.result))
20339 : return 1;
20340 : }
20341 :
20342 56712 : proc = sym->ns->proc_name;
20343 56712 : if (sym->attr.dummy
20344 6331 : && !sym->attr.value
20345 6209 : && ((proc->attr.subroutine && sym->attr.intent == INTENT_IN)
20346 6003 : || proc->attr.function))
20347 706 : return 1;
20348 :
20349 : /* TODO: Sort out what can be storage associated, if anything, and include
20350 : it here. In principle equivalences should be scanned but it does not
20351 : seem to be possible to storage associate an impure variable this way. */
20352 : return 0;
20353 : }
20354 :
20355 :
20356 : /* Test whether a symbol is pure or not. For a NULL pointer, checks if the
20357 : current namespace is inside a pure procedure. */
20358 :
20359 : bool
20360 2425798 : gfc_pure (gfc_symbol *sym)
20361 : {
20362 2425798 : symbol_attribute attr;
20363 2425798 : gfc_namespace *ns;
20364 :
20365 2425798 : if (sym == NULL)
20366 : {
20367 : /* Check if the current namespace or one of its parents
20368 : belongs to a pure procedure. */
20369 3259514 : for (ns = gfc_current_ns; ns; ns = ns->parent)
20370 : {
20371 1925828 : sym = ns->proc_name;
20372 1925828 : if (sym == NULL)
20373 : return 0;
20374 1924687 : attr = sym->attr;
20375 1924687 : if (attr.flavor == FL_PROCEDURE && attr.pure)
20376 : return 1;
20377 : }
20378 : return 0;
20379 : }
20380 :
20381 1083373 : attr = sym->attr;
20382 :
20383 1083373 : return attr.flavor == FL_PROCEDURE && attr.pure;
20384 : }
20385 :
20386 :
20387 : /* Test whether a symbol is implicitly pure or not. For a NULL pointer,
20388 : checks if the current namespace is implicitly pure. Note that this
20389 : function returns false for a PURE procedure. */
20390 :
20391 : bool
20392 741140 : gfc_implicit_pure (gfc_symbol *sym)
20393 : {
20394 741140 : gfc_namespace *ns;
20395 :
20396 741140 : if (sym == NULL)
20397 : {
20398 : /* Check if the current procedure is implicit_pure. Walk up
20399 : the procedure list until we find a procedure. */
20400 1022950 : for (ns = gfc_current_ns; ns; ns = ns->parent)
20401 : {
20402 729059 : sym = ns->proc_name;
20403 729059 : if (sym == NULL)
20404 : return 0;
20405 :
20406 728986 : if (sym->attr.flavor == FL_PROCEDURE)
20407 : break;
20408 : }
20409 : }
20410 :
20411 447173 : return sym->attr.flavor == FL_PROCEDURE && sym->attr.implicit_pure
20412 770492 : && !sym->attr.pure;
20413 : }
20414 :
20415 :
20416 : void
20417 436364 : gfc_unset_implicit_pure (gfc_symbol *sym)
20418 : {
20419 436364 : gfc_namespace *ns;
20420 :
20421 436364 : if (sym == NULL)
20422 : {
20423 : /* Check if the current procedure is implicit_pure. Walk up
20424 : the procedure list until we find a procedure. */
20425 714178 : for (ns = gfc_current_ns; ns; ns = ns->parent)
20426 : {
20427 441627 : sym = ns->proc_name;
20428 441627 : if (sym == NULL)
20429 : return;
20430 :
20431 440794 : if (sym->attr.flavor == FL_PROCEDURE)
20432 : break;
20433 : }
20434 : }
20435 :
20436 435531 : if (sym->attr.flavor == FL_PROCEDURE)
20437 154339 : sym->attr.implicit_pure = 0;
20438 : else
20439 281192 : sym->attr.pure = 0;
20440 : }
20441 :
20442 :
20443 : /* Test whether the current procedure is elemental or not. */
20444 :
20445 : bool
20446 1464438 : gfc_elemental (gfc_symbol *sym)
20447 : {
20448 1464438 : symbol_attribute attr;
20449 :
20450 1464438 : if (sym == NULL)
20451 0 : sym = gfc_current_ns->proc_name;
20452 0 : if (sym == NULL)
20453 : return 0;
20454 1464438 : attr = sym->attr;
20455 :
20456 1464438 : return attr.flavor == FL_PROCEDURE && attr.elemental;
20457 : }
20458 :
20459 :
20460 : /* Warn about unused labels. */
20461 :
20462 : static void
20463 4873 : warn_unused_fortran_label (gfc_st_label *label)
20464 : {
20465 4899 : if (label == NULL)
20466 : return;
20467 :
20468 27 : warn_unused_fortran_label (label->left);
20469 :
20470 27 : if (label->defined == ST_LABEL_UNKNOWN)
20471 : return;
20472 :
20473 26 : switch (label->referenced)
20474 : {
20475 2 : case ST_LABEL_UNKNOWN:
20476 2 : gfc_warning (OPT_Wunused_label, "Label %d at %L defined but not used",
20477 : label->value, &label->where);
20478 2 : break;
20479 :
20480 1 : case ST_LABEL_BAD_TARGET:
20481 1 : gfc_warning (OPT_Wunused_label,
20482 : "Label %d at %L defined but cannot be used",
20483 : label->value, &label->where);
20484 1 : break;
20485 :
20486 : default:
20487 : break;
20488 : }
20489 :
20490 26 : warn_unused_fortran_label (label->right);
20491 : }
20492 :
20493 :
20494 : /* Returns the sequence type of a symbol or sequence. */
20495 :
20496 : static seq_type
20497 1076 : sequence_type (gfc_typespec ts)
20498 : {
20499 1076 : seq_type result;
20500 1076 : gfc_component *c;
20501 :
20502 1076 : switch (ts.type)
20503 : {
20504 49 : case BT_DERIVED:
20505 :
20506 49 : if (ts.u.derived->components == NULL)
20507 : return SEQ_NONDEFAULT;
20508 :
20509 49 : result = sequence_type (ts.u.derived->components->ts);
20510 103 : for (c = ts.u.derived->components->next; c; c = c->next)
20511 67 : if (sequence_type (c->ts) != result)
20512 : return SEQ_MIXED;
20513 :
20514 : return result;
20515 :
20516 129 : case BT_CHARACTER:
20517 129 : if (ts.kind != gfc_default_character_kind)
20518 0 : return SEQ_NONDEFAULT;
20519 :
20520 : return SEQ_CHARACTER;
20521 :
20522 240 : case BT_INTEGER:
20523 240 : if (ts.kind != gfc_default_integer_kind)
20524 25 : return SEQ_NONDEFAULT;
20525 :
20526 : return SEQ_NUMERIC;
20527 :
20528 559 : case BT_REAL:
20529 559 : if (!(ts.kind == gfc_default_real_kind
20530 269 : || ts.kind == gfc_default_double_kind))
20531 0 : return SEQ_NONDEFAULT;
20532 :
20533 : return SEQ_NUMERIC;
20534 :
20535 81 : case BT_COMPLEX:
20536 81 : if (ts.kind != gfc_default_complex_kind)
20537 48 : return SEQ_NONDEFAULT;
20538 :
20539 : return SEQ_NUMERIC;
20540 :
20541 17 : case BT_LOGICAL:
20542 17 : if (ts.kind != gfc_default_logical_kind)
20543 0 : return SEQ_NONDEFAULT;
20544 :
20545 : return SEQ_NUMERIC;
20546 :
20547 : default:
20548 : return SEQ_NONDEFAULT;
20549 : }
20550 : }
20551 :
20552 :
20553 : /* Resolve derived type EQUIVALENCE object. */
20554 :
20555 : static bool
20556 80 : resolve_equivalence_derived (gfc_symbol *derived, gfc_symbol *sym, gfc_expr *e)
20557 : {
20558 80 : gfc_component *c = derived->components;
20559 :
20560 80 : if (!derived)
20561 : return true;
20562 :
20563 : /* Shall not be an object of nonsequence derived type. */
20564 80 : if (!derived->attr.sequence)
20565 : {
20566 0 : gfc_error ("Derived type variable %qs at %L must have SEQUENCE "
20567 : "attribute to be an EQUIVALENCE object", sym->name,
20568 : &e->where);
20569 0 : return false;
20570 : }
20571 :
20572 : /* Shall not have allocatable components. */
20573 80 : if (derived->attr.alloc_comp)
20574 : {
20575 1 : gfc_error ("Derived type variable %qs at %L cannot have ALLOCATABLE "
20576 : "components to be an EQUIVALENCE object",sym->name,
20577 : &e->where);
20578 1 : return false;
20579 : }
20580 :
20581 79 : if (sym->attr.in_common && gfc_has_default_initializer (sym->ts.u.derived))
20582 : {
20583 1 : gfc_error ("Derived type variable %qs at %L with default "
20584 : "initialization cannot be in EQUIVALENCE with a variable "
20585 : "in COMMON", sym->name, &e->where);
20586 1 : return false;
20587 : }
20588 :
20589 245 : for (; c ; c = c->next)
20590 : {
20591 167 : if (gfc_bt_struct (c->ts.type)
20592 167 : && (!resolve_equivalence_derived(c->ts.u.derived, sym, e)))
20593 : return false;
20594 :
20595 : /* Shall not be an object of sequence derived type containing a pointer
20596 : in the structure. */
20597 167 : if (c->attr.pointer)
20598 : {
20599 0 : gfc_error ("Derived type variable %qs at %L with pointer "
20600 : "component(s) cannot be an EQUIVALENCE object",
20601 : sym->name, &e->where);
20602 0 : return false;
20603 : }
20604 : }
20605 : return true;
20606 : }
20607 :
20608 :
20609 : /* Resolve equivalence object.
20610 : An EQUIVALENCE object shall not be a dummy argument, a pointer, a target,
20611 : an allocatable array, an object of nonsequence derived type, an object of
20612 : sequence derived type containing a pointer at any level of component
20613 : selection, an automatic object, a function name, an entry name, a result
20614 : name, a named constant, a structure component, or a subobject of any of
20615 : the preceding objects. A substring shall not have length zero. A
20616 : derived type shall not have components with default initialization nor
20617 : shall two objects of an equivalence group be initialized.
20618 : Either all or none of the objects shall have an protected attribute.
20619 : The simple constraints are done in symbol.cc(check_conflict) and the rest
20620 : are implemented here. */
20621 :
20622 : static void
20623 1565 : resolve_equivalence (gfc_equiv *eq)
20624 : {
20625 1565 : gfc_symbol *sym;
20626 1565 : gfc_symbol *first_sym;
20627 1565 : gfc_expr *e;
20628 1565 : gfc_ref *r;
20629 1565 : locus *last_where = NULL;
20630 1565 : seq_type eq_type, last_eq_type;
20631 1565 : gfc_typespec *last_ts;
20632 1565 : int object, cnt_protected;
20633 1565 : const char *msg;
20634 :
20635 1565 : last_ts = &eq->expr->symtree->n.sym->ts;
20636 :
20637 1565 : first_sym = eq->expr->symtree->n.sym;
20638 :
20639 1565 : cnt_protected = 0;
20640 :
20641 4727 : for (object = 1; eq; eq = eq->eq, object++)
20642 : {
20643 3171 : e = eq->expr;
20644 :
20645 3171 : e->ts = e->symtree->n.sym->ts;
20646 : /* match_varspec might not know yet if it is seeing
20647 : array reference or substring reference, as it doesn't
20648 : know the types. */
20649 3171 : if (e->ref && e->ref->type == REF_ARRAY)
20650 : {
20651 2152 : gfc_ref *ref = e->ref;
20652 2152 : sym = e->symtree->n.sym;
20653 :
20654 2152 : if (sym->attr.dimension)
20655 : {
20656 1855 : ref->u.ar.as = sym->as;
20657 1855 : ref = ref->next;
20658 : }
20659 :
20660 : /* For substrings, convert REF_ARRAY into REF_SUBSTRING. */
20661 2152 : if (e->ts.type == BT_CHARACTER
20662 592 : && ref
20663 371 : && ref->type == REF_ARRAY
20664 371 : && ref->u.ar.dimen == 1
20665 371 : && ref->u.ar.dimen_type[0] == DIMEN_RANGE
20666 371 : && ref->u.ar.stride[0] == NULL)
20667 : {
20668 370 : gfc_expr *start = ref->u.ar.start[0];
20669 370 : gfc_expr *end = ref->u.ar.end[0];
20670 370 : void *mem = NULL;
20671 :
20672 : /* Optimize away the (:) reference. */
20673 370 : if (start == NULL && end == NULL)
20674 : {
20675 9 : if (e->ref == ref)
20676 0 : e->ref = ref->next;
20677 : else
20678 9 : e->ref->next = ref->next;
20679 : mem = ref;
20680 : }
20681 : else
20682 : {
20683 361 : ref->type = REF_SUBSTRING;
20684 361 : if (start == NULL)
20685 9 : start = gfc_get_int_expr (gfc_charlen_int_kind,
20686 : NULL, 1);
20687 361 : ref->u.ss.start = start;
20688 361 : if (end == NULL && e->ts.u.cl)
20689 27 : end = gfc_copy_expr (e->ts.u.cl->length);
20690 361 : ref->u.ss.end = end;
20691 361 : ref->u.ss.length = e->ts.u.cl;
20692 361 : e->ts.u.cl = NULL;
20693 : }
20694 370 : ref = ref->next;
20695 370 : free (mem);
20696 : }
20697 :
20698 : /* Any further ref is an error. */
20699 1930 : if (ref)
20700 : {
20701 1 : gcc_assert (ref->type == REF_ARRAY);
20702 1 : gfc_error ("Syntax error in EQUIVALENCE statement at %L",
20703 : &ref->u.ar.where);
20704 1 : continue;
20705 : }
20706 : }
20707 :
20708 3170 : if (!gfc_resolve_expr (e))
20709 2 : continue;
20710 :
20711 3168 : sym = e->symtree->n.sym;
20712 :
20713 3168 : if (sym->attr.is_protected)
20714 2 : cnt_protected++;
20715 3168 : if (cnt_protected > 0 && cnt_protected != object)
20716 : {
20717 2 : gfc_error ("Either all or none of the objects in the "
20718 : "EQUIVALENCE set at %L shall have the "
20719 : "PROTECTED attribute",
20720 : &e->where);
20721 2 : break;
20722 : }
20723 :
20724 : /* Shall not equivalence common block variables in a PURE procedure. */
20725 3166 : if (sym->ns->proc_name
20726 3150 : && sym->ns->proc_name->attr.pure
20727 7 : && sym->attr.in_common)
20728 : {
20729 : /* Need to check for symbols that may have entered the pure
20730 : procedure via a USE statement. */
20731 7 : bool saw_sym = false;
20732 7 : if (sym->ns->use_stmts)
20733 : {
20734 6 : gfc_use_rename *r;
20735 10 : for (r = sym->ns->use_stmts->rename; r; r = r->next)
20736 4 : if (strcmp(r->use_name, sym->name) == 0) saw_sym = true;
20737 : }
20738 : else
20739 : saw_sym = true;
20740 :
20741 6 : if (saw_sym)
20742 3 : gfc_error ("COMMON block member %qs at %L cannot be an "
20743 : "EQUIVALENCE object in the pure procedure %qs",
20744 : sym->name, &e->where, sym->ns->proc_name->name);
20745 : break;
20746 : }
20747 :
20748 : /* Shall not be a named constant. */
20749 3159 : if (e->expr_type == EXPR_CONSTANT)
20750 : {
20751 0 : gfc_error ("Named constant %qs at %L cannot be an EQUIVALENCE "
20752 : "object", sym->name, &e->where);
20753 0 : continue;
20754 : }
20755 :
20756 3161 : if (e->ts.type == BT_DERIVED
20757 3159 : && !resolve_equivalence_derived (e->ts.u.derived, sym, e))
20758 2 : continue;
20759 :
20760 : /* Check that the types correspond correctly:
20761 : Note 5.28:
20762 : A numeric sequence structure may be equivalenced to another sequence
20763 : structure, an object of default integer type, default real type, double
20764 : precision real type, default logical type such that components of the
20765 : structure ultimately only become associated to objects of the same
20766 : kind. A character sequence structure may be equivalenced to an object
20767 : of default character kind or another character sequence structure.
20768 : Other objects may be equivalenced only to objects of the same type and
20769 : kind parameters. */
20770 :
20771 : /* Identical types are unconditionally OK. */
20772 3157 : if (object == 1 || gfc_compare_types (last_ts, &sym->ts))
20773 2677 : goto identical_types;
20774 :
20775 480 : last_eq_type = sequence_type (*last_ts);
20776 480 : eq_type = sequence_type (sym->ts);
20777 :
20778 : /* Since the pair of objects is not of the same type, mixed or
20779 : non-default sequences can be rejected. */
20780 :
20781 480 : msg = G_("Sequence %s with mixed components in EQUIVALENCE "
20782 : "statement at %L with different type objects");
20783 481 : if ((object ==2
20784 480 : && last_eq_type == SEQ_MIXED
20785 7 : && last_where
20786 7 : && !gfc_notify_std (GFC_STD_GNU, msg, first_sym->name, last_where))
20787 486 : || (eq_type == SEQ_MIXED
20788 6 : && !gfc_notify_std (GFC_STD_GNU, msg, sym->name, &e->where)))
20789 1 : continue;
20790 :
20791 479 : msg = G_("Non-default type object or sequence %s in EQUIVALENCE "
20792 : "statement at %L with objects of different type");
20793 483 : if ((object ==2
20794 479 : && last_eq_type == SEQ_NONDEFAULT
20795 50 : && last_where
20796 49 : && !gfc_notify_std (GFC_STD_GNU, msg, first_sym->name, last_where))
20797 525 : || (eq_type == SEQ_NONDEFAULT
20798 24 : && !gfc_notify_std (GFC_STD_GNU, msg, sym->name, &e->where)))
20799 4 : continue;
20800 :
20801 475 : msg = G_("Non-CHARACTER object %qs in default CHARACTER "
20802 : "EQUIVALENCE statement at %L");
20803 479 : if (last_eq_type == SEQ_CHARACTER
20804 475 : && eq_type != SEQ_CHARACTER
20805 475 : && !gfc_notify_std (GFC_STD_GNU, msg, sym->name, &e->where))
20806 4 : continue;
20807 :
20808 471 : msg = G_("Non-NUMERIC object %qs in default NUMERIC "
20809 : "EQUIVALENCE statement at %L");
20810 473 : if (last_eq_type == SEQ_NUMERIC
20811 471 : && eq_type != SEQ_NUMERIC
20812 471 : && !gfc_notify_std (GFC_STD_GNU, msg, sym->name, &e->where))
20813 2 : continue;
20814 :
20815 3146 : identical_types:
20816 :
20817 3146 : last_ts =&sym->ts;
20818 3146 : last_where = &e->where;
20819 :
20820 3146 : if (!e->ref)
20821 1003 : continue;
20822 :
20823 : /* Shall not be an automatic array. */
20824 2143 : if (e->ref->type == REF_ARRAY && is_non_constant_shape_array (sym))
20825 : {
20826 3 : gfc_error ("Array %qs at %L with non-constant bounds cannot be "
20827 : "an EQUIVALENCE object", sym->name, &e->where);
20828 3 : continue;
20829 : }
20830 :
20831 2140 : r = e->ref;
20832 4326 : while (r)
20833 : {
20834 : /* Shall not be a structure component. */
20835 2187 : if (r->type == REF_COMPONENT)
20836 : {
20837 0 : gfc_error ("Structure component %qs at %L cannot be an "
20838 : "EQUIVALENCE object",
20839 0 : r->u.c.component->name, &e->where);
20840 0 : break;
20841 : }
20842 :
20843 : /* A substring shall not have length zero. */
20844 2187 : if (r->type == REF_SUBSTRING)
20845 : {
20846 341 : if (compare_bound (r->u.ss.start, r->u.ss.end) == CMP_GT)
20847 : {
20848 1 : gfc_error ("Substring at %L has length zero",
20849 : &r->u.ss.start->where);
20850 1 : break;
20851 : }
20852 : }
20853 2186 : r = r->next;
20854 : }
20855 : }
20856 1565 : }
20857 :
20858 :
20859 : /* Function called by resolve_fntype to flag other symbols used in the
20860 : length type parameter specification of function results. */
20861 :
20862 : static bool
20863 4297 : flag_fn_result_spec (gfc_expr *expr,
20864 : gfc_symbol *sym,
20865 : int *f ATTRIBUTE_UNUSED)
20866 : {
20867 4297 : gfc_namespace *ns;
20868 4297 : gfc_symbol *s;
20869 :
20870 4297 : if (expr->expr_type == EXPR_VARIABLE)
20871 : {
20872 1400 : s = expr->symtree->n.sym;
20873 2193 : for (ns = s->ns; ns; ns = ns->parent)
20874 2193 : if (!ns->parent)
20875 : break;
20876 :
20877 1400 : if (sym == s)
20878 : {
20879 1 : gfc_error ("Self reference in character length expression "
20880 : "for %qs at %L", sym->name, &expr->where);
20881 1 : return true;
20882 : }
20883 :
20884 1399 : if (!s->fn_result_spec
20885 1399 : && s->attr.flavor == FL_PARAMETER)
20886 : {
20887 : /* Function contained in a module.... */
20888 63 : if (ns->proc_name && ns->proc_name->attr.flavor == FL_MODULE)
20889 : {
20890 32 : gfc_symtree *st;
20891 32 : s->fn_result_spec = 1;
20892 : /* Make sure that this symbol is translated as a module
20893 : variable. */
20894 32 : st = gfc_get_unique_symtree (ns);
20895 32 : st->n.sym = s;
20896 32 : s->refs++;
20897 32 : }
20898 : /* ... which is use associated and called. */
20899 31 : else if (s->attr.use_assoc || s->attr.used_in_submodule
20900 0 : ||
20901 : /* External function matched with an interface. */
20902 0 : (s->ns->proc_name
20903 0 : && ((s->ns == ns
20904 0 : && s->ns->proc_name->attr.if_source == IFSRC_DECL)
20905 0 : || s->ns->proc_name->attr.if_source == IFSRC_IFBODY)
20906 0 : && s->ns->proc_name->attr.function))
20907 31 : s->fn_result_spec = 1;
20908 : }
20909 : }
20910 : return false;
20911 : }
20912 :
20913 :
20914 : /* Resolve function and ENTRY types, issue diagnostics if needed. */
20915 :
20916 : static void
20917 370654 : resolve_fntype (gfc_namespace *ns)
20918 : {
20919 370654 : gfc_entry_list *el;
20920 370654 : gfc_symbol *sym;
20921 :
20922 370654 : if (ns->proc_name == NULL || !ns->proc_name->attr.function)
20923 : return;
20924 :
20925 : /* If there are any entries, ns->proc_name is the entry master
20926 : synthetic symbol and ns->entries->sym actual FUNCTION symbol. */
20927 193410 : if (ns->entries)
20928 596 : sym = ns->entries->sym;
20929 : else
20930 : sym = ns->proc_name;
20931 193410 : if (sym->result == sym
20932 157294 : && sym->ts.type == BT_UNKNOWN
20933 6 : && !gfc_set_default_type (sym, 0, NULL)
20934 193414 : && !sym->attr.untyped)
20935 : {
20936 3 : gfc_error ("Function %qs at %L has no IMPLICIT type",
20937 : sym->name, &sym->declared_at);
20938 3 : sym->attr.untyped = 1;
20939 : }
20940 :
20941 14295 : if (sym->ts.type == BT_DERIVED && !sym->ts.u.derived->attr.use_assoc
20942 1947 : && !sym->attr.contained
20943 335 : && !gfc_check_symbol_access (sym->ts.u.derived)
20944 193410 : && gfc_check_symbol_access (sym))
20945 : {
20946 0 : gfc_notify_std (GFC_STD_F2003, "PUBLIC function %qs at "
20947 : "%L of PRIVATE type %qs", sym->name,
20948 0 : &sym->declared_at, sym->ts.u.derived->name);
20949 : }
20950 :
20951 193410 : if (ns->entries)
20952 1253 : for (el = ns->entries->next; el; el = el->next)
20953 : {
20954 657 : if (el->sym->result == el->sym
20955 445 : && el->sym->ts.type == BT_UNKNOWN
20956 2 : && !gfc_set_default_type (el->sym, 0, NULL)
20957 659 : && !el->sym->attr.untyped)
20958 : {
20959 2 : gfc_error ("ENTRY %qs at %L has no IMPLICIT type",
20960 : el->sym->name, &el->sym->declared_at);
20961 2 : el->sym->attr.untyped = 1;
20962 : }
20963 : }
20964 :
20965 193410 : if (sym->ts.type == BT_CHARACTER
20966 7194 : && sym->ts.u.cl->length
20967 1931 : && sym->ts.u.cl->length->ts.type == BT_INTEGER)
20968 1926 : gfc_traverse_expr (sym->ts.u.cl->length, sym, flag_fn_result_spec, 0);
20969 : }
20970 :
20971 :
20972 : /* 12.3.2.1.1 Defined operators. */
20973 :
20974 : static bool
20975 508 : check_uop_procedure (gfc_symbol *sym, locus where)
20976 : {
20977 508 : gfc_formal_arglist *formal;
20978 :
20979 508 : if (!sym->attr.function)
20980 : {
20981 4 : gfc_error ("User operator procedure %qs at %L must be a FUNCTION",
20982 : sym->name, &where);
20983 4 : return false;
20984 : }
20985 :
20986 504 : if (sym->ts.type == BT_CHARACTER
20987 15 : && !((sym->ts.u.cl && sym->ts.u.cl->length) || sym->ts.deferred)
20988 2 : && !(sym->result && ((sym->result->ts.u.cl
20989 2 : && sym->result->ts.u.cl->length) || sym->result->ts.deferred)))
20990 : {
20991 2 : gfc_error ("User operator procedure %qs at %L cannot be assumed "
20992 : "character length", sym->name, &where);
20993 2 : return false;
20994 : }
20995 :
20996 502 : formal = gfc_sym_get_dummy_args (sym);
20997 502 : if (!formal || !formal->sym)
20998 : {
20999 1 : gfc_error ("User operator procedure %qs at %L must have at least "
21000 : "one argument", sym->name, &where);
21001 1 : return false;
21002 : }
21003 :
21004 501 : if (formal->sym->attr.intent != INTENT_IN)
21005 : {
21006 0 : gfc_error ("First argument of operator interface at %L must be "
21007 : "INTENT(IN)", &where);
21008 0 : return false;
21009 : }
21010 :
21011 501 : if (formal->sym->attr.optional)
21012 : {
21013 0 : gfc_error ("First argument of operator interface at %L cannot be "
21014 : "optional", &where);
21015 0 : return false;
21016 : }
21017 :
21018 501 : formal = formal->next;
21019 501 : if (!formal || !formal->sym)
21020 : return true;
21021 :
21022 297 : if (formal->sym->attr.intent != INTENT_IN)
21023 : {
21024 0 : gfc_error ("Second argument of operator interface at %L must be "
21025 : "INTENT(IN)", &where);
21026 0 : return false;
21027 : }
21028 :
21029 297 : if (formal->sym->attr.optional)
21030 : {
21031 1 : gfc_error ("Second argument of operator interface at %L cannot be "
21032 : "optional", &where);
21033 1 : return false;
21034 : }
21035 :
21036 296 : if (formal->next)
21037 : {
21038 2 : gfc_error ("Operator interface at %L must have, at most, two "
21039 : "arguments", &where);
21040 2 : return false;
21041 : }
21042 :
21043 : return true;
21044 : }
21045 :
21046 : static void
21047 371460 : gfc_resolve_uops (gfc_symtree *symtree)
21048 : {
21049 371460 : gfc_interface *itr;
21050 :
21051 371460 : if (symtree == NULL)
21052 : return;
21053 :
21054 403 : gfc_resolve_uops (symtree->left);
21055 403 : gfc_resolve_uops (symtree->right);
21056 :
21057 798 : for (itr = symtree->n.uop->op; itr; itr = itr->next)
21058 395 : check_uop_procedure (itr->sym, itr->sym->declared_at);
21059 : }
21060 :
21061 : /* Mark all lhs in assignment statement as used. It is better to put this into
21062 : its own function rather than into the different switch cases in
21063 : gfc_resolve_code. */
21064 :
21065 : static void
21066 712426 : mark_lhs_assignments_set (gfc_code *code)
21067 : {
21068 :
21069 1879248 : for (; code; code = code->next)
21070 : {
21071 1166822 : gfc_expr *lvalue = code->expr1, *rvalue = code->expr2;
21072 :
21073 1166822 : if (lvalue == NULL || lvalue->symtree == NULL || rvalue == NULL)
21074 863637 : continue;
21075 :
21076 303185 : switch (code->op)
21077 : {
21078 291188 : case EXEC_ASSIGN:
21079 291188 : if (gfc_is_reallocatable_lhs (lvalue) && lvalue->rank == rvalue->rank)
21080 8552 : gfc_lvalue_allocated_at (lvalue->symtree->n.sym, &lvalue->where);
21081 :
21082 301625 : gcc_fallthrough();
21083 301625 : case EXEC_POINTER_ASSIGN:
21084 301625 : gfc_expr_set_at (lvalue, &rvalue->where, VALUE_VARDEF);
21085 : default:
21086 : break;
21087 : }
21088 : }
21089 712426 : }
21090 :
21091 : /* Examine all of the expressions associated with a program unit,
21092 : assign types to all intermediate expressions, make sure that all
21093 : assignments are to compatible types and figure out which names
21094 : refer to which functions or subroutines. It doesn't check code
21095 : block, which is handled by gfc_resolve_code. */
21096 :
21097 : static void
21098 373306 : resolve_types (gfc_namespace *ns)
21099 : {
21100 373306 : gfc_namespace *n;
21101 373306 : gfc_charlen *cl;
21102 373306 : gfc_data *d;
21103 373306 : gfc_equiv *eq;
21104 373306 : gfc_namespace* old_ns = gfc_current_ns;
21105 373306 : bool recursive = ns->proc_name && ns->proc_name->attr.recursive;
21106 :
21107 373306 : if (ns->types_resolved)
21108 : return;
21109 :
21110 : /* Check that all IMPLICIT types are ok. */
21111 370655 : if (!ns->seen_implicit_none)
21112 : {
21113 : unsigned letter;
21114 9340030 : for (letter = 0; letter != GFC_LETTERS; ++letter)
21115 8994103 : if (ns->set_flag[letter]
21116 8994103 : && !resolve_typespec_used (&ns->default_type[letter],
21117 : &ns->implicit_loc[letter], NULL))
21118 : return;
21119 : }
21120 :
21121 370654 : gfc_current_ns = ns;
21122 :
21123 370654 : resolve_entries (ns);
21124 :
21125 370654 : resolve_common_vars (&ns->blank_common, false);
21126 370654 : resolve_common_blocks (ns->common_root);
21127 :
21128 370654 : resolve_contained_functions (ns);
21129 :
21130 370654 : if (ns->proc_name && ns->proc_name->attr.flavor == FL_PROCEDURE
21131 317759 : && ns->proc_name->attr.if_source == IFSRC_IFBODY)
21132 211646 : gfc_resolve_formal_arglist (ns->proc_name);
21133 :
21134 370654 : gfc_traverse_ns (ns, resolve_bind_c_derived_types);
21135 :
21136 467584 : for (cl = ns->cl_list; cl; cl = cl->next)
21137 96930 : resolve_charlen (cl);
21138 :
21139 370654 : gfc_traverse_ns (ns, resolve_symbol);
21140 :
21141 370654 : resolve_fntype (ns);
21142 :
21143 421731 : for (n = ns->contained; n; n = n->sibling)
21144 : {
21145 : /* Exclude final wrappers with the test for the artificial attribute. */
21146 51077 : if (gfc_pure (ns->proc_name)
21147 5 : && !gfc_pure (n->proc_name)
21148 51077 : && !n->proc_name->attr.artificial)
21149 0 : gfc_error ("Contained procedure %qs at %L of a PURE procedure must "
21150 : "also be PURE", n->proc_name->name,
21151 : &n->proc_name->declared_at);
21152 :
21153 51077 : resolve_types (n);
21154 : }
21155 :
21156 370654 : forall_flag = 0;
21157 370654 : gfc_do_concurrent_flag = 0;
21158 370654 : gfc_check_interfaces (ns);
21159 :
21160 370654 : gfc_traverse_ns (ns, resolve_values);
21161 :
21162 370654 : if (ns->save_all || (!flag_automatic && !recursive))
21163 315 : gfc_save_all (ns);
21164 :
21165 370654 : iter_stack = NULL;
21166 373190 : for (d = ns->data; d; d = d->next)
21167 2536 : resolve_data (d);
21168 :
21169 370654 : iter_stack = NULL;
21170 370654 : gfc_traverse_ns (ns, gfc_formalize_init_value);
21171 :
21172 370654 : gfc_traverse_ns (ns, gfc_verify_binding_labels);
21173 :
21174 372219 : for (eq = ns->equiv; eq; eq = eq->next)
21175 1565 : resolve_equivalence (eq);
21176 :
21177 : /* Warn about unused labels. */
21178 370654 : if (warn_unused_label)
21179 4846 : warn_unused_fortran_label (ns->st_labels);
21180 :
21181 370654 : gfc_resolve_uops (ns->uop_root);
21182 :
21183 370654 : gfc_traverse_ns (ns, gfc_verify_DTIO_procedures);
21184 :
21185 370654 : gfc_resolve_omp_declare (ns);
21186 :
21187 370654 : gfc_resolve_omp_udrs (ns->omp_udr_root);
21188 :
21189 370654 : gfc_resolve_omp_udms (ns->omp_udm_root);
21190 :
21191 370654 : ns->types_resolved = 1;
21192 :
21193 370654 : gfc_current_ns = old_ns;
21194 : }
21195 :
21196 :
21197 : /* Call gfc_resolve_code recursively. */
21198 :
21199 : static void
21200 373368 : resolve_codes (gfc_namespace *ns)
21201 : {
21202 373368 : gfc_namespace *n;
21203 373368 : bitmap_obstack old_obstack;
21204 :
21205 373368 : if (ns->resolved == 1)
21206 15318 : return;
21207 :
21208 409189 : for (n = ns->contained; n; n = n->sibling)
21209 51139 : resolve_codes (n);
21210 :
21211 358050 : gfc_current_ns = ns;
21212 :
21213 : /* Don't clear 'cs_base' if this is the namespace of a BLOCK construct. */
21214 358050 : if (!(ns->proc_name && ns->proc_name->attr.flavor == FL_LABEL))
21215 344903 : cs_base = NULL;
21216 :
21217 : /* Set to an out of range value. */
21218 358050 : current_entry_id = -1;
21219 :
21220 358050 : old_obstack = labels_obstack;
21221 358050 : bitmap_obstack_initialize (&labels_obstack);
21222 :
21223 358050 : gfc_resolve_oacc_declare (ns);
21224 358050 : gfc_resolve_oacc_routines (ns);
21225 358050 : gfc_resolve_omp_local_vars (ns);
21226 358050 : if (ns->omp_allocate)
21227 62 : gfc_resolve_omp_allocate (ns, ns->omp_allocate);
21228 358050 : gfc_resolve_code (ns->code, ns);
21229 :
21230 358049 : bitmap_obstack_release (&labels_obstack);
21231 358049 : labels_obstack = old_obstack;
21232 : }
21233 :
21234 : /* Return true if the value of a variable can be considered used, either
21235 : through the value_used flag or because it is a suitable dummy argument. */
21236 :
21237 : static bool
21238 453 : var_value_is_used (gfc_symbol *sym)
21239 : {
21240 453 : if (sym->attr.value_used != VALUE_UNUSED)
21241 : return true;
21242 :
21243 107 : if (!sym->attr.dummy)
21244 : return false;
21245 :
21246 90 : if (sym->attr.value)
21247 : return false;
21248 :
21249 90 : switch (sym->attr.intent)
21250 : {
21251 : case INTENT_UNKNOWN:
21252 : case INTENT_INOUT:
21253 : case INTENT_OUT:
21254 : return true;
21255 :
21256 : case INTENT_IN:
21257 : default:
21258 : return false;
21259 : }
21260 : }
21261 :
21262 : /* Similar, see if the variable could have gotten its value from somewhere. */
21263 :
21264 : static bool
21265 2381 : var_value_is_set (gfc_symbol *sym)
21266 : {
21267 2381 : if (sym->attr.value_set != VALUE_UNSET)
21268 : return true;
21269 :
21270 1684 : if (sym->value)
21271 : return true;
21272 :
21273 1669 : if (sym->ts.type == BT_DERIVED
21274 1669 : && gfc_has_default_initializer (sym->ts.u.derived))
21275 : return true;
21276 :
21277 1669 : if (!sym->attr.dummy)
21278 : return false;
21279 :
21280 1624 : if (sym->attr.value)
21281 : return true;
21282 :
21283 1591 : if (sym->attr.intent == INTENT_OUT)
21284 3 : return false;
21285 :
21286 : return true;
21287 : }
21288 :
21289 : /* Callback function to catch set but never used variables. */
21290 :
21291 : static void
21292 34663 : find_unused_vs_set (gfc_symbol *sym)
21293 : {
21294 34663 : symbol_attribute *attr = &sym->attr;
21295 :
21296 34663 : if (attr->flavor != FL_VARIABLE)
21297 : return;
21298 :
21299 : /* Do not warn about anything too far out of the ordinary. This might be
21300 : tightened later. */
21301 8653 : if (attr->in_common || attr->in_equivalence || attr->artificial
21302 8247 : || attr->cray_pointer || attr->cray_pointee || attr->associate_var
21303 8244 : || attr->target || attr->fe_temp || attr->omp_declare_target
21304 8241 : || attr->omp_declare_target_link || attr->omp_declare_target_local
21305 8232 : || attr->omp_declare_target_indirect || attr->oacc_declare_create
21306 8232 : || attr->oacc_declare_copyin || attr->oacc_declare_deviceptr
21307 8232 : || attr->oacc_declare_device_resident || attr->oacc_declare_link
21308 8232 : || attr->result || attr->warning_emitted || attr->use_assoc
21309 5669 : || attr->volatile_ || attr->asynchronous || !attr->referenced)
21310 : return;
21311 :
21312 2449 : if (attr->host_assoc && attr->access != ACCESS_PRIVATE)
21313 : return;
21314 :
21315 : /* There is no allocation in sight, but the variable is used anyway. This
21316 : might be hidden behind PRESENT, but issue a warning nonetheless. If
21317 : people complain, we might want to make this to an extra option to be
21318 : included with -Wextra. */
21319 :
21320 2383 : if (warn_undefined_vars && attr->allocatable && !attr->allocated
21321 2435 : && var_value_is_used (sym))
21322 : {
21323 3 : if (attr->dummy && attr->intent == INTENT_OUT)
21324 : {
21325 0 : gfc_warning (OPT_Wundefined_vars, "Unallocated INTENT(OUT) variable "
21326 : "%qs referenced at %L", sym->name, &sym->other_loc);
21327 0 : attr->warning_emitted = 1;
21328 0 : return;
21329 : }
21330 :
21331 3 : if (!attr->dummy)
21332 : {
21333 2 : gfc_warning (OPT_Wundefined_vars, "Unallocated variable %qs "
21334 : "referenced at %L", sym->name, &sym->other_loc);
21335 2 : attr->warning_emitted = 1;
21336 2 : return;
21337 : }
21338 : }
21339 :
21340 2424 : if (warn_undefined_vars && !var_value_is_set (sym))
21341 : {
21342 : /* Warn about variables which have been allocated and used, but never
21343 : set. */
21344 48 : if (attr->allocated && sym->attr.value_used > VALUE_MAYBE_USED)
21345 : {
21346 3 : switch (sym->attr.value_used)
21347 : {
21348 1 : case VALUE_INTENT_IN:
21349 1 : gfc_warning (OPT_Wundefined_vars, "Allocated variable %qs passed "
21350 : "undefined to INTENT(IN) argument at %L", sym->name,
21351 : &sym->other_loc);
21352 1 : break;
21353 :
21354 1 : case VALUE_VALUE_ARG:
21355 1 : gfc_warning (OPT_Wundefined_vars, "Allocated variable %qs passed "
21356 : "undefined to VALUE argument at %L", sym->name,
21357 : &sym->other_loc);
21358 1 : break;
21359 1 : case VALUE_USED:
21360 1 : gfc_warning (OPT_Wundefined_vars, "Allocated undefined variable "
21361 : "%qs used at %L", sym->name, &sym->other_loc);
21362 1 : break;
21363 0 : default:
21364 0 : gfc_internal_error ("Wrong value_set");
21365 3 : break;
21366 : }
21367 3 : attr->warning_emitted = 1;
21368 3 : return;
21369 : }
21370 :
21371 : /* Similar, when undefined variables are passed to INTENT(IN), VALUE
21372 : arguments or are used in general. */
21373 :
21374 45 : if (attr->value_used == VALUE_INTENT_IN)
21375 : {
21376 1 : gfc_warning (OPT_Wundefined_vars, "Undefined variable %qs passed "
21377 : "to INTENT(IN) argument at %L", sym->name, &sym->other_loc);
21378 1 : attr->warning_emitted = 1;
21379 1 : return;
21380 : }
21381 44 : else if (attr->value_used == VALUE_VALUE_ARG)
21382 : {
21383 1 : gfc_warning (OPT_Wundefined_vars, "Undefined variable %qs passed "
21384 : "to VALUE argument at %L", sym->name, &sym->other_loc);
21385 1 : attr->warning_emitted = 1;
21386 1 : return;
21387 : }
21388 43 : else if (attr->value_used == VALUE_USED)
21389 : {
21390 9 : if (attr->dummy && attr->intent == INTENT_OUT)
21391 1 : gfc_warning (OPT_Wundefined_vars, "Undefined INTENT(OUT) variable %qs "
21392 : "used at %L", sym->name, &sym->other_loc);
21393 : else
21394 8 : gfc_warning (OPT_Wundefined_vars, "Undefined variable %qs used at "
21395 : "%L", sym->name, &sym->other_loc);
21396 :
21397 9 : attr->warning_emitted = 1;
21398 9 : return;
21399 : }
21400 :
21401 : /* PR 28004 - warn about INTENT(OUT) variables that are never set. If
21402 : the variable or a component are allocatable, do not warn since this is
21403 : a frequent shortcut for deallocation. */
21404 :
21405 34 : if (sym->attr.dummy && sym->attr.intent == INTENT_OUT
21406 2 : && !(attr->allocatable || attr->alloc_comp))
21407 : {
21408 0 : gfc_warning (OPT_Wundefined_vars, "INTENT(OUT) variable %qs "
21409 : "declared at %L is not assigned a value", sym->name,
21410 : &sym->declared_at);
21411 0 : attr->warning_emitted = 1;
21412 0 : return;
21413 : }
21414 : }
21415 :
21416 : /* Warn for unused but defined variables. */
21417 :
21418 2410 : if (warn_unused_but_set_variable)
21419 : {
21420 2302 : if (attr->value_set == VALUE_VARDEF && !var_value_is_used (sym))
21421 : {
21422 7 : gfc_warning (OPT_Wunused_but_set_variable_, "Variable %qs defined at "
21423 : "%L but never used", sym->name, &sym->other_loc);
21424 7 : attr->warning_emitted = 1;
21425 7 : return;
21426 : }
21427 2295 : if (attr->allocatable && !var_value_is_used (sym))
21428 : {
21429 2 : if (attr->allocated == ALLOCATED_ALLOCATE_STMT)
21430 : {
21431 1 : gfc_warning (OPT_Wunused_but_set_variable_, "Variable %qs "
21432 : "allocated at %L but never used", sym->name,
21433 : &sym->extra_loc);
21434 1 : attr->warning_emitted = 1;
21435 1 : return;
21436 : }
21437 1 : else if (attr->allocated == ALLOCATED_ARG)
21438 : {
21439 1 : gfc_warning (OPT_Wunused_but_set_variable_, "Variable %qs maybe "
21440 : "allocated as argument at %L but never used",
21441 : sym->name, &sym->extra_loc);
21442 1 : attr->warning_emitted = 1;
21443 1 : return;
21444 : }
21445 : }
21446 : }
21447 :
21448 : /* -Wunused-intent-out and -Wunused-read are enabled with -Wextra, so
21449 : check for these conditions at the end. If one of the warnings
21450 : with -Wall triggered, we do not want to issue a different warrning
21451 : for the same variable if the user supplies -Wall -Wextra instead
21452 : of only -Wall. */
21453 :
21454 39 : if (warn_unused_intent_out && attr->value_set == VALUE_INTENT_OUT
21455 2406 : && !var_value_is_used (sym))
21456 : {
21457 1 : gfc_warning (OPT_Wunused_intent_out, "Variable %qs passed to "
21458 : "INTENT(OUT) argument at %L but value never used",
21459 : sym->name, &sym->other_loc);
21460 1 : attr->warning_emitted = 1;
21461 1 : return;
21462 : }
21463 :
21464 2400 : if (warn_unused_read && attr->value_set == VALUE_READ && !var_value_is_used (sym))
21465 : {
21466 1 : gfc_warning (OPT_Wunused_read, "Variable %qs read at %L but never "
21467 : "used", sym->name, &sym->other_loc);
21468 1 : attr->warning_emitted = 1;
21469 1 : return;
21470 : }
21471 : }
21472 :
21473 : /* Run warn_unused_vs_set over a namespace recursively. */
21474 :
21475 : static void
21476 4875 : warn_unused_vs_set (gfc_namespace *ns)
21477 : {
21478 4875 : gfc_traverse_ns (ns, find_unused_vs_set);
21479 :
21480 5398 : for (gfc_namespace *n = ns->contained; n; n = n->sibling)
21481 523 : warn_unused_vs_set (n);
21482 4875 : }
21483 :
21484 : /* This function is called after a complete program unit has been compiled.
21485 : Its purpose is to examine all of the expressions associated with a program
21486 : unit, assign types to all intermediate expressions, make sure that all
21487 : assignments are to compatible types and figure out which names refer to
21488 : which functions or subroutines. */
21489 :
21490 : void
21491 327196 : gfc_resolve (gfc_namespace *ns, gfc_association_list *a)
21492 : {
21493 327196 : gfc_namespace *old_ns;
21494 327196 : code_stack *old_cs_base;
21495 327196 : struct gfc_omp_saved_state old_omp_state;
21496 :
21497 327196 : if (ns->resolved)
21498 4967 : return;
21499 :
21500 322229 : ns->resolved = -1;
21501 322229 : old_ns = gfc_current_ns;
21502 322229 : old_cs_base = cs_base;
21503 :
21504 : /* As gfc_resolve can be called during resolution of an OpenMP construct
21505 : body, we should clear any state associated to it, so that say NS's
21506 : DO loops are not interpreted as OpenMP loops. */
21507 322229 : if (!ns->construct_entities)
21508 309082 : gfc_omp_save_and_clear_state (&old_omp_state);
21509 :
21510 322229 : resolve_types (ns);
21511 322229 : component_assignment_level = 0;
21512 322229 : resolve_codes (ns);
21513 322228 : mark_assoc_used (a);
21514 :
21515 322228 : if (warn_unused_but_set_variable || warn_unused_intent_out
21516 317934 : || warn_unused_read || warn_undefined_vars)
21517 : {
21518 4376 : int error_count;
21519 4376 : gfc_get_errors (NULL, &error_count);
21520 4376 : if (error_count == 0)
21521 4352 : warn_unused_vs_set (ns);
21522 : }
21523 :
21524 322228 : if (ns->omp_assumes)
21525 16 : gfc_resolve_omp_assumptions (ns->omp_assumes);
21526 :
21527 322228 : gfc_current_ns = old_ns;
21528 322228 : cs_base = old_cs_base;
21529 322228 : ns->resolved = 1;
21530 :
21531 322228 : gfc_run_passes (ns);
21532 :
21533 322228 : if (!ns->construct_entities)
21534 309081 : gfc_omp_restore_state (&old_omp_state);
21535 : }
|